diff --git a/superelliptic.ipynb b/superelliptic.ipynb new file mode 100644 index 0000000..22d0da3 --- /dev/null +++ b/superelliptic.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [], + "source": [ + "class superelliptic:\n", + " def __init__(self, f, m, p):\n", + " R. = PolynomialRing(GF(p))\n", + " self.polynomial = R(f)\n", + " self.exponent = m\n", + " self.characteristic = p\n", + " \n", + " \n", + " def __repr__(self):\n", + " f = self.polynomial\n", + " m = self.exponent\n", + " p = self.characteristic\n", + " return 'Superelliptic curve with the equation y^' + str(m) + ' = ' + str(f)+' over finite field with ' + str(p) + ' elements.'\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 basis_holomorphic_differentials(self, j = 'all'):\n", + " f = self.polynomial\n", + " m = self.exponent\n", + " p = self.characteristic\n", + " r = f.degree()\n", + " delta = GCD(r, m)\n", + " \n", + " basis = {}\n", + " if j == 'all':\n", + " k = 0\n", + " for i in range(1, r):\n", + " for j in range(1, m):\n", + " if (r*j - m*i >= delta):\n", + " basis[k] = superelliptic_form(C, x^(i-1)/y^j)\n", + " k = k+1\n", + " return basis\n", + " else:\n", + " k = 0\n", + " for i in range(1, r):\n", + " if (r*j - m*i >= delta):\n", + " basis[k] = superelliptic_form(C, x^(i-1)/y^j)\n", + " k = k+1\n", + " return basis\n", + " \n", + "def reduction(C, g):\n", + " p = C.characteristic\n", + " R. = PolynomialRing(GF(p), 2)\n", + " RR = FractionField(R)\n", + " f = C.polynomial\n", + " r = f.degree()\n", + " m = C.exponent\n", + " g = RR(g)\n", + " g1 = g.numerator()\n", + " g2 = g.denominator()\n", + " \n", + " R1. = PolynomialRing(GF(p))\n", + " R2 = FractionField(R1)\n", + " R3. = PolynomialRing(R2) \n", + " (A, B, C) = xgcd(R3(g2), R3(y^m - f))\n", + " g = R3(g1*B/A)\n", + " \n", + " while(g.degree(R(y)) >= m):\n", + " d = g.degree(R(y))\n", + " G = g.coefficient(R(y^d))\n", + " i = floor(d/m)\n", + " g = g - G*y^d + f^i * y^(d%m) *G\n", + " \n", + " return(R3(g))\n", + "\n", + "def reduction_form(C, g):\n", + " p = C.characteristic\n", + " R. = PolynomialRing(GF(p), 2)\n", + " RR = FractionField(R)\n", + " f = C.polynomial\n", + " r = f.degree()\n", + " m = C.exponent\n", + " g = reduction(C, g)\n", + "\n", + " g1 = RR(0)\n", + " R1. = PolynomialRing(GF(p))\n", + " R2 = FractionField(R1)\n", + " R3. = PolynomialRing(R2)\n", + " \n", + " g = R3(g)\n", + " for j in range(0, m):\n", + " G = g.coefficients(sparse = false)[j]\n", + " g1 += RR(y^(j-m)*f*G)\n", + " \n", + " return(g1)\n", + " \n", + "class superelliptic_function:\n", + " def __init__(self, C, g):\n", + " R. = PolynomialRing(GF(p), 2)\n", + " RR = FractionField(R)\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", + " R. = PolynomialRing(GF(p), 2)\n", + " g = R(g)\n", + " return g.coefficient(y^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", + " g = self.function\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", + "class superelliptic_form:\n", + " def __init__(self, C, g):\n", + " R. = PolynomialRing(GF(p), 2)\n", + " RR = FractionField(R)\n", + " g = RR(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 jth_component(self, j):\n", + " g = self.form\n", + " R. = PolynomialRing(GF(p), 2)\n", + " g = R(g)\n", + " return g.coefficient(y^j)" + ] + }, + { + "cell_type": "code", + "execution_count": 220, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{0: (1/y) dx}" + ] + }, + "execution_count": 220, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "C = superelliptic(x^3 + x + 2, 2, 5)\n", + "C.basis_holomorphic_differentials()" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 179, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "A.degree(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [], + "source": [ + "p = 5\n", + "R. = PolynomialRing(GF(p), 2)\n", + "g = x^6*y^2 + y^2" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "metadata": {}, + "outputs": [], + "source": [ + "omega = diffn(superelliptic_function(C, y^2))" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-2*x^2 + 1" + ] + }, + "execution_count": 183, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "omega.jth_component(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "y" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "R. = PolynomialRing(GF(p), 2)\n", + "g1 = x^3*y^7 + x^2*y^9\n", + "g2 = x^2*y + y^6\n", + "R1. = PolynomialRing(GF(p))\n", + "R2 = FractionField(R1)\n", + "R3. = PolynomialRing(R2)\n", + "\n", + "xgcd(R3(g1), R3(g2))[1]*R3(g1) + xgcd(R3(g1), R3(g2))[2]*R3(g2)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "H = HyperellipticCurve(x^5 - x + 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Hyperelliptic Curve over Finite Field of size 5 defined by y^2 = x^5 + 4*x + 1" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "H" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "f = x^3 + x + 2" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-2*x^2 + 1" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f.derivative(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [], + "source": [ + "R1. = PolynomialRing(GF(p))\n", + "R2 = FractionField(R1)\n", + "R3. = PolynomialRing(R2)\n", + "g = y^2/x + y/(x+1) " + ] + }, + { + "cell_type": "code", + "execution_count": 218, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1/(x + 1), 1/x]" + ] + }, + "execution_count": 218, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "g.coefficients(sparse = false)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "SageMath 9.1", + "language": "sage", + "name": "sagemath" + }, + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}