2022-10-21 12:04:10 +02:00
{
"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.<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",
" 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)^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.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
" RtQ = FractionField(Rt)\n",
" RptW.<W> = 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.<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": 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",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
" self.base_ring = F\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" Rxy.<x, y> = PolynomialRing(F, 2)\n",
" Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
2022-10-21 12:04:10 +02:00
"\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",
2022-10-26 17:43:09 +02:00
" p = self.characteristic\n",
" return p^n*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",
2022-10-21 12:04:10 +02:00
" \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",
2022-10-26 17:43:09 +02:00
" p = self.characteristic\n",
2022-10-21 12:04:10 +02:00
" return sum(p^(n-j-1)*(jumps[i][j]+1)*(p-1) for j in range(n))\n",
"\n",
2022-10-26 17:43:09 +02:00
" def exponent_of_different_prim(self, i = 0):\n",
" jumps = self.jumps\n",
" n = self.height\n",
" delta = self.nb_of_pts_at_infty\n",
" p = self.characteristic\n",
" return sum(p^(n-j-1)*(jumps[i][j])*(p-1) for j in range(n))\n",
" \n",
" def holomorphic_differentials_basis(self, parameter = 8):\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = self.base_ring\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
2022-10-26 17:43:09 +02:00
" Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
2022-10-21 12:04:10 +02:00
" #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",
2022-10-26 17:43:09 +02:00
" for i in range(0, parameter*r):\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-11-01 18:40:44 +01:00
" return holomorphic_differentials_basis(self, parameter = parameter + 1)\n",
" if len(forms) > self.genus():\n",
" print(\"Increase precision.\")\n",
2022-10-21 12:04:10 +02:00
" return forms\n",
2022-10-26 17:43:09 +02:00
" \n",
" ##find fcts with pole order in infty's at most pole_order\n",
2022-11-01 18:40:44 +01:00
" def at_most_poles(self, pole_order, parameter = 8):\n",
2022-10-26 17:43:09 +02:00
" from itertools import product\n",
" x_series = self.x\n",
" y_series = self.y\n",
" z_series = self.z\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",
" F = self.base_ring\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(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" Rt.<t> = LaurentSeriesRing(F, 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",
2022-11-01 18:40:44 +01:00
" for i in range(0, parameter*r):\n",
2022-10-26 17:43:09 +02:00
" for j in range(0, m):\n",
" for k in product(*pr):\n",
" eta = as_function(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_fcts(S, pole_order)\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_fcts(forms, pole_order)\n",
" \n",
" return forms\n",
" \n",
2022-11-01 18:40:44 +01:00
" def magical_element(self, parameter = 8):\n",
" list_of_elts = self.at_most_poles(self.exponent_of_different_prim(), parameter)\n",
2022-10-26 17:43:09 +02:00
" result = []\n",
" for a in list_of_elts:\n",
" if a.trace().function != 0:\n",
" result += [a]\n",
" return result\n",
"\n",
2022-11-01 18:40:44 +01:00
" def pseudo_magical_element(self, parameter = 8):\n",
" list_of_elts = self.at_most_poles(self.exponent_of_different(), parameter)\n",
2022-10-26 17:43:09 +02:00
" result = []\n",
" for a in list_of_elts:\n",
" if a.trace().function != 0:\n",
" result += [a]\n",
" return result\n",
" \n",
" ##find fcts with pole order in infty's at most pole_order\n",
2022-11-01 18:40:44 +01:00
" def at_most_poles_forms(self, pole_order, parameter = 8):\n",
2022-10-26 17:43:09 +02:00
" from itertools import product\n",
" x_series = self.x\n",
" y_series = self.y\n",
" z_series = self.z\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",
" F = self.base_ring\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(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" Rt.<t> = LaurentSeriesRing(F, 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",
2022-11-01 18:40:44 +01:00
" for i in range(0, parameter*r):\n",
2022-10-26 17:43:09 +02:00
" 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",
2022-10-21 12:04:10 +02:00
"\n",
2022-10-26 17:43:09 +02:00
" forms = holomorphic_combinations_forms(S, pole_order)\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(forms, pole_order)\n",
" \n",
" return forms\n",
" \n",
2022-10-21 12:04:10 +02:00
"#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",
2022-10-26 17:43:09 +02:00
" F = C_AS.base_ring\n",
2022-10-21 12:04:10 +02:00
" prec = C_AS.prec\n",
" Rt.<t> = 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",
2022-10-26 17:43:09 +02:00
" M = matrix(F, list_of_lists)\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
2022-10-21 12:04:10 +02:00
" n = C.height\n",
" variable_names = 'x, y'\n",
" for i in range(n):\n",
" variable_names += ', z' + str(i)\n",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" self.function = RxyzQ(g)\n",
2022-10-26 17:43:09 +02:00
"\n",
" def __repr__(self):\n",
" return str(self.function)\n",
"\n",
" def __add__(self, other):\n",
" C = self.curve\n",
" g1 = self.function\n",
" g2 = other.function\n",
" return as_function(C, g1 + g2)\n",
"\n",
" def __sub__(self, other):\n",
" C = self.curve\n",
" g1 = self.function\n",
" g2 = other.function\n",
" return as_function(C, g1 - g2)\n",
"\n",
" def __rmul__(self, constant):\n",
" C = self.curve\n",
" g = self.function\n",
" return as_function(C, constant*g)\n",
"\n",
" def expansion_at_infty(self, i = 0):\n",
" C = self.curve\n",
" delta = C.nb_of_pts_at_infty\n",
" F = C.base_ring\n",
" x_series = C.x[i]\n",
" y_series = C.y[i]\n",
" z_series = C.z[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(F, 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.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
" g = self.function\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)\n",
"\n",
" def group_action(self, ZN_tuple):\n",
" C = self.curve\n",
" n = C.height\n",
" F = C.base_ring\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, 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.function\n",
" return as_form(C, g.substitute(sub_list))\n",
"\n",
" def trace(self):\n",
" C = self.curve\n",
" C_super = C.quotient\n",
" n = C.height\n",
" F = C.base_ring\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" g = self.function\n",
" result = RxyzQ(0)\n",
" g_num = Rxyz(numerator(g))\n",
" g_den = Rxyz(denominator(g))\n",
" z = prod(z[i] for i in range(n))^(p-1)\n",
" for a in g_num.monomials():\n",
" if (z.divides(a)):\n",
" result += g_num.monomial_coefficient(a)*a/z\n",
" result /= g_den\n",
" Rxy.<x, y> = PolynomialRing(F, 2)\n",
" return superelliptic_function(C_super, Rxy(result))\n",
2022-10-21 12:04:10 +02:00
" \n",
"class as_form:\n",
" def __init__(self, C, g):\n",
" self.curve = C\n",
" n = C.height\n",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
2022-10-21 12:04:10 +02:00
" variable_names = 'x, y'\n",
" for i in range(n):\n",
" variable_names += ', z' + str(i)\n",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" prec = C.prec\n",
2022-10-26 17:43:09 +02:00
" Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
2022-10-21 12:04:10 +02:00
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-11-01 18:40:44 +01:00
"\n",
" #Find coordinates of the given form self in terms of the basis forms in a list \"holo\"\n",
" def coordinates(self, holo):\n",
2022-10-26 17:43:09 +02:00
" C = self.curve\n",
" n = C.height\n",
" gC = C.genus()\n",
" F = C.base_ring\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" from sage.rings.polynomial.toy_variety import linear_representation\n",
" return linear_representation(Rxyz(self.form), holo)\n",
2022-10-21 12:04:10 +02:00
"\n",
2022-10-26 17:43:09 +02:00
" def trace(self):\n",
" C = self.curve\n",
" C_super = C.quotient\n",
" n = C.height\n",
" F = C.base_ring\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" RxyzQ = FractionField(Rxyz)\n",
" g = self.form\n",
" result = RxyzQ(0)\n",
" g_num = Rxyz(numerator(g))\n",
" g_den = Rxyz(denominator(g))\n",
" z = prod(z[i] for i in range(n))^(p-1)\n",
" for a in g_num.monomials():\n",
" if (z.divides(a)):\n",
" result += g_num.monomial_coefficient(a)*a/z\n",
" result /= g_den\n",
" Rxy.<x, y> = PolynomialRing(F, 2)\n",
" return superelliptic_form(C_super, Rxy(result))\n",
" \n",
2022-10-21 12:04:10 +02:00
"# 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.<t> = 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.<t> = 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",
2022-10-26 17:43:09 +02:00
" correction += coeff.nth_root(p)*t^(-M)\n",
" power_series = power_series - (coeff*t^(-p*M) - coeff.nth_root(p)*t^(-M))\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = C.base_ring\n",
2022-10-21 12:04:10 +02:00
" n = C.height\n",
" variable_names = 'x, y'\n",
" for i in range(n):\n",
" variable_names += ', z' + str(i)\n",
2022-10-26 17:43:09 +02:00
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
2022-10-21 12:04:10 +02:00
" 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",
2022-10-26 17:43:09 +02:00
" F = C_AS.base_ring\n",
" n = C_AS.height\n",
" holo = C_AS.holomorphic_differentials_basis()\n",
" holo_forms = [omega.form for omega in holo]\n",
" denom = LCM([denominator(omega) for omega in holo_forms])\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" holo_forms = [Rxyz(omega*denom) for omega in holo_forms]\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",
" omega1 = denom * omega1\n",
2022-11-01 18:40:44 +01:00
" v1 = omega1.coordinates(holo_forms)\n",
2022-10-26 17:43:09 +02:00
" A[i] += [v1]\n",
" for i in range(n):\n",
" A[i] = matrix(F, A[i])\n",
" A[i] = A[i].transpose()\n",
" return A\n",
"\n",
2022-11-01 18:40:44 +01:00
"def group_action_matrices_log(C_AS):\n",
2022-10-26 17:43:09 +02:00
" F = C_AS.base_ring\n",
" n = C_AS.height\n",
" holo = C_AS.at_most_poles_forms(1)\n",
" holo_forms = [omega.form for omega in holo]\n",
" denom = LCM([denominator(omega) for omega in holo_forms])\n",
" variable_names = 'x, y'\n",
" for j in range(n):\n",
" variable_names += ', z' + str(j)\n",
" Rxyz = PolynomialRing(F, n+2, variable_names)\n",
" x, y = Rxyz.gens()[:2]\n",
" z = Rxyz.gens()[2:]\n",
" holo_forms = [Rxyz(omega*denom) for omega in holo_forms]\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",
" omega1 = denom * omega1\n",
2022-11-01 18:40:44 +01:00
" v1 = omega1.coordinates(holo_forms)\n",
2022-10-26 17:43:09 +02:00
" A[i] += [v1]\n",
" for i in range(n):\n",
" A[i] = matrix(F, A[i])\n",
" A[i] = A[i].transpose()\n",
" return A\n",
"\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_fcts(S, pole_order):\n",
" C_AS = S[0][0].curve\n",
" p = C_AS.characteristic\n",
" F = C_AS.base_ring\n",
" prec = C_AS.prec\n",
" Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
" RtQ = FractionField(Rt)\n",
" minimal_valuation = min([Rt(g[1]).valuation() for g in S])\n",
" if minimal_valuation >= -pole_order:\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 + Rt(eta_exp).valuation()\n",
" list_coeffs = a*[0] + Rt(eta_exp).list() + (-minimal_valuation)*[0]\n",
" list_coeffs = list_coeffs[:-minimal_valuation - pole_order]\n",
" list_of_lists += [list_coeffs]\n",
" M = matrix(F, 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_function(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",
"#given a set S of (form, corresponding Laurent series at some pt), find their combinations holomorphic at that pt\n",
"def holomorphic_combinations_forms(S, pole_order):\n",
" C_AS = S[0][0].curve\n",
" p = C_AS.characteristic\n",
" F = C_AS.base_ring\n",
" prec = C_AS.prec\n",
" Rt.<t> = LaurentSeriesRing(F, default_prec=prec)\n",
" RtQ = FractionField(Rt)\n",
" minimal_valuation = min([Rt(g[1]).valuation() for g in S])\n",
" if minimal_valuation >= -pole_order:\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 + Rt(eta_exp).valuation()\n",
" list_coeffs = a*[0] + Rt(eta_exp).list() + (-minimal_valuation)*[0]\n",
" list_coeffs = list_coeffs[:-minimal_valuation - pole_order]\n",
" list_of_lists += [list_coeffs]\n",
" M = matrix(F, 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",
"#print only forms that are log at the branch pts, but not holomorphic\n",
"def only_log_forms(C_AS):\n",
" list1 = AS.at_most_poles_forms(0)\n",
" list2 = AS.at_most_poles_forms(1)\n",
" result = []\n",
" for a in list2:\n",
" if not(are_forms_linearly_dependent(list1 + result + [a])):\n",
" result += [a]\n",
2022-11-01 18:40:44 +01:00
" return result\n",
"\n",
"#find decomposition into indecomposables using magma\n",
"def magmathis(A, B, p, deg = 1):\n",
" n = A.dimensions()[0]\n",
" A = str(list(A))\n",
" B = str(list(B))\n",
" A = A.replace(\"(\", \"\")\n",
" A = A.replace(\")\", \"\")\n",
" B = B.replace(\"(\", \"\")\n",
" B = B.replace(\")\", \"\")\n",
" result = \"A := MatrixAlgebra<GF(\"+str(p)+\"^\" + str(deg) + \"),\"+ str(n) + \"|\"\n",
" result += A + \",\" + B\n",
" result += \">;\"\n",
" result += \"M := RModule(RSpace(GF(\"+str(p)+\"^\" + str(deg)+\"),\" + str(n) + \"), A);\"\n",
" result += \"IndecomposableSummands(M);\"\n",
" print(magma_free(result))"
2022-10-26 17:43:09 +02:00
]
},
{
"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.<x> = PolynomialRing(GF(p))\n",
"f = x^3 + x^2 + 1\n",
"C_super = superelliptic(f, m)\n",
"Rxy.<x, y> = 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.<x> = PolynomialRing(GF(p))\n",
"f = x^3 + x^2 + 1\n",
"C_super = superelliptic(f, m)\n",
"Rxy.<x, y> = 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",
2022-10-21 12:04:10 +02:00
"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.<x> = 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.<x, y> = 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",
2022-10-26 17:43:09 +02:00
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"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 [3]\u001b[0m, in \u001b[0;36m<cell line: 14>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 12\u001b[0m f2 \u001b[38;5;241m=\u001b[39m superelliptic_function(C_super, x\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mInteger(\u001b[38;5;241m3\u001b[39m))\n\u001b[1;32m 13\u001b[0m AS \u001b[38;5;241m=\u001b[39m as_cover(C_super, [f1, f2], prec\u001b[38;5;241m=\u001b[39mInteger(\u001b[38;5;241m300\u001b[39m))\n\u001b[0;32m---> 14\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mAS\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmagical_element\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n",
"Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mas_cover.magical_element\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmagical_element\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 171\u001b[0m list_of_elts \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mat_most_poles\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexponent_of_different_prim\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 172\u001b[0m result \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m list_of_elts:\n",
"Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mas_cover.at_most_poles\u001b[0;34m(self, pole_order)\u001b[0m\n\u001b[1;32m 159\u001b[0m eta_exp \u001b[38;5;241m=\u001b[39m eta\u001b[38;5;241m.\u001b[39mexpansion_at_infty()\n\u001b[1;32m 160\u001b[0m S \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m [(eta, eta_exp)]\n\u001b[0;32m--> 162\u001b[0m forms \u001b[38;5;241m=\u001b[39m \u001b[43mholomorphic_combinations_fcts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mS\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpole_order\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(Integer(\u001b[38;5;241m1\u001b[39m), delta):\n\u001b[1;32m 165\u001b[0m forms \u001b[38;5;241m=\u001b[39m [(omega, omega\u001b[38;5;241m.\u001b[39mexpansion_at_infty(i \u001b[38;5;241m=\u001b[39m i)) \u001b[38;5;28;01mfor\u001b[39;00m omega \u001b[38;5;129;01min\u001b[39;00m forms]\n",
"Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mholomorphic_combinations_fcts\u001b[0;34m(S, pole_order)\u001b[0m\n\u001b[1;32m 599\u001b[0m eta \u001b[38;5;241m=\u001b[39m elt_S[Integer(\u001b[38;5;241m0\u001b[39m)]\n\u001b[1;32m 600\u001b[0m \u001b[38;5;66;03m#eta_exp = elt_S[1]\u001b[39;00m\n\u001b[0;32m--> 601\u001b[0m forma_holo \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[43mvec_wspolrzedna\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43meta\u001b[49m\n\u001b[1;32m 602\u001b[0m \u001b[38;5;66;03m#forma_holo_power_series += vec_wspolrzedna*eta_exp\u001b[39;00m\n\u001b[1;32m 603\u001b[0m forms \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m [forma_holo]\n",
"File \u001b[0;32m/ext/sage/9.7/src/sage/structure/element.pyx:1528\u001b[0m, in \u001b[0;36msage.structure.element.Element.__mul__\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1526\u001b[0m if not err:\n\u001b[1;32m 1527\u001b[0m return (<Element>right)._mul_long(value)\n\u001b[0;32m-> 1528\u001b[0m return coercion_model.bin_op(left, right, mul)\n\u001b[1;32m 1529\u001b[0m except TypeError:\n\u001b[1;32m 1530\u001b[0m return NotImplemented\n",
"File \u001b[0;32m/ext/sage/9.7/src/sage/structure/coerce.pyx:1242\u001b[0m, in \u001b[0;36msage.structure.coerce.CoercionModel.bin_op\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1240\u001b[0m mul_method = getattr(y, '__r%s__'%op_name, None)\n\u001b[1;32m 1241\u001b[0m if mul_method is not None:\n\u001b[0;32m-> 1242\u001b[0m res = mul_method(x)\n\u001b[1;32m 1243\u001b[0m if res is not None and res is not NotImplemented:\n\u001b[1;32m 1244\u001b[0m return res\n",
"Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mas_function.__rmul__\u001b[0;34m(self, constant)\u001b[0m\n\u001b[1;32m 285\u001b[0m C \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcurve\n\u001b[1;32m 286\u001b[0m g \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction\n\u001b[0;32m--> 287\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mas_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mC\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mconstant\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mg\u001b[49m\u001b[43m)\u001b[49m\n",
"Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36mas_function.__init__\u001b[0;34m(self, C, g)\u001b[0m\n\u001b[1;32m 261\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(n):\n\u001b[1;32m 262\u001b[0m variable_names \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m, z\u001b[39m\u001b[38;5;124m'\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(i)\n\u001b[0;32m--> 263\u001b[0m Rxyz \u001b[38;5;241m=\u001b[39m \u001b[43mPolynomialRing\u001b[49m\u001b[43m(\u001b[49m\u001b[43mF\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn\u001b[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\u001b[43m \u001b[49m\u001b[43mvariable_names\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 264\u001b[0m x, y \u001b[38;5;241m=\u001b[39m Rxyz\u001b[38;5;241m.\u001b[39mgens()[:Integer(\u001b[38;5;241m2\u001b[39m)]\n\u001b[1;32m 265\u001b[0m z \u001b[38;5;241m=\u001b[39m Rxyz\u001b[38;5;241m.\u001b[39mgens()[Integer(\u001b[38;5;241m2\u001b[39m):]\n",
"File \u001b[0;32m/ext/sage/9.7/src/sage/rings/polynomial/polynomial_ring_constructor.py:609\u001b[0m, in \u001b[0;36mPolynomialRing\u001b[0;34m(base_ring, *args, **kwds)\u001b[0m\n\u001b[1;32m 607\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m arg \u001b[38;5;129;01min\u001b[39;00m args:\n\u001b[1;32m 608\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 609\u001b[0m k \u001b[38;5;241m=\u001b[39m \u001b[43mInteger\u001b[49m\u001b[43m(\u001b[49m\u001b[43marg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 610\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 611\u001b[0m \u001b[38;5;66;03m# Interpret arg as names\u001b[39;00m\n\u001b[1;32m 612\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m names \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
"File \u001b[0;32m/ext/sage/9.7/src/sage/rings/integer.pyx:678\u001b[0m, in \u001b[0;36msage.rings.integer.Integer.__init__\u001b[0;34m()\u001b[0m\n\u001b[1;32m 676\u001b[0m if '_' in x:\n\u001b[1;32m 677\u001b[0m x = x.replace('_', '')\n\u001b[0;32m--> 678\u001b[0m mpz_set_str_python(self.value, str_to_bytes(x), base)\n\u001b[1;32m 679\u001b[0m return\n\u001b[1;32m 680\u001b[0m \n",
"File \u001b[0;32m/ext/sage/9.7/src/sage/rings/integer.pyx:7112\u001b[0m, in \u001b[0;36msage.rings.integer.mpz_set_str_python\u001b[0;34m()\u001b[0m\n\u001b[1;32m 7110\u001b[0m assert base >= 2\n\u001b[1;32m 7111\u001b[0m if mpz_set_str(z, x, base) != 0:\n\u001b[0;32m-> 7112\u001b[0m raise TypeError(\"unable to convert %r to an integer\" % char_to_str(s))\n\u001b[1;32m 7113\u001b[0m if sign < 0:\n\u001b[1;32m 7114\u001b[0m mpz_neg(z, z)\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 = 5\n",
"m = 3\n",
"#F = GF(p)\n",
"F = GF(p^2, 'a')\n",
"a = F.gen()\n",
"Rx.<x> = PolynomialRing(F)\n",
"f = x^m + 1\n",
"C_super = superelliptic(f, m)\n",
"\n",
"Rxy.<x, y> = PolynomialRing(F, 2)\n",
"f1 = superelliptic_function(C_super, x)\n",
"f2 = superelliptic_function(C_super, x^3)\n",
"AS = as_cover(C_super, [f1, f2], prec=300)\n",
"print(AS.magical_element())"
]
},
{
"cell_type": "code",
"execution_count": 8,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
2022-10-26 17:43:09 +02:00
"[1,\n",
" z1,\n",
" z1^2,\n",
" z0,\n",
" z0*z1,\n",
" -x*z0^2 + z0*z1^2,\n",
" z0^2,\n",
" z0^2*z1,\n",
" z0^2*z1^2 + x*z0*z1 + x^2,\n",
" y,\n",
" -y*z0^2 + y*z1,\n",
" y*z0,\n",
" x,\n",
" -x*z0^2 + x*z1,\n",
" x*z0]"
2022-10-21 12:04:10 +02:00
]
},
2022-10-26 17:43:09 +02:00
"execution_count": 8,
2022-10-21 12:04:10 +02:00
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
2022-10-26 17:43:09 +02:00
"AS.at_most_poles(14)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
]
},
{
"cell_type": "code",
"execution_count": 35,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
2022-10-26 17:43:09 +02:00
"data": {
"text/plain": [
"[((z0^2*z1^2 + x*z0*z1 + x^2)/y) * dx]"
]
},
"execution_count": 35,
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
"only_log_forms(AS)"
]
},
{
"cell_type": "code",
"execution_count": 162,
"metadata": {
"collapsed": false
},
"outputs": [
2022-10-21 12:04:10 +02:00
{
"name": "stdout",
"output_type": "stream",
"text": [
2022-10-26 17:43:09 +02:00
"I haven't found all forms.\n",
"[1]\n"
2022-10-21 12:04:10 +02:00
]
2022-10-26 17:43:09 +02:00
}
],
"source": [
"dpp = AS.exponent_of_different_prim()\n",
"print(at_most_poles(AS, dpp))"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": false
},
"outputs": [
2022-10-21 12:04:10 +02:00
{
"name": "stdout",
2022-10-26 17:43:09 +02:00
"output_type": "stream",
"text": [
"((z0*z1^2 - z1^2 + (a + 1)*x)/y) * dx\n"
2022-10-21 12:04:10 +02:00
]
}
],
"source": [
2022-10-26 17:43:09 +02:00
"Rxy.<x, y, z0, z1> = PolynomialRing(F, 4)\n",
"omega = as_form(AS, z0^2*z1^2/y - (a+1)*z0*x/y)\n",
"print(omega - omega.group_action([1, 0]))"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 78,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
2022-10-26 17:43:09 +02:00
{
"data": {
"text/plain": [
"a*t^-10 + 2*t^-8 + a*t^-6 + (a + 1)*t^-2 + O(t^288)"
]
},
"execution_count": 78,
"metadata": {
},
"output_type": "execute_result"
}
2022-10-21 12:04:10 +02:00
],
"source": [
2022-10-26 17:43:09 +02:00
"g = as_function(AS, z0^2*z1^2+z0*(a+1)*x)\n",
"g.expansion_at_infty(i = 0)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 18,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
2022-11-01 18:40:44 +01:00
"p = 7\n",
"m = 2\n",
2022-10-26 17:43:09 +02:00
"F = GF(p)\n",
"Rx.<x> = PolynomialRing(F)\n",
2022-11-01 18:40:44 +01:00
"f = x^3 + 1\n",
2022-10-21 12:04:10 +02:00
"C_super = superelliptic(f, m)\n",
2022-10-26 17:43:09 +02:00
"\n",
"Rxy.<x, y> = PolynomialRing(F, 2)\n",
2022-11-01 18:40:44 +01:00
"f1 = superelliptic_function(C_super, x^2*y)\n",
"f2 = superelliptic_function(C_super, x^3)\n",
"AS = as_cover(C_super, [f1, f2], prec=1000)\n",
"#print(AS.magical_element())\n",
"#print(AS.pseudo_magical_element())"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 19,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
2022-11-01 18:40:44 +01:00
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"True\n",
"True\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
}
2022-10-21 12:04:10 +02:00
],
"source": [
2022-11-01 18:40:44 +01:00
"#A, B = group_action_matrices2_log(AS1)\n",
"A, B = group_action_matrices2(AS)\n",
"n = A.dimensions()[0]\n",
"print(A*B == B*A)\n",
"print(A^p == identity_matrix(n))\n",
"print(B^p == identity_matrix(n))\n",
"magmathis(A, B, p, deg = 1)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 10,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
2022-11-01 18:40:44 +01:00
{
"name": "stdout",
"output_type": "stream",
"text": [
"t^-5 + 2*t + O(t^5)\n",
"t^-6 + 3 + O(t^4)\n"
]
}
2022-10-21 12:04:10 +02:00
],
"source": [
2022-11-01 18:40:44 +01:00
"print(f1.expansion_at_infty())\n",
"print(f2.expansion_at_infty())"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 48,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
2022-10-26 17:43:09 +02:00
"[z0^2]"
2022-10-21 12:04:10 +02:00
]
},
2022-10-26 17:43:09 +02:00
"execution_count": 48,
2022-10-21 12:04:10 +02:00
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
2022-10-26 17:43:09 +02:00
"AS.magical_element()"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 51,
2022-10-21 12:04:10 +02:00
"metadata": {
2022-10-26 17:43:09 +02:00
"collapsed": false,
"scrolled": true
2022-10-21 12:04:10 +02:00
},
"outputs": [
{
"data": {
"text/plain": [
2022-10-26 17:43:09 +02:00
"68"
2022-10-21 12:04:10 +02:00
]
},
2022-10-26 17:43:09 +02:00
"execution_count": 51,
2022-10-21 12:04:10 +02:00
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
2022-10-26 17:43:09 +02:00
"AS1.exponent_of_different_prim()"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 16,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
2022-11-01 18:40:44 +01:00
"p = 3\n",
2022-10-21 12:04:10 +02:00
"m = 2\n",
2022-10-26 17:43:09 +02:00
"F = GF(p)\n",
"#F = GF(p^2, 'a')\n",
"#a = F.gen()\n",
"Rx.<x> = PolynomialRing(F)\n",
"f = x^2 + 1\n",
2022-10-21 12:04:10 +02:00
"C_super = superelliptic(f, m)\n",
"\n",
2022-10-26 17:43:09 +02:00
"Rxy.<x, y> = PolynomialRing(F, 2)\n",
2022-11-01 18:40:44 +01:00
"f1 = superelliptic_function(C_super, x)\n",
2022-10-21 12:04:10 +02:00
"f2 = superelliptic_function(C_super, x^2)\n",
2022-10-26 17:43:09 +02:00
"AS1 = as_cover(C_super, [f1, f2], prec=300)\n",
2022-11-01 18:40:44 +01:00
"#print(AS1.pseudo_magical_element())\n",
"#print(AS1.magical_element())"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 17,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
2022-10-26 17:43:09 +02:00
"#A, B = group_action_matrices2_log(AS1)\n",
2022-11-01 18:40:44 +01:00
"A, B = group_action_matrices(AS1)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 56,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
2022-10-26 17:43:09 +02:00
"68"
2022-10-21 12:04:10 +02:00
]
},
2022-10-26 17:43:09 +02:00
"execution_count": 56,
2022-10-21 12:04:10 +02:00
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
2022-10-26 17:43:09 +02:00
"AS1.genus()"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 57,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
2022-10-26 17:43:09 +02:00
"196"
2022-10-21 12:04:10 +02:00
]
},
2022-10-26 17:43:09 +02:00
"execution_count": 57,
2022-10-21 12:04:10 +02:00
"metadata": {
},
"output_type": "execute_result"
}
],
"source": [
2022-10-26 17:43:09 +02:00
"lll = AS1.holomorphic_differentials_basis()\n",
"len(lll)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 6,
2022-10-26 17:43:09 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
2022-11-01 18:40:44 +01:00
{
"ename": "NameError",
"evalue": "name 'AS1' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m#A, B = group_action_matrices2_log(AS1)\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m A, B \u001b[38;5;241m=\u001b[39m group_action_matrices2(\u001b[43mAS1\u001b[49m)\n",
"\u001b[0;31mNameError\u001b[0m: name 'AS1' is not defined"
]
}
2022-10-26 17:43:09 +02:00
],
"source": [
"#A, B = group_action_matrices2_log(AS1)\n",
"A, B = group_action_matrices2(AS1)"
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 18,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
2022-10-26 17:43:09 +02:00
"True\n",
"True\n",
"True\n"
2022-10-21 12:04:10 +02:00
]
2022-10-26 17:43:09 +02:00
}
],
"source": [
"n = A.dimensions()[0]\n",
"print(A*B == B*A)\n",
"print(A^p == identity_matrix(n))\n",
"print(B^p == identity_matrix(n))"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false
},
"outputs": [
2022-10-21 12:04:10 +02:00
{
2022-10-26 17:43:09 +02:00
"data": {
"text/plain": [
"28"
]
},
"execution_count": 29,
"metadata": {
},
"output_type": "execute_result"
2022-10-21 12:04:10 +02:00
}
],
"source": [
2022-10-26 17:43:09 +02:00
"n"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 7,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
]
},
{
"cell_type": "code",
2022-10-26 17:43:09 +02:00
"execution_count": 34,
2022-10-21 12:04:10 +02:00
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
2022-10-26 17:43:09 +02:00
"[\n",
"RModule of dimension 1 over GF(3^2),\n",
"RModule of dimension 1 over GF(3^2),\n",
"RModule of dimension 3 over GF(3^2),\n",
"RModule of dimension 3 over GF(3^2),\n",
"RModule of dimension 6 over GF(3^2),\n",
"RModule of dimension 6 over GF(3^2),\n",
"RModule of dimension 8 over GF(3^2)\n",
"]\n"
2022-10-21 12:04:10 +02:00
]
}
],
"source": [
2022-10-26 17:43:09 +02:00
"magmathis(A, B, 3, deg = 2)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
"def magmatxt(A, B, p, deg = 1):\n",
" n = A.dimensions()[0]\n",
" A = str(list(A))\n",
" B = str(list(B))\n",
" A = A.replace(\"(\", \"\")\n",
" A = A.replace(\")\", \"\")\n",
" B = B.replace(\"(\", \"\")\n",
" B = B.replace(\")\", \"\")\n",
" result = \"A := MatrixAlgebra<GF(\"+str(p)+\"^\" + str(deg) + \"),\"+ str(n) + \"|\"\n",
" result += A + \",\" + B\n",
" result += \">;\"\n",
" result += \"M := RModule(RSpace(GF(\"+str(p)+\"^\" + str(deg)+\"),\" + str(n) + \"), A);\"\n",
" result += \"IndecomposableSummands(M);\"\n",
" print(result)"
]
},
{
"cell_type": "code",
"execution_count": 19,
2022-10-21 12:04:10 +02:00
"metadata": {
2022-10-26 17:43:09 +02:00
"collapsed": false
2022-10-21 12:04:10 +02:00
},
"outputs": [
{
2022-11-01 18:40:44 +01:00
"name": "stdout",
"output_type": "stream",
"text": [
"A := MatrixAlgebra<GF(3^1),14|[1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 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, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]>;M := RModule(RSpace(GF(3^1),14), A);IndecomposableSummands(M);\n"
]
2022-10-21 12:04:10 +02:00
}
],
"source": [
2022-11-01 18:40:44 +01:00
"magmatxt(A, B, p)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
2022-11-01 18:40:44 +01:00
"execution_count": 21,
2022-10-21 12:04:10 +02:00
"metadata": {
2022-11-01 18:40:44 +01:00
"collapsed": false,
"scrolled": true
2022-10-21 12:04:10 +02:00
},
"outputs": [
{
2022-11-01 18:40:44 +01:00
"name": "stderr",
"output_type": "stream",
"text": [
"WARNING: Some output was deleted.\n"
2022-10-26 17:43:09 +02:00
]
2022-10-21 12:04:10 +02:00
}
],
"source": [
2022-11-01 18:40:44 +01:00
"magmatxtx(A, B, p)"
2022-10-21 12:04:10 +02:00
]
},
{
"cell_type": "code",
"execution_count": 0,
"metadata": {
"collapsed": false
},
"outputs": [
],
"source": [
2022-11-01 18:40:44 +01:00
"def magmathis(A, B, p, deg = 1):\n",
" n = A.dimensions()[0]\n",
" A = str(list(A))\n",
" B = str(list(B))\n",
" A = A.replace(\"(\", \"\")\n",
" A = A.replace(\")\", \"\")\n",
" B = B.replace(\"(\", \"\")\n",
" B = B.replace(\")\", \"\")\n",
" result = \"A := MatrixAlgebra<GF(\"+str(p)+\"^\" + str(deg) + \"),\"+ str(n) + \"|\"\n",
" result += A + \",\" + B\n",
" result += \">;\"\n",
" result += \"M := RModule(RSpace(GF(\"+str(p)+\"^\" + str(deg)+\"),\" + str(n) + \"), A);\"\n",
" result += \"IndecomposableSummands(M);\"\n",
" print(magma_free(result))"
]
},
{
"cell_type": "markdown",
"metadata": {
"collapsed": false
},
"source": [
"A := MatrixAlgebra<GF(3^1),14|[1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 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, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]>;\n",
"M := RModule(RSpace(GF(3^1),14), A);\n",
"lll := IndecomposableSummands(M);\n",
"Morphism(lll[2], M);"
2022-10-21 12:04:10 +02:00
]
}
],
"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
}
