brnoeth.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SINGULAR DEMO\n",
    "## \"brnoeth: A Singular library for AG codes\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introduction to Singular \n",
    "A Computer Algebra System for polynomial computations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Singular homepage & download http://www.singular.uni-kl.de\n",
    "\n",
    "Manual online http://www.singular.uni-kl.de/index.php/singular-manual.html\n",
    "\n",
    "Singular online https://www.singular.uni-kl.de:8003/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "General remarks: \n",
    "- Comments: introduced by double slash \n",
    "- Command lines: always ended by \";\" \n",
    "- Variables: declare type before using \n",
    "- Booleans: work like in C/C++ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is to save the session (Input and Output) on a local file: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "monitor(\"session.txt\",\"io\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "declare an integer variable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "int i = 1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list of existing variables "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// i                              [0]  int 1\r\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "i is defined if the answer is a positive integer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "defined(i);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check the type of a variable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int\r\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(i);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "remove a variable together with its value "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "kill i;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check that i is removed: answer is zero "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "defined(i);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic types: \n",
    "- int (integer) \n",
    "- intvec (vector of integers) \n",
    "- intmat (matrix of integers) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "random integer between 3 and 100 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54\r\n"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int k = random(3, 100);\n",
    "k;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "intvec by list of integers "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,2,4,3\r\n"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intvec v=1,2,4,3;\n",
    "v;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "intvec by a range "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,2,3,4,5\r\n"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intvec w=1..5;\n",
    "w;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "access to positions: index starts from 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[4];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "matrix of integers: declare the dimensions and the entries "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,2,3,\r\n",
       "4,5,6 \r\n"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intmat A[2][3]=1,2,3,4,5,6;\n",
    "A;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a more pleasant display "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     1     2     3\r\n",
       "     4     5     6\r\n"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(A);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "access to a specific entry of A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5\r\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "declare an empty list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "empty list\r\n"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list L=list();\n",
    "L;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define the entries of L "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "L[1]=v;\n",
    "L[2]=w;\n",
    "L[3]=A;\n",
    "L[5]=1;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "show the complete list L "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,2,4,3\r\n",
       "[2]:\r\n",
       "   1,2,3,4,5\r\n",
       "[3]:\r\n",
       "   1,2,3,\r\n",
       "   4,5,6 \r\n",
       "[5]:\r\n",
       "   1\r\n"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "redefine an entry "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "L[5]=0;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check that L is updated "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,2,4,3\r\n",
       "[2]:\r\n",
       "   1,2,3,4,5\r\n",
       "[3]:\r\n",
       "   1,2,3,\r\n",
       "   4,5,6 \r\n",
       "[5]:\r\n",
       "   0\r\n"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nested indices: the third component of the first component "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1][3];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the size of L "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5\r\n"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(L);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which type is entry in position 5? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int\r\n"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(L[5]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which type is entry in position 4? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "none\r\n"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(L[4]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define a list with the function \"list\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "list LL=list(w,5,list());"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "show LL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,2,3,4,5\r\n",
       "[2]:\r\n",
       "   5\r\n",
       "[3]:\r\n",
       "   empty list\r\n"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LL;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "concatenate two lists "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,2,4,3\r\n",
       "[2]:\r\n",
       "   1,2,3,4,5\r\n",
       "[3]:\r\n",
       "   1,2,3,\r\n",
       "   4,5,6 \r\n",
       "[5]:\r\n",
       "   0\r\n",
       "[6]:\r\n",
       "   1,2,3,4,5\r\n",
       "[7]:\r\n",
       "   5\r\n",
       "[8]:\r\n",
       "   empty list\r\n"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L + LL;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Rings: an example "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "//   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : (a2+a+1)\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering dp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring r=(2,a),(x,y),dp;\n",
    "minpoly=a2+a+1;\n",
    "basering;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "computations in the base (finite) field "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a+1)\r\n"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*a;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "characteristic of the basering "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char(basering);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "number of variables of the basering "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nvars(basering);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Important remark: only one ring can be active at a time "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "clone a ring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def R=basering;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "change the active ring (basering) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "setring R;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects inside a ring: \n",
    "- numbers \n",
    "- polynomials \n",
    "- ideals \n",
    "- matrices \n",
    "- modules \n",
    "- etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a)\r\n"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number b=a2+1;\n",
    "b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x2+y\r\n"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly f=y-x2;\n",
    "f;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "objects inside a rings are local variables: only accessible when the ring is active "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// R                              [0]  *ring\r\n",
       "//      f                              [0]  poly\r\n",
       "//      b                              [0]  number\r\n",
       "// r                              [0]  ring(*)\r\n",
       "// LL                             [0]  list, size: 3\r\n",
       "// L                              [0]  list, size: 5\r\n",
       "// A                              [0]  intmat 2 x 3\r\n",
       "// w                              [0]  intvec (5)\r\n",
       "// v                              [0]  intvec (4)\r\n",
       "// k                              [0]  int 54\r\n"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other objects are global: \n",
    "- int \n",
    "- intvec \n",
    "- string \n",
    "- etc. \n",
    "\n",
    "Lists are local or global depending on their content "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "setring r;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "objects of R are cloned in r because of the \"def\" statement "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// R                              [0]  ring(*)\r\n",
       "// r                              [0]  *ring\r\n",
       "//      f                              [0]  poly\r\n",
       "//      b                              [0]  number\r\n",
       "// LL                             [0]  list, size: 3\r\n",
       "// L                              [0]  list, size: 5\r\n",
       "// A                              [0]  intmat 2 x 3\r\n",
       "// w                              [0]  intvec (5)\r\n",
       "// v                              [0]  intvec (4)\r\n",
       "// k                              [0]  int 54\r\n"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "another ring: check what is global now "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// s                              [0]  *ring\r\n",
       "// R                              [0]  ring\r\n",
       "// r                              [0]  ring\r\n",
       "// LL                             [0]  list, size: 3\r\n",
       "// L                              [0]  list, size: 5\r\n",
       "// A                              [0]  intmat 2 x 3\r\n",
       "// w                              [0]  intvec (5)\r\n",
       "// v                              [0]  intvec (4)\r\n",
       "// k                              [0]  int 54\r\n"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring s = 2,(x,y),lp;\n",
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f is not defined now in ring s "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "defined(f);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this is to obtain reduced standard bases "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "option(redSB);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "compute a standard basis "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=y6\r\n",
       "_[2]=x+y3\r\n"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ideal I=x2,y3+x;\n",
    "std(I);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the same again, but assign the result to I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "I[1]=y6\r\n",
       "I[2]=x+y3\r\n"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "I = std(I);\n",
    "I;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "number of generators of I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ncols(I);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "number of non-zero generators of I "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2\r\n"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(I);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import a library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LIB \"general.lib\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "with \"general.lib\" we can remove all the existing variables "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** killing the basering for level 0\r\n"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "killall();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check that everything is removed "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "obtain help with: help lib/proc; \n",
    "\n",
    "Remark: you should correctly configure you help browser with: system(\"--browser\", <browser>);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the online Manual for further types and procedures "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finite Fields and extensions "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "factorize a cyclotomic polynomial over $F_3$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   _[1]=1\r\n",
       "   _[2]=x+1\r\n",
       "   _[3]=x-1\r\n",
       "   _[4]=x\r\n",
       "   _[5]=x3-x+1\r\n",
       "   _[6]=x3+x2-x+1\r\n",
       "   _[7]=x3-x-1\r\n",
       "   _[8]=x3+x2-1\r\n",
       "   _[9]=x3-x2-x-1\r\n",
       "   _[10]=x3-x2+x+1\r\n",
       "   _[11]=x3-x2+1\r\n",
       "   _[12]=x3+x2+x-1\r\n",
       "[2]:\r\n",
       "   1,1,1,1,1,1,1,1,1,1,1,1\r\n"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring r=3,(x,y),dp;\n",
    "poly f=x27-x;\n",
    "factorize(f);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "extend the base field to $F_{27}$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "//   characteristic : 3\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : (a3-a+1)\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering dp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring rr=(3,a),(x,y),dp;\n",
    "minpoly=a3-a+1;\n",
    "basering;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import f from r with the canonical embedding "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x27-x\r\n"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly f=imap(r,f);\n",
    "f;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "factorize now over the extension field "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=x+(-a)\r\n",
       "_[2]=x+(a2+a)\r\n",
       "_[3]=x+(a2)\r\n",
       "_[4]=x+(a2+a-1)\r\n",
       "_[5]=x+(a+1)\r\n",
       "_[6]=x+(a2+1)\r\n",
       "_[7]=x+(-a2-a-1)\r\n",
       "_[8]=x+(-a2+a+1)\r\n",
       "_[9]=x+(-a2-1)\r\n",
       "_[10]=x+(-a2+1)\r\n",
       "_[11]=x+(-a-1)\r\n",
       "_[12]=x+(-a2-a)\r\n",
       "_[13]=x+(a2-a+1)\r\n",
       "_[14]=x+(-a2+a-1)\r\n",
       "_[15]=x+(a2-a)\r\n",
       "_[16]=x+(-a2+a)\r\n",
       "_[17]=x+(a2+a+1)\r\n",
       "_[18]=x+(-a2-a+1)\r\n",
       "_[19]=x+(a2-1)\r\n",
       "_[20]=x+1\r\n",
       "_[21]=x-1\r\n",
       "_[22]=x+(-a+1)\r\n",
       "_[23]=x+(a-1)\r\n",
       "_[24]=x+(-a2)\r\n",
       "_[25]=x+(a2-a-1)\r\n",
       "_[26]=x+(a)\r\n",
       "_[27]=x\r\n"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorize(f,1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the Euclidean algorithm for (univariate) polynomials "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x2-x\r\n"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gcd(f,x4-x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the extended Euclidean algorithm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   x2-x\r\n",
       "[2]:\r\n",
       "   -x\r\n",
       "[3]:\r\n",
       "   x24+x21+x18+x15+x12+x9+x6+x3+1\r\n"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "extgcd(f,x4-x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "further computations over finite fields "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "I[1]=x2+y2\r\n",
       "I[2]=x2-y2\r\n"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ideal I=x2+y2,x2-y2;\n",
    "I;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "compute a standard basis (w.r.t. the graded lexico-graphical ordering dp) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "J[1]=y2\r\n",
       "J[2]=x2\r\n"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ideal J=std(I);\n",
    "J;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for the next computations we need J to be a standard basis "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the Krull dimension "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the dimension of R/J as a vector space (R is the basering) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vdim(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a vector basis of R/J "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=xy\r\n",
       "_[2]=y\r\n",
       "_[3]=x\r\n",
       "_[4]=1\r\n"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kbase(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the Samuel multiplicity "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mult(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the Hilbert series "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "//         1 t^0\r\n",
       "//        -2 t^2\r\n",
       "//         1 t^4\r\n",
       "\r\n",
       "//         1 t^0\r\n",
       "//         2 t^1\r\n",
       "//         1 t^2\r\n",
       "// dimension (affine) = 0\r\n",
       "// degree (affine)  = 4\r\n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hilb(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the syzygies "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=x2*gen(1)-y2*gen(2)\r\n"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "syz(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "primary decomposition of prime ideals: the primary ideals with their associated primes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** redefining sat1 **\r\n",
       "// ** redefining sat2 **\r\n",
       "// ** redefining minSat **\r\n",
       "// ** redefining minSat **\r\n",
       "// ** redefining quotMin **\r\n",
       "// ** redefining testFactor **\r\n",
       "// ** redefining factor **\r\n",
       "// ** redefining idealsEqual **\r\n",
       "// ** redefining idealsEqual **\r\n",
       "// ** redefining specialIdealsEqual **\r\n",
       "// ** redefining stdIdealsEqual **\r\n",
       "// ** redefining primaryTest **\r\n",
       "// ** redefining primaryTest **\r\n",
       "// ** redefining gcdTest **\r\n",
       "// ** redefining gcdTest **\r\n",
       "// ** redefining splitPrimary **\r\n",
       "// ** redefining splitCharp **\r\n",
       "// ** redefining zero_decomp **\r\n",
       "// ** redefining zero_decomp **\r\n",
       "// ** redefining extF **\r\n",
       "// ** redefining extF **\r\n",
       "// ** redefining zeroSp **\r\n",
       "// ** redefining zeroSp **\r\n",
       "// ** redefining zeroSepClos **\r\n",
       "// ** redefining zeroSepClos **\r\n",
       "// ** redefining insepDecomp_i **\r\n",
       "// ** redefining insepDecomp_i **\r\n",
       "// ** redefining clearSB **\r\n",
       "// ** redefining clearSBNeu **\r\n",
       "// ** redefining teilt **\r\n",
       "// ** redefining independSet **\r\n",
       "// ** redefining maxIndependSet **\r\n",
       "// ** redefining prepareQuotientring **\r\n",
       "// ** redefining cleanPrimary **\r\n",
       "// ** redefining minAssPrimesoldE **\r\n",
       "// ** redefining minAssPrimesoldE **\r\n",
       "// ** redefining minAssPrimesold **\r\n",
       "// ** redefining minAssPrimesold **\r\n",
       "// ** redefining minAssPrimesold_i **\r\n",
       "// ** redefining primT **\r\n",
       "// ** redefining minAssPrimesE **\r\n",
       "// ** redefining minAssPrimes **\r\n",
       "// ** redefining minAssPrimes_i **\r\n",
       "// ** redefining union **\r\n",
       "// ** redefining equidim **\r\n",
       "// ** redefining equidim **\r\n",
       "// ** redefining equidimMax **\r\n",
       "// ** redefining equidimMax **\r\n",
       "// ** redefining islp **\r\n",
       "// ** redefining algeDecoE **\r\n",
       "// ** redefining algeDecoE **\r\n",
       "// ** redefining algeDeco **\r\n",
       "// ** redefining algeDeco **\r\n",
       "// ** redefining algeDeco_i **\r\n",
       "// ** redefining prepare_absprimdec **\r\n",
       "// ** redefining decompE **\r\n",
       "// ** redefining decomp **\r\n",
       "// ** redefining decomp_i **\r\n",
       "// ** redefining powerCoeffs **\r\n",
       "// ** redefining sep **\r\n",
       "// ** redefining sep **\r\n",
       "// ** redefining zeroRad **\r\n",
       "// ** redefining zeroRad **\r\n",
       "// ** redefining algeRad **\r\n",
       "// ** redefining radicalEHV **\r\n",
       "// ** redefining radicalEHV **\r\n",
       "// ** redefining Ann **\r\n",
       "// ** redefining Ann **\r\n",
       "// ** redefining int_ass_primary_e **\r\n",
       "// ** redefining AnnExt_R **\r\n",
       "// ** redefining analyze **\r\n",
       "// ** redefining simplifyIdeal **\r\n",
       "// ** redefining ini_mod **\r\n",
       "// ** redefining min_ass_prim_charsets_i **\r\n",
       "// ** redefining min_ass_prim_charsets0_i **\r\n",
       "// ** redefining min_ass_prim_charsets1_i **\r\n",
       "// ** redefining prim_dec_i **\r\n",
       "// ** redefining pseudo_prim_dec_charsets_i **\r\n",
       "// ** redefining pseudo_prim_dec_special_charsets_i **\r\n",
       "// ** redefining pseudo_prim_dec_i_i **\r\n",
       "// ** redefining extraction **\r\n",
       "// ** redefining minsat **\r\n",
       "// ** redefining minsat_ppd **\r\n",
       "// ** redefining minquot **\r\n",
       "// ** redefining special_ideals_equal **\r\n",
       "// ** redefining convList **\r\n",
       "// ** redefining reconvList **\r\n",
       "// ** redefining primdecGTZE **\r\n",
       "// ** redefining primdecGTZE **\r\n",
       "// ** redefining primdecGTZ **\r\n",
       "// ** redefining primdecGTZ **\r\n",
       "// ** redefining primdecGTZ_i **\r\n",
       "// ** redefining absPrimdecGTZE **\r\n",
       "// ** redefining absPrimdecGTZE **\r\n",
       "// ** redefining absPrimdecGTZ **\r\n",
       "// ** redefining absPrimdecGTZ **\r\n",
       "// ** redefining absPrimdecGTZ_i **\r\n",
       "// ** redefining primdecSYE **\r\n",
       "// ** redefining primdecSYE **\r\n",
       "// ** redefining primdecSY **\r\n",
       "// ** redefining primdecSY **\r\n",
       "// ** redefining primdecSY_i **\r\n",
       "// ** redefining minAssGTZE **\r\n",
       "// ** redefining minAssGTZE **\r\n",
       "// ** redefining minAssGTZ **\r\n",
       "// ** redefining minAssGTZ **\r\n",
       "// ** redefining minAssGTZ_i **\r\n",
       "// ** redefining minAssCharE **\r\n",
       "// ** redefining minAssCharE **\r\n",
       "// ** redefining minAssChar **\r\n",
       "// ** redefining minAssChar **\r\n",
       "// ** redefining minAssChar_i **\r\n",
       "// ** redefining minAssChar_i **\r\n",
       "// ** redefining equiRadical **\r\n",
       "// ** redefining equiRadical **\r\n",
       "// ** redefining radical **\r\n",
       "// ** redefining radical **\r\n",
       "// ** redefining radicalKL **\r\n",
       "// ** redefining radicalSL **\r\n",
       "// ** redefining radicalReduction **\r\n",
       "// ** redefining radicalSLIteration **\r\n",
       "// ** redefining newMaxIndependSetDp **\r\n",
       "// ** redefining newMaxIndependSetDp **\r\n",
       "// ** redefining prepareAss **\r\n",
       "// ** redefining prepareAss **\r\n",
       "// ** redefining equidimMaxEHV **\r\n",
       "// ** redefining equidimMaxEHV **\r\n",
       "// ** redefining testPrimaryE **\r\n",
       "// ** redefining testPrimaryE **\r\n",
       "// ** redefining testPrimary **\r\n",
       "// ** redefining testPrimary **\r\n",
       "// ** redefining testPrimary_i **\r\n",
       "// ** redefining zerodec **\r\n",
       "// ** redefining zerodec **\r\n",
       "// ** redefining newDecompStepE **\r\n",
       "// ** redefining newDecompStep **\r\n",
       "// ** redefining newDecompStep_i **\r\n",
       "// ** redefining newReduction **\r\n",
       "// ** redefining minAssE **\r\n",
       "// ** redefining minAssE **\r\n",
       "// ** redefining minAss **\r\n",
       "// ** redefining minAss **\r\n",
       "// ** redefining minAss_i **\r\n",
       "// ** redefining minAssSL **\r\n",
       "// ** redefining minAssSLIteration **\r\n",
       "// ** redefining newMaxIndependSetLp **\r\n",
       "// ** redefining newMaxIndependSetLp **\r\n",
       "// ** redefining newZero_decomp **\r\n",
       "// ** redefining newZero_decomp **\r\n"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LIB \"primdec.lib\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the radical of the ideal J "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=y\r\n",
       "_[2]=x\r\n"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "radical(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "fetch J into the ring r "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "J[1]=y2\r\n",
       "J[2]=x2\r\n"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setring r;\n",
    "ideal J=imap(rr,I);\n",
    "J=std(J);\n",
    "J;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "algorithm of Gianni-Trager-Zacharias "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y2\r\n",
       "      _[2]=x2\r\n",
       "   [2]:\r\n",
       "      _[1]=x\r\n",
       "      _[2]=y\r\n"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primdecGTZ(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "algorithm of Shimoyama-Yokoyama "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y2\r\n",
       "      _[2]=x2\r\n",
       "   [2]:\r\n",
       "      _[1]=y\r\n",
       "      _[2]=x\r\n"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "primdecSY(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a harder example in characteristic zero "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=z6+4z3+4\r\n",
       "      _[2]=y-z2\r\n",
       "   [2]:\r\n",
       "      _[1]=z3+2\r\n",
       "      _[2]=y-z2\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      _[1]=z2+1\r\n",
       "      _[2]=y-z2\r\n",
       "   [2]:\r\n",
       "      _[1]=z2+1\r\n",
       "      _[2]=y-z2\r\n"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring r0 = 0,(x,y,z),lp;\n",
    "poly p = z2+1;\n",
    "poly q = z3+2;\n",
    "ideal i = p*q^2,y-z2;\n",
    "list pr = primdecGTZ(i);\n",
    "pr;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a hard computation of standard basis over $F_2$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ring s=2,(x,y,z,t),lp;\n",
    "ideal I=x8+y7+z6,y5+z4+t3,x7+z6+t5,x4+y3+t2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "time control ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "timer=1\r\n"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timer=1;\n",
    "print(\"timer=\"+string(timer));\n",
    "ideal J=std(I);\n",
    "print(\"timer=\"+string(timer));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the result ... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "J[1]=t119+t115+t113+t112+t110+t104+t101+t100+t99+t98+t96+t93+t91+t89+t88+t87+t86+t84+t82+t77+t76+t73+t70+t69+t67+t65+t63+t61+t60+t58+t57+t56+t55+t54+t53+t51+t50+t48+t46+t45+t43+t42+t41+t40+t37+t35+t33+t32+t23+t21+t17+t16+t14+t11+t10+t9+t8\r\n",
       "J[2]=z2t7+t117+t106+t105+t103+t102+t101+t99+t96+t94+t93+t92+t91+t89+t88+t83+t80+t79+t74+t72+t69+t67+t66+t62+t61+t60+t58+t57+t55+t54+t53+t52+t50+t49+t47+t42+t40+t38+t34+t32+t31+t30+t29+t28+t27+t24+t23+t22+t18+t17+t16+t14+t13+t9+t8\r\n",
       "J[3]=z4t5+z2t6+t117+t116+t114+t111+t110+t109+t108+t107+t104+t100+t98+t96+t92+t91+t89+t88+t87+t86+t85+t84+t83+t82+t80+t79+t78+t77+t71+t69+t67+t64+t63+t62+t60+t55+t53+t50+t46+t44+t40+t39+t38+t34+t33+t32+t31+t30+t27+t25+t24+t23+t22+t20+t19+t18+t16+t15+t14+t13+t12+t10\r\n",
       "J[4]=z6t3+t118+t114+t111+t110+t108+t107+t102+t101+t95+t94+t93+t90+t89+t88+t87+t85+t84+t82+t81+t78+t75+t74+t71+t70+t69+t68+t67+t66+t62+t61+t60+t58+t54+t53+t51+t50+t49+t44+t42+t39+t36+t34+t33+t32+t31+t30+t27+t26+t25+t24+t23+t22+t21+t20+t18+t13+t12+t11+t10+t9+t8\r\n",
       "J[5]=z8t2+t117+t116+t114+t111+t108+t105+t103+t101+t100+t99+t96+t93+t90+t88+t85+t81+t76+t75+t74+t72+t70+t69+t64+t62+t59+t57+t55+t54+t53+t52+t51+t50+t47+t46+t45+t44+t43+t41+t40+t37+t36+t34+t33+t32+t30+t29+t28+t27+t19+t18+t17+t15+t13+t12+t11\r\n",
       "J[6]=z10t+t116+t115+t114+t113+t110+t108+t107+t106+t103+t102+t99+t96+t95+t92+t91+t90+t89+t82+t79+t76+t73+t72+t70+t69+t68+t67+t64+t57+t56+t52+t51+t49+t43+t42+t41+t39+t38+t35+t33+t28+t27+t24+t23+t22+t21+t20+t19+t17+t15+t14+t12+t10+t8\r\n",
       "J[7]=z12+t118+t117+t116+t115+t114+t113+t112+t111+t107+t105+t103+t102+t101+t100+t99+t98+t95+t94+t92+t90+t89+t86+t85+t84+t81+t75+t71+t70+t69+t67+t64+t63+t57+t55+t53+t50+t47+t44+t43+t41+t39+t38+t37+t34+t33+t32+t28+t27+t26+t24+t21+t20+t16+t15+t13+t10+t8\r\n",
       "J[8]=yt7+t116+t112+t107+t106+t105+t104+t102+t101+t100+t99+t97+t95+t91+t90+t88+t85+t82+t79+t78+t77+t75+t73+t71+t70+t69+t68+t66+t65+t63+t58+t57+t56+t54+t47+t45+t42+t41+t36+t35+t34+t33+t32+t30+t29+t22+t20+t19+t17+t16+t14+t13+t12+t10+t9+t8\r\n",
       "J[9]=yz2t6+t117+t113+t111+t110+t108+t106+t105+t102+t101+t96+t95+t94+t92+t91+t90+t88+t87+t86+t85+t84+t80+t77+t75+t74+t72+t70+t67+t65+t63+t62+t59+t58+t56+t55+t53+t47+t46+t45+t42+t41+t39+t34+t33+t30+t29+t28+t24+t23+t20+t18+t16+t15+t12+t11+t10\r\n",
       "J[10]=yz4t3+yt6+t106+t105+t101+t100+t97+t95+t93+t90+t89+t88+t84+t83+t81+t80+t79+t78+t77+t76+t74+t73+t71+t69+t65+t64+t63+t61+t60+t58+t56+t54+t53+t52+t51+t50+t47+t38+t35+t33+t32+t31+t23+t19+t18+t15+t14+t13+t12+t9+t8+t7\r\n",
       "J[11]=yz6t+yz2t5+yz2t4+z8t+z2t5+t118+t117+t115+t114+t112+t110+t108+t105+t104+t103+t102+t101+t100+t99+t96+t95+t94+t93+t92+t91+t88+t83+t80+t78+t77+t74+t73+t72+t70+t69+t64+t62+t61+t56+t53+t49+t46+t45+t44+t43+t42+t41+t39+t38+t35+t34+t30+t28+t25+t24+t23+t22+t21+t20+t13+t12+t11+t10+t9+t8+t7\r\n",
       "J[12]=yz8+yt6+z10+z4t4+t117+t116+t115+t114+t113+t108+t107+t104+t103+t100+t99+t97+t95+t94+t93+t92+t91+t88+t87+t85+t84+t82+t81+t78+t77+t76+t75+t74+t69+t68+t67+t63+t60+t53+t52+t51+t49+t45+t44+t43+t41+t39+t38+t36+t35+t34+t32+t30+t29+t28+t26+t25+t22+t21+t17+t16+t15+t14+t12+t11+t8+t7\r\n",
       "J[13]=y2t6+yz4t2+yz2t5+yt6+yt5+z10+z6t2+z2t6+t115+t114+t111+t110+t109+t108+t107+t106+t103+t98+t97+t93+t92+t88+t86+t80+t79+t78+t76+t73+t70+t69+t67+t62+t60+t59+t58+t54+t53+t52+t50+t49+t47+t46+t43+t40+t38+t35+t34+t33+t32+t29+t26+t24+t23+t22+t21+t19+t16+t14+t13+t12+t9+t8+t6\r\n",
       "J[14]=y2z2t4+yz6+yz2t5+yz2t4+yz2t3+yt6+z8t+z8+z4t4+z2t4+t117+t116+t115+t114+t112+t111+t109+t108+t101+t98+t93+t92+t90+t89+t87+t86+t85+t82+t81+t80+t78+t76+t75+t74+t70+t68+t67+t66+t65+t63+t58+t55+t54+t53+t52+t51+t49+t46+t45+t44+t43+t39+t35+t34+t30+t29+t28+t27+t21+t20+t19+t14+t11+t10+t9\r\n",
       "J[15]=y2z4+y2t3+yz4+yt3+z6+t4\r\n",
       "J[16]=y3t5+y2t5+yz6+yz4t2+yz4t+yz2t5+yz2t3+yt4+z8+z6t2+z6t+z4t4+z2t5+z2t4+t117+t114+t112+t109+t108+t101+t98+t93+t91+t90+t85+t83+t74+t71+t70+t69+t67+t66+t62+t60+t59+t58+t57+t55+t51+t49+t46+t45+t44+t41+t40+t38+t36+t34+t33+t32+t31+t30+t29+t27+t26+t19+t16+t13+t12+t11+t10+t8+t6+t5\r\n",
       "J[17]=y3z2t3+y3t4+y2z2t3+y2t4+yz6+yz4+yz2t4+yt6+yt4+yt3+z10+z8+z6+z4t4+t117+t116+t115+t114+t113+t108+t107+t104+t103+t100+t99+t97+t95+t94+t93+t92+t91+t88+t87+t85+t84+t82+t81+t78+t77+t76+t75+t74+t69+t68+t67+t63+t60+t53+t52+t51+t49+t45+t44+t43+t41+t39+t38+t36+t35+t34+t32+t30+t29+t28+t26+t25+t22+t21+t17+t16+t15+t14+t12+t11+t8+t7+t6+t4\r\n",
       "J[18]=y4t4+y2t5+yz4t+yz2t5+yz2t4+yt6+yt5+yt4+z10+z8t+z8+z6t2+z6t+z2t5+t118+t116+t115+t113+t110+t108+t107+t106+t105+t103+t102+t101+t99+t98+t96+t95+t94+t92+t91+t90+t89+t88+t87+t83+t82+t80+t79+t78+t76+t74+t71+t69+t67+t66+t63+t61+t57+t55+t52+t48+t47+t45+t44+t43+t38+t35+t34+t31+t29+t28+t27+t23+t22+t19+t18+t17+t16+t15+t12+t9+t8+t6+t5\r\n",
       "J[19]=y5+z4+t3\r\n",
       "J[20]=xt7+z10+t116+t112+t110+t109+t108+t107+t106+t104+t103+t101+t100+t99+t92+t91+t90+t89+t88+t86+t85+t83+t81+t80+t79+t77+t76+t75+t73+t72+t68+t67+t66+t65+t64+t62+t61+t60+t59+t58+t56+t53+t49+t48+t46+t39+t38+t37+t36+t35+t32+t28+t26+t25+t22+t21+t18+t15+t13+t12+t10+t8+t7\r\n",
       "J[21]=xz2t6+t116+t112+t111+t109+t108+t106+t103+t98+t96+t94+t92+t91+t90+t88+t84+t82+t79+t75+t74+t67+t62+t59+t55+t52+t46+t45+t44+t42+t39+t37+t35+t31+t30+t29+t27+t23+t22+t20+t17+t15+t14+t12+t10+t8+t7\r\n",
       "J[22]=xz6+xt5+yz4+yt3+t4\r\n",
       "J[23]=xyt6+xz4t4+yz6+yz4t2+yz2t4+yz2t3+yt6+yt5+z8+z6t2+z2t4+t118+t117+t116+t114+t111+t109+t107+t105+t102+t100+t98+t97+t95+t93+t92+t90+t87+t84+t83+t82+t80+t79+t75+t74+t72+t71+t69+t68+t65+t64+t63+t61+t57+t56+t54+t53+t52+t50+t46+t43+t39+t37+t36+t33+t32+t31+t30+t29+t28+t26+t15+t13+t10+t8+t7+t6\r\n",
       "J[24]=xyz2t3+xyt5+xz4t4+xz2t4+y2t5+yz6+yz4t2+yz4+yz2t4+yz2t3+yt6+yt5+yt4+yt3+z6t2+z6+z2t5+z2t4+t118+t117+t116+t113+t111+t110+t109+t107+t104+t103+t101+t100+t95+t94+t91+t88+t84+t82+t81+t80+t78+t75+t74+t73+t72+t70+t68+t67+t66+t62+t59+t55+t53+t49+t45+t41+t40+t38+t35+t34+t32+t31+t29+t26+t24+t23+t22+t20+t19+t18+t15+t13+t9+t8+t7+t6+t4\r\n",
       "J[25]=xyz4t2+xyt5+xz4t4+xt6+yz6+yz4t2+yz2t5+yz2t4+yz2t3+yt5+z8t+z8+z2t4+t118+t115+t111+t108+t106+t103+t102+t100+t99+t98+t97+t95+t93+t92+t90+t88+t87+t84+t81+t80+t78+t76+t74+t72+t71+t70+t68+t66+t62+t59+t58+t55+t53+t51+t49+t45+t43+t42+t40+t39+t36+t35+t34+t31+t29+t28+t27+t26+t22+t20+t17+t16+t15+t13+t12+t11+t10+t8+t6\r\n",
       "J[26]=xy2t5+xyz4t+xyt5+xyt4+xz4t4+xt6+xt5+y2t5+yz4t2+yz4t+yz2t4+yt6+yt5+yt4+z6t2+z2t5+t118+t116+t115+t113+t111+t110+t103+t101+t100+t98+t97+t96+t95+t94+t89+t88+t87+t86+t85+t84+t83+t81+t78+t75+t74+t73+t72+t70+t67+t66+t64+t63+t62+t61+t60+t55+t54+t51+t49+t48+t46+t43+t39+t37+t36+t35+t34+t32+t29+t26+t22+t20+t19+t18+t16+t15+t12+t10+t9+t7+t6+t5\r\n",
       "J[27]=xy3t4+xy2t4+xyz4t+xyz4+xyt3+xz4t4+xz2t5+xt4+y3t4+y2z2t3+y2t5+yz6+yz4t+yz2t5+yz2t3+z10+z8t+z6+z2t5+z2t4+t118+t116+t115+t114+t107+t106+t104+t103+t99+t96+t95+t93+t89+t88+t85+t83+t82+t81+t80+t79+t76+t73+t72+t66+t64+t63+t62+t61+t56+t51+t49+t48+t46+t45+t43+t40+t39+t36+t35+t34+t33+t32+t30+t29+t22+t21+t20+t19+t18+t16+t14+t11+t10+t8+t7+t5\r\n",
       "J[28]=x2z2t5+x2t6+xz4t4+xz2t5+xt6+y3t4+y2z2t3+y2t4+yz4t2+yz4t+yz4+yz2t3+yt6+yt3+z8+z6t2+z6t+z6+z2t4+t118+t116+t114+t112+t111+t110+t109+t108+t106+t103+t102+t101+t98+t94+t93+t90+t88+t86+t83+t82+t81+t77+t76+t75+t73+t69+t68+t65+t64+t63+t62+t60+t57+t55+t54+t51+t49+t43+t42+t40+t39+t35+t34+t32+t31+t29+t28+t27+t24+t21+t19+t18+t17+t15+t13+t11+t10+t9+t8+t7+t6+t5+t4\r\n",
       "J[29]=x2z4t4+xz4t4+y2t5+yz4t2+yz4t+yz2t5+yz2t4+yt4+z10+z8t+z6t+z2t5+t118+t117+t115+t112+t109+t108+t105+t104+t102+t101+t99+t98+t95+t93+t92+t87+t86+t85+t84+t83+t82+t81+t80+t77+t76+t75+t72+t71+t69+t68+t67+t60+t52+t48+t45+t41+t40+t39+t37+t36+t35+t32+t29+t28+t26+t22+t20+t18+t14+t13+t12+t9+t8+t7+t6+t5\r\n",
       "J[30]=x2yz4t+x2yt5+x2yt4+x2t6+x2t5+xyt5+xt6+y2t5+yz4t+yz2t5+yt6+yt4+z10+z8t+z8+z6t2+z2t6+z2t5+t118+t116+t110+t109+t105+t103+t102+t99+t98+t97+t96+t95+t94+t89+t88+t87+t86+t81+t76+t73+t71+t70+t69+t68+t60+t58+t56+t54+t52+t50+t48+t47+t46+t43+t42+t38+t37+t36+t33+t32+t28+t27+t24+t23+t22+t20+t19+t18+t17+t15+t14+t12+t10+t5\r\n",
       "J[31]=x2y2t4+x2yz4+x2yt5+x2yt4+x2yt3+x2t5+x2t4+xyt4+xt5+yz4+yt3+z10+t118+t113+t111+t109+t108+t106+t99+t98+t96+t94+t93+t91+t90+t88+t87+t86+t85+t84+t83+t77+t75+t74+t69+t68+t65+t64+t62+t61+t60+t57+t56+t55+t51+t50+t49+t46+t43+t42+t41+t38+t36+t34+t31+t30+t28+t23+t22+t19+t18+t17+t15+t12+t9+t4\r\n",
       "J[32]=x3t6+xyz4t+xyt5+xyt4+xt6+xt5+y2t5+yz4t+yz2t5+yt6+yt4+z8t+z8+z6t2+z2t5+t118+t116+t114+t113+t112+t111+t110+t108+t107+t106+t105+t104+t100+t97+t96+t95+t94+t92+t91+t90+t89+t88+t86+t85+t84+t83+t80+t79+t77+t74+t70+t68+t67+t65+t61+t57+t55+t54+t53+t51+t50+t49+t48+t47+t46+t45+t43+t42+t34+t33+t27+t24+t22+t20+t18+t14+t12+t10+t7+t5\r\n",
       "J[33]=x3z2t4+x2yt5+x2t6+xyz4t+xyt4+xt5+z10+t117+t107+t105+t97+t96+t95+t93+t92+t90+t88+t86+t85+t83+t82+t81+t78+t76+t75+t74+t73+t72+t71+t70+t68+t67+t64+t63+t62+t57+t56+t55+t54+t53+t50+t44+t43+t42+t37+t35+t33+t32+t31+t30+t22+t20+t19+t18+t17+t16+t14+t13+t9+t7\r\n",
       "J[34]=x3z4t2+x3t5+x2yz4+x2yt5+x2yt4+x2yt3+x2t6+x2t5+x2t4+xyz4t+xyz4+xyt4+xyt3+xt5+xt4+y2t5+yz4t2+yz4t+yz2t4+yt4+z10+z8t+z6t+z4t4+z2t6+z2t5+t118+t117+t115+t114+t113+t110+t108+t107+t106+t103+t102+t100+t99+t98+t95+t94+t93+t88+t87+t82+t80+t77+t76+t73+t67+t66+t65+t64+t62+t61+t60+t59+t58+t57+t56+t55+t52+t50+t49+t47+t45+t41+t40+t39+t38+t37+t36+t35+t33+t32+t31+t27+t18+t16+t13+t12+t11+t10+t8+t7+t6+t5\r\n",
       "J[35]=x3yt4+x3t5+x2yz4+x2yt3+x2t4+y3t4+y2z2t3+y2t4+yz6+yz4t2+yz4+yz2t5+yz2t4+yt6+yt5+yt4+yt3+z10+z8+z6t2+z6+z2t6+t118+t117+t116+t115+t112+t108+t106+t104+t102+t100+t98+t91+t90+t89+t88+t87+t86+t85+t83+t80+t79+t78+t74+t73+t67+t66+t65+t63+t62+t54+t50+t47+t45+t43+t42+t41+t40+t39+t38+t36+t34+t32+t26+t25+t24+t21+t20+t19+t18+t16+t15+t13+t12+t10+t9+t8+t7+t4\r\n",
       "J[36]=x3yz4+x3yt3+x3t4+y3t4+y2z2t3+y2t5+y2t4+yz6+yz4t2+yz4t+yz4+yz2t5+yt3+z8+z6t+z6+z4t4+z2t5+t117+t114+t112+t109+t108+t101+t98+t93+t91+t90+t85+t83+t74+t71+t70+t69+t67+t66+t62+t60+t59+t58+t57+t55+t51+t49+t46+t45+t44+t41+t40+t38+t36+t34+t33+t32+t31+t30+t29+t27+t26+t19+t16+t13+t12+t11+t10+t8+t7+t5+t4\r\n",
       "J[37]=x3y2t2+x3z4+x3t3+y2z2t3+y2t5+yz6+yz2t3+z8+z2t4\r\n",
       "J[38]=x3y3+x3t2+z6+t5\r\n",
       "J[39]=x4+y3+t2\r\n"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Triangulation algorithms for zero-dimensional ideals (Lazard) \n",
    "- They are used to solve systems of algebraic equations with finitely many solutions \n",
    "- Input: std with respect to lp \n",
    "- Output: list of triangular systems "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** redefining triangL **\r\n",
       "// ** redefining triangL **\r\n",
       "// ** redefining triangLfak **\r\n",
       "// ** redefining triangLfak **\r\n",
       "// ** redefining triangLbas **\r\n",
       "// ** redefining invertieren **\r\n",
       "// ** redefining invertieren_oT **\r\n",
       "// ** redefining Erw_ggt_oT **\r\n",
       "// ** redefining normieren_oT **\r\n",
       "// ** redefining triangM **\r\n",
       "// ** redefining triangM **\r\n",
       "// ** redefining triangMH **\r\n",
       "// ** redefining triangMH **\r\n",
       "// ** redefining sort_red **\r\n",
       "// ** redefining Listenrest **\r\n",
       "// ** redefining Idealrest **\r\n",
       "// ** redefining H_anhaengen **\r\n",
       "// ** redefining faktorisiere_letzten **\r\n",
       "// ** redefining faktorisiere_DB **\r\n",
       "// ** redefining degv **\r\n",
       "// ** redefining pdiv **\r\n",
       "// ** redefining lvar **\r\n",
       "// ** redefining lcoef **\r\n"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LIB \"triang.lib\";"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[2]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[3]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[4]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[5]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[6]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[7]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[8]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[9]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[10]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[11]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[12]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[13]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[14]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[15]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[16]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[17]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[18]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[19]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[20]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[21]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[22]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[23]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[24]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[25]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[26]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[27]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[28]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[29]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[30]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[31]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[32]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[33]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[34]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[35]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[36]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[37]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[38]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[39]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[40]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[41]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[42]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[43]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[44]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[45]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[46]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[47]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y3\r\n",
       "   _[4]=x4\r\n",
       "[48]:\r\n",
       "   _[1]=t\r\n",
       "   _[2]=z4\r\n",
       "   _[3]=y2\r\n",
       "   _[4]=x4\r\n",
       "[49]:\r\n",
       "   _[1]=t111+t107+t105+t104+t102+t96+t93+t92+t91+t90+t88+t85+t83+t81+t80+t79+t78+t76+t74+t69+t68+t65+t62+t61+t59+t57+t55+t53+t52+t50+t49+t48+t47+t46+t45+t43+t42+t40+t38+t37+t35+t34+t33+t32+t29+t27+t25+t24+t15+t13+t9+t8+t6+t3+t2+t+1\r\n",
       "   _[2]=z2+t110+t99+t98+t96+t95+t94+t92+t89+t87+t86+t85+t84+t82+t81+t76+t73+t72+t67+t65+t62+t60+t59+t55+t54+t53+t51+t50+t48+t47+t46+t45+t43+t42+t40+t35+t33+t31+t27+t25+t24+t23+t22+t21+t20+t17+t16+t15+t11+t10+t9+t7+t6+t2+t\r\n",
       "   _[3]=y+t109+t105+t100+t99+t98+t97+t95+t94+t93+t92+t90+t88+t84+t83+t81+t78+t75+t72+t71+t70+t68+t66+t64+t63+t62+t61+t59+t58+t56+t51+t50+t49+t47+t40+t38+t35+t34+t29+t28+t27+t26+t25+t23+t22+t15+t13+t12+t10+t9+t7+t6+t5+t3+t2+t\r\n",
       "   _[4]=x+t109+t108+t107+t106+t103+t101+t98+t97+t96+t95+t93+t92+t91+t88+t87+t85+t79+t78+t76+t73+t72+t71+t70+t69+t66+t64+t62+t58+t57+t56+t55+t54+t53+t52+t51+t48+t46+t44+t43+t42+t39+t35+t34+t33+t32+t29+t28+t27+t21+t20+t18+t16+t13+t12+t9+t8+t7+t5+t4+t3+t2+t\r\n"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "triangL(J);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hamburger-Noether expansions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** killing the basering for level 0\r\n"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "killall();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LIB \"hnoether.lib\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "local ring for computations (local ordering) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ring r = 2,(x,y),ds;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "local equation at the origin "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "poly f = x10+x3y7+y9+y2;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list of the HN expansions of all the branches at the origin "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1,1]=0\r\n",
       "      _[1,2]=0\r\n",
       "      _[1,3]=0\r\n",
       "      _[1,4]=0\r\n",
       "      _[1,5]=1\r\n",
       "      _[1,6]=0\r\n",
       "      _[1,7]=0\r\n",
       "      _[1,8]=0\r\n",
       "      _[1,9]=0\r\n",
       "      _[1,10]=0\r\n",
       "      _[1,11]=0\r\n",
       "      _[1,12]=0\r\n",
       "      _[1,13]=0\r\n",
       "      _[1,14]=0\r\n",
       "      _[1,15]=0\r\n",
       "      _[1,16]=0\r\n",
       "      _[1,17]=0\r\n",
       "      _[1,18]=0\r\n",
       "      _[1,19]=1\r\n",
       "      _[1,20]=0\r\n",
       "      _[1,21]=0\r\n",
       "      _[1,22]=0\r\n",
       "      _[1,23]=x\r\n",
       "      _[2,1]=0\r\n",
       "      _[2,2]=1\r\n",
       "      _[2,3]=0\r\n",
       "      _[2,4]=0\r\n",
       "      _[2,5]=0\r\n",
       "      _[2,6]=0\r\n",
       "      _[2,7]=0\r\n",
       "      _[2,8]=0\r\n",
       "      _[2,9]=0\r\n",
       "      _[2,10]=0\r\n",
       "      _[2,11]=0\r\n",
       "      _[2,12]=0\r\n",
       "      _[2,13]=0\r\n",
       "      _[2,14]=0\r\n",
       "      _[2,15]=0\r\n",
       "      _[2,16]=1\r\n",
       "      _[2,17]=0\r\n",
       "      _[2,18]=0\r\n",
       "      _[2,19]=0\r\n",
       "      _[2,20]=0\r\n",
       "      _[2,21]=0\r\n",
       "      _[2,22]=0\r\n",
       "      _[2,23]=0\r\n",
       "   [2]:\r\n",
       "      22,-17\r\n",
       "   [3]:\r\n",
       "      0\r\n",
       "   [4]:\r\n",
       "      y+y8+xy11+x3y10+x5y9+x7y8+y15+x16+x2y14+x4y13+x6y12+x8y11+xy18+x17y3+x10y10+x19y2+x12y9+x5y16+x21y+x14y8+y22+x23+x16y7+x18y6+x4y20+x20y5+x22y4+x8y18+x24y3+x26y2+x12y16+x28y+x30+x2y28+x10y24+x33y2+y36+x37+x32y6+x18y20+x36y4+x8y32+xy39+x3y38+x40y2+x26y16+x5y37+x7y36+x44+x9y35+x2y42+x11y34+x34y12+x13y33+x6y40+x15y32+x3y45+x5y44+x42y8+y50+x18y34+x11y41+x4y48+x13y40+x50y4+x22y32+x19y37+x21y36+x58+x27y33+x29y32+y64+x32y34+x4y62+x64y4+x36y32+x8y60+xy67+x3y66+x12y58+x5y65+x7y64+x72+x65y7+x16y56+x67y6+x69y5+x20y54+x71y4+x73y3+x66y10+x24y52+x75y2+x77y+x70y8+x28y50+y78+x79+x67y13+x32y48+x69y12+x64y18+x36y46+x8y74+x82y2+x75y9+x68y16+x40y44+x5y79+x77y8+x7y78+x86+x44y42+x16y70+x9y77+x2y84+x11y76+x83y5+x48y40+x13y75+x85y4+x15y74+x52y38+x24y66+x17y73+x10y80+x19y72+x91y+x56y36+x21y71+y92+x93+x23y70+x60y34+x25y69+x4y90+x27y68+x64y32+x29y67+xy95+x31y66+x3y94+x96y2+x68y30+x33y65+x5y93+x35y64+x7y92+x100+x72y28+x16y84+x9y91+x2y98+x11y90+x76y26+x34y68+x20y82+x13y89+x15y88+x80y24+x17y87+x3y101+x19y86+x5y100+x84y22+x42y64+x21y85+x23y84+x88y20+x32y76+x25y83+x11y97+x4y104+x27y82+x13y96+x92y18+x36y74+x29y81+x31y80+x96y16+x33y79+x5y107+x35y78+x7y106+y113+x100y14+x37y77+x9y105+x2y112+x39y76+x11y104+x104y12+x48y68+x41y75+x20y96+x6y110+x43y74+x108y10+x52y66+x45y73+x10y108+x47y72+x112y8+x49y71+x21y99+x14y106+x7y113+x51y70+x23y98+x9y112+x116y6+x53y69+x25y97+x18y104+x55y68+x27y96+x120y4+x57y67+x22y102+x59y66+x124y2+x61y65+x26y100+x63y64+y127+x30y98+x2y126+x32y97+x4y125+x6y124+x8y123+xy130+x129y3+x66y66+x10y122+x131y2+x12y121+x5y128+x133y+x14y120+x135+x16y119+x67y69+x39y97+x18y118+x69y68+x41y96+x20y117+x22y116+x24y115+x75y65+x68y72+x26y114+x77y64+x28y113+x128y14+x30y112+x32y111+x69y75+x34y110+x71y74+x64y81+x36y109+x8y137+x136y10+x73y73+x66y80+x38y108+x10y136+x75y72+x40y107+x133y15+x84y64+x70y78+x42y106+x135y14+x44y105+x144y6+x137y13+x130y20+x74y76+x46y104+x139y12+x48y103+x141y11+x85y67+x78y74+x71y81+x50y102+x143y10+x87y66+x73y80+x52y101+x24y129+x152y2+x145y9+x138y16+x89y65+x82y72+x54y100+x26y128+x147y8+x91y64+x56y99+x149y7+x128y28+x86y70+x58y98+x151y6+x60y97+x153y5+x132y26+x90y68+x62y96+x155y4+x64y95+x8y151+x157y3+x129y31+x94y66+x66y94+x10y150+x159y2+x131y30+x96y65+x68y93+x12y149+x161y+x133y29+x70y92+x14y148+x163+x135y28+x72y91+x16y147+x9y154+x144y20+x137y27+x130y34+x74y90+x18y146+x139y26+x76y89+x20y145+x13y152+x162y4+x148y18+x141y25+x78y88+x22y144+x143y24+x80y87+x145y23+x131y37+x103y65+x82y86+x147y22+x133y36+x105y64+x84y85+x170+x149y21+x86y84+x151y20+x88y83+x25y146+x160y12+x153y19+x139y33+x132y40+x90y82+x155y18+x141y32+x92y81+x29y144+x164y10+x157y17+x94y80+x159y16+x96y79+x40y135+x161y15+x133y43+x98y78+x42y134+x163y14+x135y42+x128y49+x100y77+x44y133+x165y13+x137y41+x130y48+x102y76+x46y132+x167y12+x139y40+x104y75+x48y131+x41y138+x176y4+x169y11+x148y32+x134y46+x106y74+x50y130+x171y10+x108y73+x52y129+x45y136+x180y2+x173y9+x138y44+x110y72+x54y128+x175y8+x112y71+x177y7+x149y35+x142y42+x135y49+x114y70+x179y6+x151y34+x137y48+x116y69+x181y5+x153y33+x146y40+x118y68+x183y4+x155y32+x120y67+x57y130+x185y3+x150y38+x122y66+x187y2+x124y65+x61y128+x189y+x154y36+x126y64+x191+x128y63+x158y34+x130y62+x160y33+x132y61+x134y60+x136y59+x194y2+x138y58+x140y57+x142y56+x144y55+x195y5+x167y33+x146y54+x197y4+x169y32+x148y53+x150y52+x152y51+x203y+x196y8+x154y50+x205+x156y49+x158y48+x160y47+x197y11+x162y46+x199y10+x192y17+x164y45+x201y9+x194y16+x166y44+x203y8+x168y43+x212+x198y14+x170y42+x172y41+x202y12+x174y40+x176y39+x213y3+x206y10+x199y17+x178y38+x215y2+x201y16+x180y37+x217y+x210y8+x182y36+x219+x184y35+x214y6+x186y34+x188y33+x218y4+x190y32+x192y31+x222y2+x194y30+x224y+x196y29+x198y28+x200y27+x202y26+x204y25+x206y24+x208y23+x231y+x210y22+x233+x212y21+x214y20+x216y19+x218y18+x220y17+x222y16+x224y15+x226y14+x228y13+x230y12+x232y11+x234y10+x236y9+x238y8+x240y7+x242y6+x244y5+x246y4+x248y3+x250y2+x252y+x254+x257y2+x261+x264y9+x266y8+x280y+x282+x264y23+x266y22+x268y21+x270y20+x272y19+x265y26+x274y18+x276y17+x269y24+x278y16+x281y18+x285y16+x296y7+x298y6+x300y5+x302y4+x304y3+x297y10+x306y2+x308y+x301y8+x310+x313y2+x317\r\n"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list H=hnexpansion(f);\n",
    "H;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "display a summary of the HN expansion "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// Hamburger-Noether development of branch nr.1:\r\n",
       "  y = x^5+x^19+z(1)*x^22\r\n",
       "  x = z(1)^2+z(1)^16 + ..... (terms of degree >=17)\r\n",
       "\r\n"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "displayHNE(H);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "parameterization of the (unique) branch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** Warning: result is exact up to order 16 in x and 24 in y !\r\n",
       "_[1]=x2+x16\r\n",
       "_[2]=x10+x24+x38+x45+x52+x73+x101+x129+x262+x269+x276+x290+x297+x304+x325+x353\r\n"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param(H[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "increase the exactness if necessary "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** Warning: result is exact up to order 44 in x and 52 in y !\r\n",
       "_[1]=x2+x16+x23+x30+x44\r\n",
       "_[2]=x10+x24+x31+x45+x59+x66+x73+x87+x94+x101+x108+x122+x129+x143+x157+x171+x178+x185+x192+x206+x213+x220+x255+x262+x276+x283+x304+x318+x325+x332+x339+x346+x353+x416+x423+x430+x444+x451+x458+x465+x479+x493+x521+x528+x535+x542+x556+x563+x570+x577+x591+x598+x612+x619+x647+x661+x703+x710+x724+x731+x752+x766+x773+x780+x787+x794+x801+x822+x829+x836+x843+x857+x871+x885+x927+x941+x969\r\n"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param(extdevelop(H[1], 40));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an example with several branches "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// Hamburger-Noether development of branch nr.1:\r\n",
       "  x = z(1)*y\r\n",
       "  y = z(1)^2\r\n",
       "\r\n",
       "// Hamburger-Noether development of branch nr.2:\r\n",
       "  x = z(1)*y\r\n",
       "  y = -z(1)^2\r\n",
       "\r\n"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ring R = 0, (x,y), dp;\n",
    "list Hne=hnexpansion(x4-y6);\n",
    "displayHNE(Hne);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "parameterization of the first branch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=x3\r\n",
       "_[2]=x2\r\n"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param(Hne[1]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "parameterization of the second branch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_[1]=-x3\r\n",
       "_[2]=-x2\r\n"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param(Hne[2]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an example where a field extension is necessary for the HNE "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// list, 1 element(s):\r\n",
       "[1]:\r\n",
       "   // ring: (0,a),(x,y),(ls(2),C);\r\n",
       "   // minpoly = (a2+1)\r\n",
       "// objects belonging to this ring:\r\n",
       "// f                              [0]  poly\r\n",
       "// hne                            [0]  list, size: 4\r\n"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list L=hnexpansion((x4-y6)*(y2+x4));\n",
    "show(L);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define the local ring where the computations are stored "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "//   characteristic : 0\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : (a2+1)\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def HNring = L[1];\n",
    "setring HNring;\n",
    "basering;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "show the computations "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// Hamburger-Noether development of branch nr.1:\r\n",
       "  y = (a)*x^2\r\n",
       "\r\n",
       "// Hamburger-Noether development of branch nr.2:\r\n",
       "  y = (-a)*x^2\r\n",
       "\r\n",
       "// Hamburger-Noether development of branch nr.3:\r\n",
       "  x = z(1)*y\r\n",
       "  y = z(1)^2\r\n",
       "\r\n",
       "// Hamburger-Noether development of branch nr.4:\r\n",
       "  x = z(1)*y\r\n",
       "  y = -z(1)^2\r\n",
       "\r\n"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "displayHNE(hne);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LIBRARY \"brnoeth\" \n",
    "Brill-Noether algorithm, Weierstrass semigroups, and AG codes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** killing the basering for level 0\r\n"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "killall();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "LIB \"brnoeth.lib\";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The library works with plane algebraic curves, possibly with singularities. \n",
    "\n",
    "The basefield must be a prime finite field, and point over extensions can be computed if necessary. \n",
    "\n",
    "The initial equation must be affine, but the library works with the projective closure. \n",
    "\n",
    "The computed points are \"closed\", meaning that only one of the conjugates by the Frobenius map is considered, until we extend the curve over a field extension. \n",
    "\n",
    "Since points can be singular, for the AG codes we consider branches of the desingularized curve, which are computed by means of Hamburger-Noether expansions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "affine global ring to define the curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ring s=2,(x,y),lp;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adjunction Divisor: singular points with their delta invariants, after the resolution of all the singularities "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "[2]:\r\n",
       "   9,3\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1,1\r\n",
       "   [2]:\r\n",
       "      1,2\r\n",
       "   [3]:\r\n",
       "      2,1\r\n",
       "   [4]:\r\n",
       "      1,3\r\n",
       "[4]:\r\n",
       "   2,2,2,42\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         1,1,1\r\n",
       "   [2]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         2\r\n"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list C=Adj_div(y9+y8+xy6+x2y3+y2+x3);\n",
    "C;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define the affine ring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def aff_R=C[1][1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "data stored in aff_R "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// aff_R                          [0]  *ring\r\n",
       "// Inf_Points                     [0]  list, size: 2\r\n",
       "// Aff_SPoints                    [0]  list, size: 3\r\n",
       "// Aff_SLocus                     [0]  ideal (SB), 2 generator(s)\r\n",
       "// CHI                            [0]  poly\r\n"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setring aff_R;\n",
    "listvar(aff_R);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the affine equation of the curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x3+x2y3+xy6+y9+y8+y2\r\n"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHI;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the ideal of the affine singular locus "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aff_SLocus[1]=y8+y2\r\n",
       "Aff_SLocus[2]=x2+y6\r\n"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_SLocus;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "affine singular points (numbered from 1 to 3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y+1\r\n",
       "      _[2]=x+1\r\n",
       "   [2]:\r\n",
       "      1\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y\r\n",
       "      _[2]=x\r\n",
       "   [2]:\r\n",
       "      2\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y2+y+1\r\n",
       "      _[2]=x+1\r\n",
       "   [2]:\r\n",
       "      3\r\n"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_SPoints;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "singular point(s) at infinity: (1:0:0) with number 4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      y\r\n",
       "   [2]:\r\n",
       "      4\r\n"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Inf_Points[1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "non-singular points at infinity (none, in this case) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "empty list\r\n"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Inf_Points[2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "projective ring (it will be necessary later, to define rational functions) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "//   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def proj_R=C[1][2];\n",
    "setring proj_R;\n",
    "basering; "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "projective equation of the curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x3z6+x2y3z4+xy6z2+y9+y8z+y2z7\r\n"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHI;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the degree of the curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9\r\n"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[2][1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the genus of the curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[2][2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list of computed (closed) places of the curve, represented with two integers: \n",
    "- the first integer is the degree of the point \n",
    "- the second integer is the index of the point in the list of points of this degree, which is in the corresponding local ring (in C[5]) \n",
    "\n",
    "In this example, there are 3 points of degree 1 and one of degree 2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,1\r\n",
       "[2]:\r\n",
       "   1,2\r\n",
       "[3]:\r\n",
       "   2,1\r\n",
       "[4]:\r\n",
       "   1,3\r\n"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[3];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the adjunction divisor "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2,2,2,42\r\n"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[4];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "local rings for points over extensions, where to find local data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      1,1,1\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      2\r\n"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[5];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for example, let us see the places (i.e. branches) of degree 2 (over $F_4$) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// S(2)                           [0]  *ring\r\n",
       "//      PARAMETRIZATIONS               [0]  list, size: 1\r\n",
       "//      BRANCHES                       [0]  list, size: 1\r\n",
       "//      LOC_EQS                        [0]  list, size: 1\r\n",
       "//      POINTS                         [0]  list, size: 1\r\n",
       "// proj_R                         [0]  ring\r\n",
       "// aff_R                          [0]  ring\r\n",
       "// C                              [0]  list, size: 5\r\n",
       "// s                              [0]  ring\r\n"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def S(2)=C[5][2][1];\n",
    "setring S(2);\n",
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "base points of the places: (1:a:1) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      1\r\n",
       "   [2]:\r\n",
       "      (a)\r\n",
       "   [3]:\r\n",
       "      1\r\n"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "POINTS;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "local equations (the base point is translated to the origin) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   y2+y3+(a+1)*y4+y6+(a+1)*y8+y9+(a)*xy2+(a+1)*xy4+xy6+(a+1)*x2y+(a)*x2y2+x2y3+x3\r\n"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LOC_EQS;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HNEs of the branches "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1,1]=0\r\n",
       "      _[1,2]=x\r\n",
       "      _[1,3]=0\r\n",
       "      _[2,1]=0\r\n",
       "      _[2,2]=1\r\n",
       "      _[2,3]=(a+1)\r\n",
       "   [2]:\r\n",
       "      1,-4\r\n",
       "   [3]:\r\n",
       "      0\r\n",
       "   [4]:\r\n",
       "      y+(a+1)*xy+(a)*x2y+(a)*x2y2+(a+1)*x3+x3y+x3y3+(a)*x4+(a+1)*x4y2+(a+1)*x4y3+x5+x5y2+(a)*x6+(a+1)*x6y2+x6y4+x6y5+x7y+(a+1)*x8+(a+1)*x8y+x8y4+(a+1)*x8y6+x9+x9y7+(a+1)*x10+x11y6+(a+1)*x12y4+x13y5+x14+x14y+x15y4+x16+(a+1)*x16y2+x17y3+x19y2+(a+1)*x20+x21y+x23\r\n"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BRANCHES;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "parameterizations of the branches and their exactness "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=t2+(a+1)*t3\r\n",
       "      _[2]=t3+(a+1)*t4\r\n",
       "   [2]:\r\n",
       "      3,4\r\n"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PARAMETRIZATIONS;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "non-singular points of given degrees "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Computing non-singular affine places of degree 1 ... \r\n",
       "Computing non-singular affine places of degree 2 ... \r\n",
       "Computing non-singular affine places of degree 3 ... \r\n",
       "Computing non-singular affine places of degree 4 ... \r\n"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C = NSplaces(1..4, C);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "places are updated: note that we have now 2 points of degree 3 and 3 points of degree 4 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,1\r\n",
       "[2]:\r\n",
       "   1,2\r\n",
       "[3]:\r\n",
       "   2,1\r\n",
       "[4]:\r\n",
       "   1,3\r\n",
       "[5]:\r\n",
       "   3,1\r\n",
       "[6]:\r\n",
       "   3,2\r\n",
       "[7]:\r\n",
       "   4,1\r\n",
       "[8]:\r\n",
       "   4,2\r\n",
       "[9]:\r\n",
       "   4,3\r\n"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C[3];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Brill-Noether algorithm: to compute a vector basis for a Riemann-Roch space L(G) \n",
    "\n",
    "define a rational divisor G with the first and third places of C "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "intvec G=4,0,4;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we need to move to the projective ring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "setring proj_R;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the Brill-Noether algorithm "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Forms of degree 10 : \r\n",
       "66\r\n",
       " \r\n",
       "Vector basis successfully computed \r\n",
       " \r\n"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list LG=BrillNoether(G,C);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the vector basis: each rational function is given by a couple numerator / denominator "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   _[1]=x2z4+xy3z2\r\n",
       "   _[2]=y6+z6\r\n",
       "[2]:\r\n",
       "   _[1]=x2z5+xy3z3\r\n",
       "   _[2]=y7+yz6\r\n",
       "[3]:\r\n",
       "   _[1]=x2z4+xz5\r\n",
       "   _[2]=y6+z6\r\n",
       "[4]:\r\n",
       "   _[1]=x2z4+y6\r\n",
       "   _[2]=y6+z6\r\n",
       "[5]:\r\n",
       "   _[1]=x2z5+y6z\r\n",
       "   _[2]=y7+yz6\r\n",
       "[6]:\r\n",
       "   _[1]=xyz4+y4z2\r\n",
       "   _[2]=y6+z6\r\n",
       "[7]:\r\n",
       "   _[1]=x2z4+y3z3\r\n",
       "   _[2]=y6+z6\r\n",
       "[8]:\r\n",
       "   _[1]=x2z5+y3z4\r\n",
       "   _[2]=y7+yz6\r\n",
       "[9]:\r\n",
       "   _[1]=xyz4+yz5\r\n",
       "   _[2]=y6+z6\r\n",
       "[10]:\r\n",
       "   _[1]=x2z4+z6\r\n",
       "   _[2]=y6+z6\r\n"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LG;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "computing the Weierstrass semigroup at the infinity point (number 4), up to m=6 (note that the genus is g=3) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Forms of degree 10 : \r\n",
       "66\r\n",
       " \r\n",
       "Vector basis successfully computed \r\n",
       " \r\n"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list WS=Weierstrass(4,6,C);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the first list is the numerical semigroup, and the second one are the associated functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      0\r\n",
       "   [2]:\r\n",
       "      3\r\n",
       "   [3]:\r\n",
       "      4\r\n",
       "   [4]:\r\n",
       "      6\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      _[1]=1\r\n",
       "      _[2]=1\r\n",
       "   [2]:\r\n",
       "      _[1]=y\r\n",
       "      _[2]=z\r\n",
       "   [3]:\r\n",
       "      _[1]=xyz+yz2\r\n",
       "      _[2]=xz2+y3\r\n",
       "   [4]:\r\n",
       "      _[1]=y2\r\n",
       "      _[2]=z2\r\n"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "WS;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "extend the curve to $F_{16}$ (this is intended to use rational points over extensions) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "   [3]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [4]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "   [5]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "[2]:\r\n",
       "   9,3,17\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1,1\r\n",
       "   [2]:\r\n",
       "      1,2\r\n",
       "   [3]:\r\n",
       "      2,1\r\n",
       "   [4]:\r\n",
       "      1,3\r\n",
       "   [5]:\r\n",
       "      3,1\r\n",
       "   [6]:\r\n",
       "      3,2\r\n",
       "   [7]:\r\n",
       "      4,1\r\n",
       "   [8]:\r\n",
       "      4,2\r\n",
       "   [9]:\r\n",
       "      4,3\r\n",
       "[4]:\r\n",
       "   2,2,2,42\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         1,1,1\r\n",
       "   [2]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         2\r\n",
       "   [3]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         3,3\r\n",
       "   [4]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         4,4,4\r\n"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list C4 = extcurve(4, C);\n",
    "C4;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "go to the ring where the points over $F_{16}$ are "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// f16                            [0]  *ring\r\n",
       "//      PARAMETRIZATIONS               [0]  list, size: 17\r\n",
       "//      BRANCHES                       [0]  list, size: 17\r\n",
       "//      LOC_EQS                        [0]  list, size: 17\r\n",
       "//      POINTS                         [0]  list, size: 17\r\n",
       "// C4                             [0]  list, size: 5\r\n",
       "// G                              [0]  intvec (3)\r\n",
       "// S(2)                           [0]  ring\r\n",
       "// proj_R                         [0]  ring\r\n",
       "// aff_R                          [0]  ring\r\n",
       "// C                              [0]  list, size: 5\r\n",
       "// s                              [0]  ring\r\n"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f16 = C4[1][5];\n",
    "setring f16;\n",
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the rational points over $F_{16}$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      1\r\n",
       "   [2]:\r\n",
       "      1\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      0\r\n",
       "   [2]:\r\n",
       "      0\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1\r\n",
       "   [2]:\r\n",
       "      0\r\n",
       "   [3]:\r\n",
       "      0\r\n",
       "[4]:\r\n",
       "   [1]:\r\n",
       "      1\r\n",
       "   [2]:\r\n",
       "      (a2+a)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      1\r\n",
       "   [2]:\r\n",
       "      (a2+a+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[6]:\r\n",
       "   [1]:\r\n",
       "      (a3+1)\r\n",
       "   [2]:\r\n",
       "      (a)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[7]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2+1)\r\n",
       "   [2]:\r\n",
       "      (a2)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[8]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2+a)\r\n",
       "   [2]:\r\n",
       "      (a+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[9]:\r\n",
       "   [1]:\r\n",
       "      (a3+a+1)\r\n",
       "   [2]:\r\n",
       "      (a2+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[10]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2+a+1)\r\n",
       "   [2]:\r\n",
       "      (a)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[11]:\r\n",
       "   [1]:\r\n",
       "      (a3+a)\r\n",
       "   [2]:\r\n",
       "      (a2)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[12]:\r\n",
       "   [1]:\r\n",
       "      (a3)\r\n",
       "   [2]:\r\n",
       "      (a+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[13]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2)\r\n",
       "   [2]:\r\n",
       "      (a2+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[14]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2+a)\r\n",
       "   [2]:\r\n",
       "      (a)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[15]:\r\n",
       "   [1]:\r\n",
       "      (a3+a+1)\r\n",
       "   [2]:\r\n",
       "      (a2)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[16]:\r\n",
       "   [1]:\r\n",
       "      (a3+1)\r\n",
       "   [2]:\r\n",
       "      (a+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n",
       "[17]:\r\n",
       "   [1]:\r\n",
       "      (a3+a2+1)\r\n",
       "   [2]:\r\n",
       "      (a2+1)\r\n",
       "   [3]:\r\n",
       "      1\r\n"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "POINTS;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the number of \"rational points\" over $F_{16}$ is computed in C4[2][3] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of AG code: the typical code over the Klein quartic "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "setring s;\n",
    "poly f=x3y+y3+x;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "first compute \"the curve\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "[2]:\r\n",
       "   4,3\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1,1\r\n",
       "   [2]:\r\n",
       "      1,2\r\n",
       "[4]:\r\n",
       "   0\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         1,1\r\n"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list KLEIN=Adj_div(f);\n",
    "KLEIN;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define the affine ring "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// r                              [0]  *ring\r\n",
       "//      Inf_Points                     [0]  list, size: 2\r\n",
       "//      Aff_SLocus                     [0]  ideal (SB), 1 generator(s)\r\n",
       "//      CHI                            [0]  poly\r\n",
       "// KLEIN                          [0]  list, size: 5\r\n",
       "// f16                            [0]  ring\r\n",
       "// C4                             [0]  list, size: 5\r\n",
       "// G                              [0]  intvec (3)\r\n",
       "// S(2)                           [0]  ring\r\n",
       "// proj_R                         [0]  ring\r\n",
       "// aff_R                          [0]  ring\r\n",
       "// C                              [0]  list, size: 5\r\n",
       "// s                              [0]  ring\r\n"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def r=KLEIN[1][1];\n",
    "setring r;\n",
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the points at infinity (singular and non-singular) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   empty list\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         x\r\n",
       "      [2]:\r\n",
       "         1\r\n",
       "   [2]:\r\n",
       "      [1]:\r\n",
       "         y\r\n",
       "      [2]:\r\n",
       "         2\r\n"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Inf_Points;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the affine singular locus (no singular point) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Aff_SLocus[1]=1\r\n"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_SLocus;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "degree of the curve = 4 (quartic) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4\r\n"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KLEIN[2][1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "genus of the Klein quartic "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KLEIN[2][2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "define the projective ring and see the projective equation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "x3y+xz3+y3z\r\n"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def R=KLEIN[1][2];\n",
    "setring R;\n",
    "CHI;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the adjunction divisor (sometimes called the \"conductor\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0\r\n"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intvec ConductorK=KLEIN[4];\n",
    "ConductorK;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the list of places "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,1\r\n",
       "[2]:\r\n",
       "   1,2\r\n"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list PlacesK=KLEIN[3];\n",
    "PlacesK;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\"local ring\" for places of degree = 1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// S(1)                           [0]  *ring\r\n",
       "//      PARAMETRIZATIONS               [0]  list, size: 2\r\n",
       "//      BRANCHES                       [0]  list, size: 2\r\n",
       "//      LOC_EQS                        [0]  list, size: 2\r\n",
       "//      POINTS                         [0]  list, size: 2\r\n",
       "// PlacesK                        [0]  list, size: 2\r\n",
       "// ConductorK                     [0]  intvec (1)\r\n",
       "// R                              [0]  ring\r\n",
       "// r                              [0]  ring\r\n",
       "// KLEIN                          [0]  list, size: 5\r\n",
       "// f16                            [0]  ring\r\n",
       "// C4                             [0]  list, size: 5\r\n",
       "// G                              [0]  intvec (3)\r\n",
       "// S(2)                           [0]  ring\r\n",
       "// proj_R                         [0]  ring\r\n",
       "// aff_R                          [0]  ring\r\n",
       "// C                              [0]  list, size: 5\r\n",
       "// s                              [0]  ring\r\n"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def S(1)=KLEIN[5][1][1];\n",
    "setring S(1);\n",
    "listvar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "compute places up to degree 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "[2]:\r\n",
       "   4,3\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1,1\r\n",
       "   [2]:\r\n",
       "      1,2\r\n",
       "   [3]:\r\n",
       "      1,3\r\n",
       "   [4]:\r\n",
       "      2,1\r\n",
       "   [5]:\r\n",
       "      3,1\r\n",
       "   [6]:\r\n",
       "      3,2\r\n",
       "   [7]:\r\n",
       "      3,3\r\n",
       "   [8]:\r\n",
       "      3,4\r\n",
       "   [9]:\r\n",
       "      3,5\r\n",
       "   [10]:\r\n",
       "      3,6\r\n",
       "   [11]:\r\n",
       "      3,7\r\n",
       "[4]:\r\n",
       "   0\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         1,1,1\r\n",
       "   [2]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         2\r\n",
       "   [3]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         3,3,3,3,3,3,3\r\n"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setring r;\n",
    "KLEIN=NSplaces(1..3,KLEIN);\n",
    "KLEIN;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check that we have few points of degree 1 (rational over $F_2$) \n",
    "\n",
    "thus, for coding purposes we have to extend the base field, to get \"many\" rational points \n",
    "\n",
    "update the list of places "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   1,1\r\n",
       "[2]:\r\n",
       "   1,2\r\n",
       "[3]:\r\n",
       "   1,3\r\n",
       "[4]:\r\n",
       "   2,1\r\n",
       "[5]:\r\n",
       "   3,1\r\n",
       "[6]:\r\n",
       "   3,2\r\n",
       "[7]:\r\n",
       "   3,3\r\n",
       "[8]:\r\n",
       "   3,4\r\n",
       "[9]:\r\n",
       "   3,5\r\n",
       "[10]:\r\n",
       "   3,6\r\n",
       "[11]:\r\n",
       "   3,7\r\n"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PlacesK=KLEIN[3];\n",
    "PlacesK;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check now the closed points of degree 1, 2 and 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y\r\n",
       "      _[2]=x\r\n",
       "   [2]:\r\n",
       "      3\r\n"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_Points(1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y2+y+1\r\n",
       "      _[2]=x+y+1\r\n",
       "   [2]:\r\n",
       "      4\r\n"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_Points(2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y+1\r\n",
       "      _[2]=x3+x+1\r\n",
       "   [2]:\r\n",
       "      5\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y2+1\r\n",
       "      _[2]=x+y\r\n",
       "   [2]:\r\n",
       "      6\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y2+1\r\n",
       "      _[2]=x+y2\r\n",
       "   [2]:\r\n",
       "      7\r\n",
       "[4]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y2+1\r\n",
       "      _[2]=x+y2+y\r\n",
       "   [2]:\r\n",
       "      8\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y+1\r\n",
       "      _[2]=x+y2+y\r\n",
       "   [2]:\r\n",
       "      9\r\n",
       "[6]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y+1\r\n",
       "      _[2]=x+y2+y+1\r\n",
       "   [2]:\r\n",
       "      10\r\n",
       "[7]:\r\n",
       "   [1]:\r\n",
       "      _[1]=y3+y+1\r\n",
       "      _[2]=x+1\r\n",
       "   [2]:\r\n",
       "      11\r\n"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Aff_Points(3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Klein quartic over $F_8$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [2]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "   [3]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 2\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y\r\n",
       "//        block   2 : ordering C\r\n",
       "   [4]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering lp\r\n",
       "//                  : names    x y z\r\n",
       "//        block   2 : ordering C\r\n",
       "   [5]:\r\n",
       "      //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "[2]:\r\n",
       "   4,3,24\r\n",
       "[3]:\r\n",
       "   [1]:\r\n",
       "      1,1\r\n",
       "   [2]:\r\n",
       "      1,2\r\n",
       "   [3]:\r\n",
       "      1,3\r\n",
       "   [4]:\r\n",
       "      2,1\r\n",
       "   [5]:\r\n",
       "      3,1\r\n",
       "   [6]:\r\n",
       "      3,2\r\n",
       "   [7]:\r\n",
       "      3,3\r\n",
       "   [8]:\r\n",
       "      3,4\r\n",
       "   [9]:\r\n",
       "      3,5\r\n",
       "   [10]:\r\n",
       "      3,6\r\n",
       "   [11]:\r\n",
       "      3,7\r\n",
       "[4]:\r\n",
       "   0\r\n",
       "[5]:\r\n",
       "   [1]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         1,1,1\r\n",
       "   [2]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         2\r\n",
       "   [3]:\r\n",
       "      [1]:\r\n",
       "         //   characteristic : 2\r\n",
       "//   1 parameter    : a \r\n",
       "//   minpoly        : ...\r\n",
       "//   number of vars : 3\r\n",
       "//        block   1 : ordering ls\r\n",
       "//                  : names    x y t\r\n",
       "//        block   2 : ordering C\r\n",
       "      [2]:\r\n",
       "         3,3,3,3,3,3,3\r\n"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KLEIN=extcurve(3,KLEIN);\n",
    "KLEIN;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input: coefficients of the divisor G (in this case, of degree 14) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "// ** redefining G **\r\n"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intvec G=6,0,0,4;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "compute the AG code L(G) by evaluating at all the rational points over $F_8$ not in the support of G "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "intvec D=2..24;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ring $F_8[x,y,z]$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0,0,(a),     (a2),    (a2+a),(a2+a+1),(a+1),   (a2+1),  (a2+a),  (a),     \r\n",
       "  (a2),    (a2+a),(a),     (a2),    (a),     (a2),    (a2+a),  (a2+a+1),\r\n",
       "  (a+1),   (a2+1),  (a2+1),  (a2+a+1),(a+1), \r\n",
       "0,0,1,       1,       1,     (a2+a+1),(a+1),   (a2+1),  (a),     (a2),    \r\n",
       "  (a2+a),  (a+1), (a2+1),  (a2+a+1),(a2+a+1),(a+1),   (a2+1),  (a),     \r\n",
       "  (a2),    (a2+a),  1,       1,       1,     \r\n",
       "0,0,1,       1,       1,     (a2),    (a2+a),  (a),     (a2+a+1),(a+1),   \r\n",
       "  (a2+1),  1,     1,       1,       (a2+a),  (a),     (a2),    1,       \r\n",
       "  1,       1,       (a2+1),  (a2+a+1),(a+1), \r\n",
       "1,0,1,       1,       1,     (a2+1),  (a2+a+1),(a+1),   (a2),    (a2+a),  \r\n",
       "  (a),     (a2+a),(a),     (a2),    (a+1),   (a2+1),  (a2+a+1),(a2+1),  \r\n",
       "  (a2+a+1),(a+1),   (a2+a+1),(a+1),   (a2+1),\r\n",
       "0,0,(a2+1),  (a2+a+1),(a+1), (a2+a+1),(a+1),   (a2+1),  (a2+a+1),(a+1),   \r\n",
       "  (a2+1),  (a2),  (a2+a),  (a),     (a2),    (a2+a),  (a),     (a2+a),  \r\n",
       "  (a),     (a2),    (a),     (a2),    (a2+a),\r\n",
       "0,0,(a2+1),  (a2+a+1),(a+1), (a2),    (a2+a),  (a),     (a2),    (a2+a),  \r\n",
       "  (a),     (a2+1),(a2+a+1),(a+1),   (a),     (a2),    (a2+a),  (a+1),   \r\n",
       "  (a2+1),  (a2+a+1),1,       1,       1,     \r\n",
       "0,0,(a2+1),  (a2+a+1),(a+1), (a2+1),  (a2+a+1),(a+1),   (a2+1),  (a2+a+1),\r\n",
       "  (a+1),   (a+1), (a2+1),  (a2+a+1),1,       1,       1,       (a2),    \r\n",
       "  (a2+a),  (a),     (a2+1),  (a2+a+1),(a+1), \r\n",
       "0,0,(a2+1),  (a2+a+1),(a+1), (a+1),   (a2+1),  (a2+a+1),(a+1),   (a2+1),  \r\n",
       "  (a2+a+1),1,     1,       1,       (a2+1),  (a2+a+1),(a+1),   (a),     \r\n",
       "  (a2),    (a2+a),  (a2+a+1),(a+1),   (a2+1),\r\n",
       "0,0,(a2+a+1),(a+1),   (a2+1),(a2+a+1),(a+1),   (a2+1),  (a2),    (a2+a),  \r\n",
       "  (a),     (a),   (a2),    (a2+a),  (a2+1),  (a2+a+1),(a+1),   1,       \r\n",
       "  1,       1,       (a2),    (a2+a),  (a),   \r\n",
       "0,0,(a2+a+1),(a+1),   (a2+1),(a2+1),  (a2+a+1),(a+1),   (a+1),   (a2+1),  \r\n",
       "  (a2+a+1),(a2),  (a2+a),  (a),     (a2+a),  (a),     (a2),    (a2+a+1),\r\n",
       "  (a+1),   (a2+1),  1,       1,       1,     \r\n",
       "0,0,(a2+a+1),(a+1),   (a2+1),(a+1),   (a2+1),  (a2+a+1),1,       1,       \r\n",
       "  1,       (a2+1),(a2+a+1),(a+1),   (a+1),   (a2+1),  (a2+a+1),(a2+a),  \r\n",
       "  (a),     (a2),    (a2+1),  (a2+a+1),(a+1), \r\n",
       "0,1,(a2+a+1),(a+1),   (a2+1),1,       1,       1,       (a2+a),  (a),     \r\n",
       "  (a2),    (a+1), (a2+1),  (a2+a+1),(a2),    (a2+a),  (a),     (a+1),   \r\n",
       "  (a2+1),  (a2+a+1),(a2+a+1),(a+1),   (a2+1) \r\n"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def ER=KLEIN[1][4];\n",
    "setring ER;\n",
    "matrix CL=AGcode_L(G,D,KLEIN);\n",
    "print(CL);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dimension of the code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12\r\n"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nrows(CL);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "length of the code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23\r\n"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ncols(CL);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dual code (Omega code) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a2+1),  0,       (a),     (a2+a),  (a+1), (a2+a),(a2+a),  0,     (a+1),   \r\n",
       "  (a2),  0,       (a2),  1,0,0,0,0,0,0,0,0,0,0,\r\n",
       "(a2),    0,       (a),     (a2+a),  (a+1), (a),   0,       (a),   1,       \r\n",
       "  0,     (a2+a),  (a2+1),0,1,0,0,0,0,0,0,0,0,0,\r\n",
       "(a2+1),  (a2),    1,       (a2+a+1),(a+1), (a),   (a),     (a2+a),(a),     \r\n",
       "  (a2+a),(a),     (a2+1),0,0,1,0,0,0,0,0,0,0,0,\r\n",
       "1,       (a2+a),  0,       (a2+1),  1,     (a2+a),0,       (a2),  (a2+a),  \r\n",
       "  (a2+1),(a),     1,     0,0,0,1,0,0,0,0,0,0,0,\r\n",
       "(a2),    (a),     (a+1),   (a2+a),  (a2),  0,     (a2),    0,     (a2+a+1),\r\n",
       "  (a2+a),(a2+a+1),(a2),  0,0,0,0,1,0,0,0,0,0,0,\r\n",
       "(a),     (a+1),   (a2+1),  (a2),    (a2+a),(a2+1),(a),     (a+1), (a),     \r\n",
       "  (a2),  (a2+1),  0,     0,0,0,0,0,1,0,0,0,0,0,\r\n",
       "(a2),    (a2+1),  (a),     (a2+a+1),(a2+a),(a2+1),(a2+a+1),(a2),  (a2+a+1),\r\n",
       "  (a2),  (a2+a),  0,     0,0,0,0,0,0,1,0,0,0,0,\r\n",
       "(a2+a),  (a2+a+1),(a),     (a2),    (a+1), (a2+a),(a2+a+1),(a+1), (a),     \r\n",
       "  (a+1), (a2+a),  0,     0,0,0,0,0,0,0,1,0,0,0,\r\n",
       "(a2+a),  (a2+a+1),(a2+a+1),(a2+a),  (a),   1,     0,       (a2+1),(a+1),   \r\n",
       "  (a),   (a2+a+1),1,     0,0,0,0,0,0,0,0,1,0,0,\r\n",
       "(a2+a+1),(a+1),   (a2+a),  (a2+1),  1,     1,     (a2+a+1),0,     0,       \r\n",
       "  1,     (a2),    (a2),  0,0,0,0,0,0,0,0,0,1,0,\r\n",
       "0,       (a2+1),  (a2+a),  0,       (a2+a),(a),   (a+1),   (a+1), (a2+a+1),\r\n",
       "  (a2+1),1,       (a2+1),0,0,0,0,0,0,0,0,0,0,1 \r\n"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix CO=AGcode_Omega(G,D,KLEIN);\n",
    "print(CO);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "dimension "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11\r\n"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nrows(CO);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23\r\n"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ncols(CO);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "directly by computing the dual code of CL "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dual_code(CL)==CO;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decoding (preprocessing of the algorithm of Skorobogatov and Vladut): we need a divisor F of degree $\\geq 6$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   _[1,1]=0\r\n",
       "   _[1,2]=0\r\n",
       "   _[1,3]=(a)\r\n",
       "   _[1,4]=(a2)\r\n",
       "   _[1,5]=(a2+a)\r\n",
       "   _[1,6]=(a2+a+1)\r\n",
       "   _[1,7]=(a+1)\r\n",
       "   _[1,8]=(a2+1)\r\n",
       "   _[1,9]=(a2+a)\r\n",
       "   _[1,10]=(a)\r\n",
       "   _[1,11]=(a2)\r\n",
       "   _[1,12]=(a2+a)\r\n",
       "   _[1,13]=(a)\r\n",
       "   _[1,14]=(a2)\r\n",
       "   _[1,15]=(a)\r\n",
       "   _[1,16]=(a2)\r\n",
       "   _[1,17]=(a2+a)\r\n",
       "   _[1,18]=(a2+a+1)\r\n",
       "   _[1,19]=(a+1)\r\n",
       "   _[1,20]=(a2+1)\r\n",
       "   _[1,21]=(a2+1)\r\n",
       "   _[1,22]=(a2+a+1)\r\n",
       "   _[1,23]=(a+1)\r\n",
       "   _[2,1]=0\r\n",
       "   _[2,2]=0\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=1\r\n",
       "   _[2,5]=1\r\n",
       "   _[2,6]=(a2+a+1)\r\n",
       "   _[2,7]=(a+1)\r\n",
       "   _[2,8]=(a2+1)\r\n",
       "   _[2,9]=(a)\r\n",
       "   _[2,10]=(a2)\r\n",
       "   _[2,11]=(a2+a)\r\n",
       "   _[2,12]=(a+1)\r\n",
       "   _[2,13]=(a2+1)\r\n",
       "   _[2,14]=(a2+a+1)\r\n",
       "   _[2,15]=(a2+a+1)\r\n",
       "   _[2,16]=(a+1)\r\n",
       "   _[2,17]=(a2+1)\r\n",
       "   _[2,18]=(a)\r\n",
       "   _[2,19]=(a2)\r\n",
       "   _[2,20]=(a2+a)\r\n",
       "   _[2,21]=1\r\n",
       "   _[2,22]=1\r\n",
       "   _[2,23]=1\r\n",
       "   _[3,1]=0\r\n",
       "   _[3,2]=0\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=1\r\n",
       "   _[3,5]=1\r\n",
       "   _[3,6]=(a2)\r\n",
       "   _[3,7]=(a2+a)\r\n",
       "   _[3,8]=(a)\r\n",
       "   _[3,9]=(a2+a+1)\r\n",
       "   _[3,10]=(a+1)\r\n",
       "   _[3,11]=(a2+1)\r\n",
       "   _[3,12]=1\r\n",
       "   _[3,13]=1\r\n",
       "   _[3,14]=1\r\n",
       "   _[3,15]=(a2+a)\r\n",
       "   _[3,16]=(a)\r\n",
       "   _[3,17]=(a2)\r\n",
       "   _[3,18]=1\r\n",
       "   _[3,19]=1\r\n",
       "   _[3,20]=1\r\n",
       "   _[3,21]=(a2+1)\r\n",
       "   _[3,22]=(a2+a+1)\r\n",
       "   _[3,23]=(a+1)\r\n",
       "   _[4,1]=1\r\n",
       "   _[4,2]=0\r\n",
       "   _[4,3]=1\r\n",
       "   _[4,4]=1\r\n",
       "   _[4,5]=1\r\n",
       "   _[4,6]=(a2+1)\r\n",
       "   _[4,7]=(a2+a+1)\r\n",
       "   _[4,8]=(a+1)\r\n",
       "   _[4,9]=(a2)\r\n",
       "   _[4,10]=(a2+a)\r\n",
       "   _[4,11]=(a)\r\n",
       "   _[4,12]=(a2+a)\r\n",
       "   _[4,13]=(a)\r\n",
       "   _[4,14]=(a2)\r\n",
       "   _[4,15]=(a+1)\r\n",
       "   _[4,16]=(a2+1)\r\n",
       "   _[4,17]=(a2+a+1)\r\n",
       "   _[4,18]=(a2+1)\r\n",
       "   _[4,19]=(a2+a+1)\r\n",
       "   _[4,20]=(a+1)\r\n",
       "   _[4,21]=(a2+a+1)\r\n",
       "   _[4,22]=(a+1)\r\n",
       "   _[4,23]=(a2+1)\r\n",
       "   _[5,1]=0\r\n",
       "   _[5,2]=0\r\n",
       "   _[5,3]=(a2+1)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[5,5]=(a+1)\r\n",
       "   _[5,6]=(a2+a+1)\r\n",
       "   _[5,7]=(a+1)\r\n",
       "   _[5,8]=(a2+1)\r\n",
       "   _[5,9]=(a2+a+1)\r\n",
       "   _[5,10]=(a+1)\r\n",
       "   _[5,11]=(a2+1)\r\n",
       "   _[5,12]=(a2)\r\n",
       "   _[5,13]=(a2+a)\r\n",
       "   _[5,14]=(a)\r\n",
       "   _[5,15]=(a2)\r\n",
       "   _[5,16]=(a2+a)\r\n",
       "   _[5,17]=(a)\r\n",
       "   _[5,18]=(a2+a)\r\n",
       "   _[5,19]=(a)\r\n",
       "   _[5,20]=(a2)\r\n",
       "   _[5,21]=(a)\r\n",
       "   _[5,22]=(a2)\r\n",
       "   _[5,23]=(a2+a)\r\n",
       "   _[6,1]=0\r\n",
       "   _[6,2]=0\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=(a2+a+1)\r\n",
       "   _[6,5]=(a+1)\r\n",
       "   _[6,6]=(a2)\r\n",
       "   _[6,7]=(a2+a)\r\n",
       "   _[6,8]=(a)\r\n",
       "   _[6,9]=(a2)\r\n",
       "   _[6,10]=(a2+a)\r\n",
       "   _[6,11]=(a)\r\n",
       "   _[6,12]=(a2+1)\r\n",
       "   _[6,13]=(a2+a+1)\r\n",
       "   _[6,14]=(a+1)\r\n",
       "   _[6,15]=(a)\r\n",
       "   _[6,16]=(a2)\r\n",
       "   _[6,17]=(a2+a)\r\n",
       "   _[6,18]=(a+1)\r\n",
       "   _[6,19]=(a2+1)\r\n",
       "   _[6,20]=(a2+a+1)\r\n",
       "   _[6,21]=1\r\n",
       "   _[6,22]=1\r\n",
       "   _[6,23]=1\r\n",
       "   _[7,1]=0\r\n",
       "   _[7,2]=0\r\n",
       "   _[7,3]=(a2+1)\r\n",
       "   _[7,4]=(a2+a+1)\r\n",
       "   _[7,5]=(a+1)\r\n",
       "   _[7,6]=(a2+1)\r\n",
       "   _[7,7]=(a2+a+1)\r\n",
       "   _[7,8]=(a+1)\r\n",
       "   _[7,9]=(a2+1)\r\n",
       "   _[7,10]=(a2+a+1)\r\n",
       "   _[7,11]=(a+1)\r\n",
       "   _[7,12]=(a+1)\r\n",
       "   _[7,13]=(a2+1)\r\n",
       "   _[7,14]=(a2+a+1)\r\n",
       "   _[7,15]=1\r\n",
       "   _[7,16]=1\r\n",
       "   _[7,17]=1\r\n",
       "   _[7,18]=(a2)\r\n",
       "   _[7,19]=(a2+a)\r\n",
       "   _[7,20]=(a)\r\n",
       "   _[7,21]=(a2+1)\r\n",
       "   _[7,22]=(a2+a+1)\r\n",
       "   _[7,23]=(a+1)\r\n",
       "   _[8,1]=0\r\n",
       "   _[8,2]=0\r\n",
       "   _[8,3]=(a2+1)\r\n",
       "   _[8,4]=(a2+a+1)\r\n",
       "   _[8,5]=(a+1)\r\n",
       "   _[8,6]=(a+1)\r\n",
       "   _[8,7]=(a2+1)\r\n",
       "   _[8,8]=(a2+a+1)\r\n",
       "   _[8,9]=(a+1)\r\n",
       "   _[8,10]=(a2+1)\r\n",
       "   _[8,11]=(a2+a+1)\r\n",
       "   _[8,12]=1\r\n",
       "   _[8,13]=1\r\n",
       "   _[8,14]=1\r\n",
       "   _[8,15]=(a2+1)\r\n",
       "   _[8,16]=(a2+a+1)\r\n",
       "   _[8,17]=(a+1)\r\n",
       "   _[8,18]=(a)\r\n",
       "   _[8,19]=(a2)\r\n",
       "   _[8,20]=(a2+a)\r\n",
       "   _[8,21]=(a2+a+1)\r\n",
       "   _[8,22]=(a+1)\r\n",
       "   _[8,23]=(a2+1)\r\n",
       "   _[9,1]=0\r\n",
       "   _[9,2]=0\r\n",
       "   _[9,3]=(a2+a+1)\r\n",
       "   _[9,4]=(a+1)\r\n",
       "   _[9,5]=(a2+1)\r\n",
       "   _[9,6]=(a2+a+1)\r\n",
       "   _[9,7]=(a+1)\r\n",
       "   _[9,8]=(a2+1)\r\n",
       "   _[9,9]=(a2)\r\n",
       "   _[9,10]=(a2+a)\r\n",
       "   _[9,11]=(a)\r\n",
       "   _[9,12]=(a)\r\n",
       "   _[9,13]=(a2)\r\n",
       "   _[9,14]=(a2+a)\r\n",
       "   _[9,15]=(a2+1)\r\n",
       "   _[9,16]=(a2+a+1)\r\n",
       "   _[9,17]=(a+1)\r\n",
       "   _[9,18]=1\r\n",
       "   _[9,19]=1\r\n",
       "   _[9,20]=1\r\n",
       "   _[9,21]=(a2)\r\n",
       "   _[9,22]=(a2+a)\r\n",
       "   _[9,23]=(a)\r\n",
       "   _[10,1]=0\r\n",
       "   _[10,2]=0\r\n",
       "   _[10,3]=(a2+a+1)\r\n",
       "   _[10,4]=(a+1)\r\n",
       "   _[10,5]=(a2+1)\r\n",
       "   _[10,6]=(a2+1)\r\n",
       "   _[10,7]=(a2+a+1)\r\n",
       "   _[10,8]=(a+1)\r\n",
       "   _[10,9]=(a+1)\r\n",
       "   _[10,10]=(a2+1)\r\n",
       "   _[10,11]=(a2+a+1)\r\n",
       "   _[10,12]=(a2)\r\n",
       "   _[10,13]=(a2+a)\r\n",
       "   _[10,14]=(a)\r\n",
       "   _[10,15]=(a2+a)\r\n",
       "   _[10,16]=(a)\r\n",
       "   _[10,17]=(a2)\r\n",
       "   _[10,18]=(a2+a+1)\r\n",
       "   _[10,19]=(a+1)\r\n",
       "   _[10,20]=(a2+1)\r\n",
       "   _[10,21]=1\r\n",
       "   _[10,22]=1\r\n",
       "   _[10,23]=1\r\n",
       "   _[11,1]=0\r\n",
       "   _[11,2]=0\r\n",
       "   _[11,3]=(a2+a+1)\r\n",
       "   _[11,4]=(a+1)\r\n",
       "   _[11,5]=(a2+1)\r\n",
       "   _[11,6]=(a+1)\r\n",
       "   _[11,7]=(a2+1)\r\n",
       "   _[11,8]=(a2+a+1)\r\n",
       "   _[11,9]=1\r\n",
       "   _[11,10]=1\r\n",
       "   _[11,11]=1\r\n",
       "   _[11,12]=(a2+1)\r\n",
       "   _[11,13]=(a2+a+1)\r\n",
       "   _[11,14]=(a+1)\r\n",
       "   _[11,15]=(a+1)\r\n",
       "   _[11,16]=(a2+1)\r\n",
       "   _[11,17]=(a2+a+1)\r\n",
       "   _[11,18]=(a2+a)\r\n",
       "   _[11,19]=(a)\r\n",
       "   _[11,20]=(a2)\r\n",
       "   _[11,21]=(a2+1)\r\n",
       "   _[11,22]=(a2+a+1)\r\n",
       "   _[11,23]=(a+1)\r\n",
       "   _[12,1]=0\r\n",
       "   _[12,2]=1\r\n",
       "   _[12,3]=(a2+a+1)\r\n",
       "   _[12,4]=(a+1)\r\n",
       "   _[12,5]=(a2+1)\r\n",
       "   _[12,6]=1\r\n",
       "   _[12,7]=1\r\n",
       "   _[12,8]=1\r\n",
       "   _[12,9]=(a2+a)\r\n",
       "   _[12,10]=(a)\r\n",
       "   _[12,11]=(a2)\r\n",
       "   _[12,12]=(a+1)\r\n",
       "   _[12,13]=(a2+1)\r\n",
       "   _[12,14]=(a2+a+1)\r\n",
       "   _[12,15]=(a2)\r\n",
       "   _[12,16]=(a2+a)\r\n",
       "   _[12,17]=(a)\r\n",
       "   _[12,18]=(a+1)\r\n",
       "   _[12,19]=(a2+1)\r\n",
       "   _[12,20]=(a2+a+1)\r\n",
       "   _[12,21]=(a2+a+1)\r\n",
       "   _[12,22]=(a+1)\r\n",
       "   _[12,23]=(a2+1)\r\n",
       "[2]:\r\n",
       "   _[1,1]=0\r\n",
       "   _[1,2]=1\r\n",
       "   _[1,3]=0\r\n",
       "   _[1,4]=0\r\n",
       "   _[2,1]=0\r\n",
       "   _[2,2]=0\r\n",
       "   _[2,3]=0\r\n",
       "   _[2,4]=0\r\n",
       "   _[3,1]=0\r\n",
       "   _[3,2]=0\r\n",
       "   _[3,3]=0\r\n",
       "   _[3,4]=0\r\n",
       "   _[4,1]=0\r\n",
       "   _[4,2]=0\r\n",
       "   _[4,3]=0\r\n",
       "   _[4,4]=0\r\n",
       "   _[5,1]=0\r\n",
       "   _[5,2]=0\r\n",
       "   _[5,3]=0\r\n",
       "   _[5,4]=0\r\n",
       "   _[6,1]=0\r\n",
       "   _[6,2]=0\r\n",
       "   _[6,3]=0\r\n",
       "   _[6,4]=0\r\n",
       "[3]:\r\n",
       "   _[1,1]=0\r\n",
       "   _[1,2]=0\r\n",
       "   _[1,3]=0\r\n",
       "   _[1,4]=0\r\n",
       "   _[2,1]=0\r\n",
       "   _[2,2]=0\r\n",
       "   _[2,3]=0\r\n",
       "   _[2,4]=0\r\n",
       "   _[3,1]=0\r\n",
       "   _[3,2]=0\r\n",
       "   _[3,3]=0\r\n",
       "   _[3,4]=0\r\n",
       "   _[4,1]=0\r\n",
       "   _[4,2]=0\r\n",
       "   _[4,3]=0\r\n",
       "   _[4,4]=0\r\n",
       "   _[5,1]=0\r\n",
       "   _[5,2]=0\r\n",
       "   _[5,3]=0\r\n",
       "   _[5,4]=0\r\n",
       "   _[6,1]=0\r\n",
       "   _[6,2]=1\r\n",
       "   _[6,3]=0\r\n",
       "   _[6,4]=0\r\n",
       "[4]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=1\r\n",
       "   _[1,3]=(a)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=(a2+1)\r\n",
       "   _[2,2]=(a2+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a2+1)\r\n",
       "   _[3,1]=(a2+1)\r\n",
       "   _[3,2]=(a2+1)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+1)\r\n",
       "   _[4,1]=(a2+a+1)\r\n",
       "   _[4,2]=(a2+a+1)\r\n",
       "   _[4,3]=(a2+1)\r\n",
       "   _[4,4]=(a2+a+1)\r\n",
       "   _[5,1]=(a2+a+1)\r\n",
       "   _[5,2]=(a2+a+1)\r\n",
       "   _[5,3]=(a2+1)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[6,1]=(a2+a+1)\r\n",
       "   _[6,2]=(a2+a+1)\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=(a2+a+1)\r\n",
       "[5]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=1\r\n",
       "   _[1,3]=(a2)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=(a2+a+1)\r\n",
       "   _[2,2]=(a2+a+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a2+a+1)\r\n",
       "   _[3,1]=(a2+a+1)\r\n",
       "   _[3,2]=(a2+a+1)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+a+1)\r\n",
       "   _[4,1]=(a+1)\r\n",
       "   _[4,2]=(a+1)\r\n",
       "   _[4,3]=(a2+a+1)\r\n",
       "   _[4,4]=(a+1)\r\n",
       "   _[5,1]=(a+1)\r\n",
       "   _[5,2]=(a+1)\r\n",
       "   _[5,3]=(a2+a+1)\r\n",
       "   _[5,4]=(a+1)\r\n",
       "   _[6,1]=(a+1)\r\n",
       "   _[6,2]=(a+1)\r\n",
       "   _[6,3]=(a2+a+1)\r\n",
       "   _[6,4]=(a+1)\r\n",
       "[6]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=1\r\n",
       "   _[1,3]=(a2+a)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=(a+1)\r\n",
       "   _[2,2]=(a+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a+1)\r\n",
       "   _[3,1]=(a+1)\r\n",
       "   _[3,2]=(a+1)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a+1)\r\n",
       "   _[4,1]=(a2+1)\r\n",
       "   _[4,2]=(a2+1)\r\n",
       "   _[4,3]=(a+1)\r\n",
       "   _[4,4]=(a2+1)\r\n",
       "   _[5,1]=(a2+1)\r\n",
       "   _[5,2]=(a2+1)\r\n",
       "   _[5,3]=(a+1)\r\n",
       "   _[5,4]=(a2+1)\r\n",
       "   _[6,1]=(a2+1)\r\n",
       "   _[6,2]=(a2+1)\r\n",
       "   _[6,3]=(a+1)\r\n",
       "   _[6,4]=(a2+1)\r\n",
       "[7]:\r\n",
       "   _[1,1]=(a2)\r\n",
       "   _[1,2]=(a2+1)\r\n",
       "   _[1,3]=(a2+a+1)\r\n",
       "   _[1,4]=(a2+a+1)\r\n",
       "   _[2,1]=(a2)\r\n",
       "   _[2,2]=(a2+1)\r\n",
       "   _[2,3]=(a2+a+1)\r\n",
       "   _[2,4]=(a2+a+1)\r\n",
       "   _[3,1]=(a2+1)\r\n",
       "   _[3,2]=(a+1)\r\n",
       "   _[3,3]=(a2)\r\n",
       "   _[3,4]=(a2)\r\n",
       "   _[4,1]=(a2)\r\n",
       "   _[4,2]=(a2+1)\r\n",
       "   _[4,3]=(a2+a+1)\r\n",
       "   _[4,4]=(a2+a+1)\r\n",
       "   _[5,1]=(a2+1)\r\n",
       "   _[5,2]=(a+1)\r\n",
       "   _[5,3]=(a2)\r\n",
       "   _[5,4]=(a2)\r\n",
       "   _[6,1]=(a+1)\r\n",
       "   _[6,2]=1\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=(a2+1)\r\n",
       "[8]:\r\n",
       "   _[1,1]=(a2+a)\r\n",
       "   _[1,2]=(a2+a+1)\r\n",
       "   _[1,3]=(a+1)\r\n",
       "   _[1,4]=(a+1)\r\n",
       "   _[2,1]=(a2+a)\r\n",
       "   _[2,2]=(a2+a+1)\r\n",
       "   _[2,3]=(a+1)\r\n",
       "   _[2,4]=(a+1)\r\n",
       "   _[3,1]=(a2+a+1)\r\n",
       "   _[3,2]=(a2+1)\r\n",
       "   _[3,3]=(a2+a)\r\n",
       "   _[3,4]=(a2+a)\r\n",
       "   _[4,1]=(a2+a)\r\n",
       "   _[4,2]=(a2+a+1)\r\n",
       "   _[4,3]=(a+1)\r\n",
       "   _[4,4]=(a+1)\r\n",
       "   _[5,1]=(a2+a+1)\r\n",
       "   _[5,2]=(a2+1)\r\n",
       "   _[5,3]=(a2+a)\r\n",
       "   _[5,4]=(a2+a)\r\n",
       "   _[6,1]=(a2+1)\r\n",
       "   _[6,2]=1\r\n",
       "   _[6,3]=(a2+a+1)\r\n",
       "   _[6,4]=(a2+a+1)\r\n",
       "[9]:\r\n",
       "   _[1,1]=(a)\r\n",
       "   _[1,2]=(a+1)\r\n",
       "   _[1,3]=(a2+1)\r\n",
       "   _[1,4]=(a2+1)\r\n",
       "   _[2,1]=(a)\r\n",
       "   _[2,2]=(a+1)\r\n",
       "   _[2,3]=(a2+1)\r\n",
       "   _[2,4]=(a2+1)\r\n",
       "   _[3,1]=(a+1)\r\n",
       "   _[3,2]=(a2+a+1)\r\n",
       "   _[3,3]=(a)\r\n",
       "   _[3,4]=(a)\r\n",
       "   _[4,1]=(a)\r\n",
       "   _[4,2]=(a+1)\r\n",
       "   _[4,3]=(a2+1)\r\n",
       "   _[4,4]=(a2+1)\r\n",
       "   _[5,1]=(a+1)\r\n",
       "   _[5,2]=(a2+a+1)\r\n",
       "   _[5,3]=(a)\r\n",
       "   _[5,4]=(a)\r\n",
       "   _[6,1]=(a2+a+1)\r\n",
       "   _[6,2]=1\r\n",
       "   _[6,3]=(a+1)\r\n",
       "   _[6,4]=(a+1)\r\n",
       "[10]:\r\n",
       "   _[1,1]=(a2+a+1)\r\n",
       "   _[1,2]=(a2)\r\n",
       "   _[1,3]=(a2+a)\r\n",
       "   _[1,4]=(a)\r\n",
       "   _[2,1]=(a2)\r\n",
       "   _[2,2]=(a2+1)\r\n",
       "   _[2,3]=(a)\r\n",
       "   _[2,4]=(a2+a+1)\r\n",
       "   _[3,1]=(a2+1)\r\n",
       "   _[3,2]=(a+1)\r\n",
       "   _[3,3]=(a2+a+1)\r\n",
       "   _[3,4]=(a2)\r\n",
       "   _[4,1]=(a2+1)\r\n",
       "   _[4,2]=(a+1)\r\n",
       "   _[4,3]=(a2+a+1)\r\n",
       "   _[4,4]=(a2)\r\n",
       "   _[5,1]=(a+1)\r\n",
       "   _[5,2]=1\r\n",
       "   _[5,3]=(a2)\r\n",
       "   _[5,4]=(a2+1)\r\n",
       "   _[6,1]=1\r\n",
       "   _[6,2]=(a2+a)\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=(a+1)\r\n",
       "[11]:\r\n",
       "   _[1,1]=(a+1)\r\n",
       "   _[1,2]=(a2+a)\r\n",
       "   _[1,3]=(a)\r\n",
       "   _[1,4]=(a2)\r\n",
       "   _[2,1]=(a2+a)\r\n",
       "   _[2,2]=(a2+a+1)\r\n",
       "   _[2,3]=(a2)\r\n",
       "   _[2,4]=(a+1)\r\n",
       "   _[3,1]=(a2+a+1)\r\n",
       "   _[3,2]=(a2+1)\r\n",
       "   _[3,3]=(a+1)\r\n",
       "   _[3,4]=(a2+a)\r\n",
       "   _[4,1]=(a2+a+1)\r\n",
       "   _[4,2]=(a2+1)\r\n",
       "   _[4,3]=(a+1)\r\n",
       "   _[4,4]=(a2+a)\r\n",
       "   _[5,1]=(a2+1)\r\n",
       "   _[5,2]=1\r\n",
       "   _[5,3]=(a2+a)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[6,1]=1\r\n",
       "   _[6,2]=(a)\r\n",
       "   _[6,3]=(a2+a+1)\r\n",
       "   _[6,4]=(a2+1)\r\n",
       "[12]:\r\n",
       "   _[1,1]=(a2+1)\r\n",
       "   _[1,2]=(a)\r\n",
       "   _[1,3]=(a2)\r\n",
       "   _[1,4]=(a2+a)\r\n",
       "   _[2,1]=(a)\r\n",
       "   _[2,2]=(a+1)\r\n",
       "   _[2,3]=(a2+a)\r\n",
       "   _[2,4]=(a2+1)\r\n",
       "   _[3,1]=(a+1)\r\n",
       "   _[3,2]=(a2+a+1)\r\n",
       "   _[3,3]=(a2+1)\r\n",
       "   _[3,4]=(a)\r\n",
       "   _[4,1]=(a+1)\r\n",
       "   _[4,2]=(a2+a+1)\r\n",
       "   _[4,3]=(a2+1)\r\n",
       "   _[4,4]=(a)\r\n",
       "   _[5,1]=(a2+a+1)\r\n",
       "   _[5,2]=1\r\n",
       "   _[5,3]=(a)\r\n",
       "   _[5,4]=(a+1)\r\n",
       "   _[6,1]=1\r\n",
       "   _[6,2]=(a2)\r\n",
       "   _[6,3]=(a+1)\r\n",
       "   _[6,4]=(a2+a+1)\r\n",
       "[13]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a2+a)\r\n",
       "   _[1,3]=(a2+a)\r\n",
       "   _[1,4]=(a+1)\r\n",
       "   _[2,1]=(a2+1)\r\n",
       "   _[2,2]=(a+1)\r\n",
       "   _[2,3]=(a+1)\r\n",
       "   _[2,4]=(a2)\r\n",
       "   _[3,1]=(a+1)\r\n",
       "   _[3,2]=1\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+1)\r\n",
       "   _[4,1]=(a2+a+1)\r\n",
       "   _[4,2]=(a2)\r\n",
       "   _[4,3]=(a2)\r\n",
       "   _[4,4]=(a)\r\n",
       "   _[5,1]=(a2)\r\n",
       "   _[5,2]=(a2+1)\r\n",
       "   _[5,3]=(a2+1)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[6,1]=(a2+1)\r\n",
       "   _[6,2]=(a+1)\r\n",
       "   _[6,3]=(a+1)\r\n",
       "   _[6,4]=(a2)\r\n",
       "[14]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a)\r\n",
       "   _[1,3]=(a)\r\n",
       "   _[1,4]=(a2+1)\r\n",
       "   _[2,1]=(a2+a+1)\r\n",
       "   _[2,2]=(a2+1)\r\n",
       "   _[2,3]=(a2+1)\r\n",
       "   _[2,4]=(a2+a)\r\n",
       "   _[3,1]=(a2+1)\r\n",
       "   _[3,2]=1\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+a+1)\r\n",
       "   _[4,1]=(a+1)\r\n",
       "   _[4,2]=(a2+a)\r\n",
       "   _[4,3]=(a2+a)\r\n",
       "   _[4,4]=(a2)\r\n",
       "   _[5,1]=(a2+a)\r\n",
       "   _[5,2]=(a2+a+1)\r\n",
       "   _[5,3]=(a2+a+1)\r\n",
       "   _[5,4]=(a+1)\r\n",
       "   _[6,1]=(a2+a+1)\r\n",
       "   _[6,2]=(a2+1)\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=(a2+a)\r\n",
       "[15]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a2)\r\n",
       "   _[1,3]=(a2)\r\n",
       "   _[1,4]=(a2+a+1)\r\n",
       "   _[2,1]=(a+1)\r\n",
       "   _[2,2]=(a2+a+1)\r\n",
       "   _[2,3]=(a2+a+1)\r\n",
       "   _[2,4]=(a)\r\n",
       "   _[3,1]=(a2+a+1)\r\n",
       "   _[3,2]=1\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a+1)\r\n",
       "   _[4,1]=(a2+1)\r\n",
       "   _[4,2]=(a)\r\n",
       "   _[4,3]=(a)\r\n",
       "   _[4,4]=(a2+a)\r\n",
       "   _[5,1]=(a)\r\n",
       "   _[5,2]=(a+1)\r\n",
       "   _[5,3]=(a+1)\r\n",
       "   _[5,4]=(a2+1)\r\n",
       "   _[6,1]=(a+1)\r\n",
       "   _[6,2]=(a2+a+1)\r\n",
       "   _[6,3]=(a2+a+1)\r\n",
       "   _[6,4]=(a)\r\n",
       "[16]:\r\n",
       "   _[1,1]=(a2+a)\r\n",
       "   _[1,2]=(a+1)\r\n",
       "   _[1,3]=(a)\r\n",
       "   _[1,4]=(a2+a+1)\r\n",
       "   _[2,1]=(a)\r\n",
       "   _[2,2]=1\r\n",
       "   _[2,3]=(a2+a+1)\r\n",
       "   _[2,4]=(a2)\r\n",
       "   _[3,1]=1\r\n",
       "   _[3,2]=(a2+1)\r\n",
       "   _[3,3]=(a2+a)\r\n",
       "   _[3,4]=(a)\r\n",
       "   _[4,1]=(a2+a+1)\r\n",
       "   _[4,2]=(a2+a)\r\n",
       "   _[4,3]=(a2)\r\n",
       "   _[4,4]=(a2+1)\r\n",
       "   _[5,1]=(a2+a)\r\n",
       "   _[5,2]=(a+1)\r\n",
       "   _[5,3]=(a)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[6,1]=(a+1)\r\n",
       "   _[6,2]=(a2)\r\n",
       "   _[6,3]=1\r\n",
       "   _[6,4]=(a2+a)\r\n",
       "[17]:\r\n",
       "   _[1,1]=(a)\r\n",
       "   _[1,2]=(a2+1)\r\n",
       "   _[1,3]=(a2)\r\n",
       "   _[1,4]=(a+1)\r\n",
       "   _[2,1]=(a2)\r\n",
       "   _[2,2]=1\r\n",
       "   _[2,3]=(a+1)\r\n",
       "   _[2,4]=(a2+a)\r\n",
       "   _[3,1]=1\r\n",
       "   _[3,2]=(a2+a+1)\r\n",
       "   _[3,3]=(a)\r\n",
       "   _[3,4]=(a2)\r\n",
       "   _[4,1]=(a+1)\r\n",
       "   _[4,2]=(a)\r\n",
       "   _[4,3]=(a2+a)\r\n",
       "   _[4,4]=(a2+a+1)\r\n",
       "   _[5,1]=(a)\r\n",
       "   _[5,2]=(a2+1)\r\n",
       "   _[5,3]=(a2)\r\n",
       "   _[5,4]=(a+1)\r\n",
       "   _[6,1]=(a2+1)\r\n",
       "   _[6,2]=(a2+a)\r\n",
       "   _[6,3]=1\r\n",
       "   _[6,4]=(a)\r\n",
       "[18]:\r\n",
       "   _[1,1]=(a2)\r\n",
       "   _[1,2]=(a2+a+1)\r\n",
       "   _[1,3]=(a2+a)\r\n",
       "   _[1,4]=(a2+1)\r\n",
       "   _[2,1]=(a2+a)\r\n",
       "   _[2,2]=1\r\n",
       "   _[2,3]=(a2+1)\r\n",
       "   _[2,4]=(a)\r\n",
       "   _[3,1]=1\r\n",
       "   _[3,2]=(a+1)\r\n",
       "   _[3,3]=(a2)\r\n",
       "   _[3,4]=(a2+a)\r\n",
       "   _[4,1]=(a2+1)\r\n",
       "   _[4,2]=(a2)\r\n",
       "   _[4,3]=(a)\r\n",
       "   _[4,4]=(a+1)\r\n",
       "   _[5,1]=(a2)\r\n",
       "   _[5,2]=(a2+a+1)\r\n",
       "   _[5,3]=(a2+a)\r\n",
       "   _[5,4]=(a2+1)\r\n",
       "   _[6,1]=(a2+a+1)\r\n",
       "   _[6,2]=(a)\r\n",
       "   _[6,3]=1\r\n",
       "   _[6,4]=(a2)\r\n",
       "[19]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a2+1)\r\n",
       "   _[1,3]=(a2+a+1)\r\n",
       "   _[1,4]=(a)\r\n",
       "   _[2,1]=(a+1)\r\n",
       "   _[2,2]=(a2)\r\n",
       "   _[2,3]=(a)\r\n",
       "   _[2,4]=(a2+a)\r\n",
       "   _[3,1]=(a2)\r\n",
       "   _[3,2]=(a)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a+1)\r\n",
       "   _[4,1]=(a2+1)\r\n",
       "   _[4,2]=(a2+a+1)\r\n",
       "   _[4,3]=(a2+a)\r\n",
       "   _[4,4]=1\r\n",
       "   _[5,1]=(a2+a+1)\r\n",
       "   _[5,2]=(a2+a)\r\n",
       "   _[5,3]=(a+1)\r\n",
       "   _[5,4]=(a2+1)\r\n",
       "   _[6,1]=(a2+a)\r\n",
       "   _[6,2]=(a+1)\r\n",
       "   _[6,3]=(a2)\r\n",
       "   _[6,4]=(a2+a+1)\r\n",
       "[20]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a2+a+1)\r\n",
       "   _[1,3]=(a+1)\r\n",
       "   _[1,4]=(a2)\r\n",
       "   _[2,1]=(a2+1)\r\n",
       "   _[2,2]=(a2+a)\r\n",
       "   _[2,3]=(a2)\r\n",
       "   _[2,4]=(a)\r\n",
       "   _[3,1]=(a2+a)\r\n",
       "   _[3,2]=(a2)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+1)\r\n",
       "   _[4,1]=(a2+a+1)\r\n",
       "   _[4,2]=(a+1)\r\n",
       "   _[4,3]=(a)\r\n",
       "   _[4,4]=1\r\n",
       "   _[5,1]=(a+1)\r\n",
       "   _[5,2]=(a)\r\n",
       "   _[5,3]=(a2+1)\r\n",
       "   _[5,4]=(a2+a+1)\r\n",
       "   _[6,1]=(a)\r\n",
       "   _[6,2]=(a2+1)\r\n",
       "   _[6,3]=(a2+a)\r\n",
       "   _[6,4]=(a+1)\r\n",
       "[21]:\r\n",
       "   _[1,1]=1\r\n",
       "   _[1,2]=(a+1)\r\n",
       "   _[1,3]=(a2+1)\r\n",
       "   _[1,4]=(a2+a)\r\n",
       "   _[2,1]=(a2+a+1)\r\n",
       "   _[2,2]=(a)\r\n",
       "   _[2,3]=(a2+a)\r\n",
       "   _[2,4]=(a2)\r\n",
       "   _[3,1]=(a)\r\n",
       "   _[3,2]=(a2+a)\r\n",
       "   _[3,3]=1\r\n",
       "   _[3,4]=(a2+a+1)\r\n",
       "   _[4,1]=(a+1)\r\n",
       "   _[4,2]=(a2+1)\r\n",
       "   _[4,3]=(a2)\r\n",
       "   _[4,4]=1\r\n",
       "   _[5,1]=(a2+1)\r\n",
       "   _[5,2]=(a2)\r\n",
       "   _[5,3]=(a2+a+1)\r\n",
       "   _[5,4]=(a+1)\r\n",
       "   _[6,1]=(a2)\r\n",
       "   _[6,2]=(a2+a+1)\r\n",
       "   _[6,3]=(a)\r\n",
       "   _[6,4]=(a2+1)\r\n",
       "[22]:\r\n",
       "   _[1,1]=(a2+1)\r\n",
       "   _[1,2]=(a2+a+1)\r\n",
       "   _[1,3]=(a2+1)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=1\r\n",
       "   _[2,2]=(a2+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a)\r\n",
       "   _[3,1]=(a2+1)\r\n",
       "   _[3,2]=(a2+a+1)\r\n",
       "   _[3,3]=(a2+1)\r\n",
       "   _[3,4]=1\r\n",
       "   _[4,1]=(a)\r\n",
       "   _[4,2]=1\r\n",
       "   _[4,3]=(a)\r\n",
       "   _[4,4]=(a2)\r\n",
       "   _[5,1]=1\r\n",
       "   _[5,2]=(a2+1)\r\n",
       "   _[5,3]=1\r\n",
       "   _[5,4]=(a)\r\n",
       "   _[6,1]=(a2+1)\r\n",
       "   _[6,2]=(a2+a+1)\r\n",
       "   _[6,3]=(a2+1)\r\n",
       "   _[6,4]=1\r\n",
       "[23]:\r\n",
       "   _[1,1]=(a2+a+1)\r\n",
       "   _[1,2]=(a+1)\r\n",
       "   _[1,3]=(a2+a+1)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=1\r\n",
       "   _[2,2]=(a2+a+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a2)\r\n",
       "   _[3,1]=(a2+a+1)\r\n",
       "   _[3,2]=(a+1)\r\n",
       "   _[3,3]=(a2+a+1)\r\n",
       "   _[3,4]=1\r\n",
       "   _[4,1]=(a2)\r\n",
       "   _[4,2]=1\r\n",
       "   _[4,3]=(a2)\r\n",
       "   _[4,4]=(a2+a)\r\n",
       "   _[5,1]=1\r\n",
       "   _[5,2]=(a2+a+1)\r\n",
       "   _[5,3]=1\r\n",
       "   _[5,4]=(a2)\r\n",
       "   _[6,1]=(a2+a+1)\r\n",
       "   _[6,2]=(a+1)\r\n",
       "   _[6,3]=(a2+a+1)\r\n",
       "   _[6,4]=1\r\n",
       "[24]:\r\n",
       "   _[1,1]=(a+1)\r\n",
       "   _[1,2]=(a2+1)\r\n",
       "   _[1,3]=(a+1)\r\n",
       "   _[1,4]=1\r\n",
       "   _[2,1]=1\r\n",
       "   _[2,2]=(a+1)\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=(a2+a)\r\n",
       "   _[3,1]=(a+1)\r\n",
       "   _[3,2]=(a2+1)\r\n",
       "   _[3,3]=(a+1)\r\n",
       "   _[3,4]=1\r\n",
       "   _[4,1]=(a2+a)\r\n",
       "   _[4,2]=1\r\n",
       "   _[4,3]=(a2+a)\r\n",
       "   _[4,4]=(a)\r\n",
       "   _[5,1]=1\r\n",
       "   _[5,2]=(a+1)\r\n",
       "   _[5,3]=1\r\n",
       "   _[5,4]=(a2+a)\r\n",
       "   _[6,1]=(a+1)\r\n",
       "   _[6,2]=(a2+1)\r\n",
       "   _[6,3]=(a+1)\r\n",
       "   _[6,4]=1\r\n",
       "[25]:\r\n",
       "   _[1,1]=0\r\n",
       "   _[1,2]=0\r\n",
       "   _[1,3]=1\r\n",
       "   _[1,4]=1\r\n",
       "   _[1,5]=1\r\n",
       "   _[1,6]=(a+1)\r\n",
       "   _[1,7]=(a2+1)\r\n",
       "   _[1,8]=(a2+a+1)\r\n",
       "   _[1,9]=(a+1)\r\n",
       "   _[1,10]=(a2+1)\r\n",
       "   _[1,11]=(a2+a+1)\r\n",
       "   _[1,12]=(a+1)\r\n",
       "   _[1,13]=(a2+1)\r\n",
       "   _[1,14]=(a2+a+1)\r\n",
       "   _[1,15]=(a)\r\n",
       "   _[1,16]=(a2)\r\n",
       "   _[1,17]=(a2+a)\r\n",
       "   _[1,18]=(a)\r\n",
       "   _[1,19]=(a2)\r\n",
       "   _[1,20]=(a2+a)\r\n",
       "   _[1,21]=(a)\r\n",
       "   _[1,22]=(a2)\r\n",
       "   _[1,23]=(a2+a)\r\n",
       "   _[2,1]=1\r\n",
       "   _[2,2]=1\r\n",
       "   _[2,3]=1\r\n",
       "   _[2,4]=1\r\n",
       "   _[2,5]=1\r\n",
       "   _[2,6]=1\r\n",
       "   _[2,7]=1\r\n",
       "   _[2,8]=1\r\n",
       "   _[2,9]=1\r\n",
       "   _[2,10]=1\r\n",
       "   _[2,11]=1\r\n",
       "   _[2,12]=1\r\n",
       "   _[2,13]=1\r\n",
       "   _[2,14]=1\r\n",
       "   _[2,15]=1\r\n",
       "   _[2,16]=1\r\n",
       "   _[2,17]=1\r\n",
       "   _[2,18]=1\r\n",
       "   _[2,19]=1\r\n",
       "   _[2,20]=1\r\n",
       "   _[2,21]=1\r\n",
       "   _[2,22]=1\r\n",
       "   _[2,23]=1\r\n",
       "   _[3,1]=0\r\n",
       "   _[3,2]=0\r\n",
       "   _[3,3]=(a)\r\n",
       "   _[3,4]=(a2)\r\n",
       "   _[3,5]=(a2+a)\r\n",
       "   _[3,6]=(a2+1)\r\n",
       "   _[3,7]=(a2+a+1)\r\n",
       "   _[3,8]=(a+1)\r\n",
       "   _[3,9]=(a2)\r\n",
       "   _[3,10]=(a2+a)\r\n",
       "   _[3,11]=(a)\r\n",
       "   _[3,12]=1\r\n",
       "   _[3,13]=1\r\n",
       "   _[3,14]=1\r\n",
       "   _[3,15]=(a2+a+1)\r\n",
       "   _[3,16]=(a+1)\r\n",
       "   _[3,17]=(a2+1)\r\n",
       "   _[3,18]=(a2+1)\r\n",
       "   _[3,19]=(a2+a+1)\r\n",
       "   _[3,20]=(a+1)\r\n",
       "   _[3,21]=(a)\r\n",
       "   _[3,22]=(a2)\r\n",
       "   _[3,23]=(a2+a)\r\n",
       "   _[4,1]=0\r\n",
       "   _[4,2]=0\r\n",
       "   _[4,3]=1\r\n",
       "   _[4,4]=1\r\n",
       "   _[4,5]=1\r\n",
       "   _[4,6]=(a2+1)\r\n",
       "   _[4,7]=(a2+a+1)\r\n",
       "   _[4,8]=(a+1)\r\n",
       "   _[4,9]=(a2+1)\r\n",
       "   _[4,10]=(a2+a+1)\r\n",
       "   _[4,11]=(a+1)\r\n",
       "   _[4,12]=(a2+1)\r\n",
       "   _[4,13]=(a2+a+1)\r\n",
       "   _[4,14]=(a+1)\r\n",
       "   _[4,15]=(a2)\r\n",
       "   _[4,16]=(a2+a)\r\n",
       "   _[4,17]=(a)\r\n",
       "   _[4,18]=(a2)\r\n",
       "   _[4,19]=(a2+a)\r\n",
       "   _[4,20]=(a)\r\n",
       "   _[4,21]=(a2)\r\n",
       "   _[4,22]=(a2+a)\r\n",
       "   _[4,23]=(a)\r\n",
       "[26]:\r\n",
       "   3,10\r\n"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intvec F=6,0,0;\n",
    "list K=prepSV(G,D,F,KLEIN);\n",
    "K;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "estimated correction capacity "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3\r\n"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K[size(K)][1];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coding information of dimension 11 into a codeword of length 23 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,1,1,1,1,1,1,1,1,1,1\r\n"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix word[1][11];\n",
    "word = 1,1,1,1,1,1,1,1,1,1,1;\n",
    "print(word);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0,0,0,0,0,(a2),(a2+a),(a),(a),(a2),(a2+a),1,1,1,1,1,1,1,1,1,1,1,1\r\n"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def c=word*CO;\n",
    "print(c);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "error correction: we add 3 errors "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,0,0,0,0,0,0,0,0,(a),0,(a+1),0,0,0,0,0,0,0,0,0,0,0\r\n"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix e[1][23];\n",
    "e[1,1]=1;\n",
    "e[1,10]=a;\n",
    "e[1,12]=1+a;\n",
    "print(e);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we receive y instead of c "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,0,0,0,0,(a2),(a2+a),(a),(a),(a2+a),(a2+a),(a),1,1,1,1,1,1,1,1,1,1,1\r\n"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def y=c+e;\n",
    "print(y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "decode "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0,0,0,0,0,(a2),(a2+a),(a),(a),(a2),(a2+a),1,1,1,1,1,1,1,1,1,1,1,1\r\n"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def x=decodeSV(y,K);\n",
    "print(x);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check the emitted codeword "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x==c;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "obtain the error vector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1,0,0,0,0,0,0,0,0,(a),0,(a+1),0,0,0,0,0,0,0,0,0,0,0\r\n"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(x-y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "can we correct 4 errors? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1,2]=y[1,2]+1;\n",
    "def x=decodeSV(y,K);\n",
    "x==c;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and 5 errors? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1\r\n"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1,3]=0;\n",
    "def x=decodeSV(y,K);\n",
    "x==c;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "with 6 errors we fail! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "? no error-locator found ?\r\n",
       "? too many errors occur, 0-matrix returned ?\r\n",
       "_[1,1]=0\r\n"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1,4]=y[1,4]+1;\n",
    "decodeSV(y,K);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Final example: Weierstrass semigroup of the Suzuki curve "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]:\r\n",
       "   [1]:\r\n",
       "      0\r\n",
       "   [2]:\r\n",
       "      8\r\n",
       "   [3]:\r\n",
       "      10\r\n",
       "   [4]:\r\n",
       "      12\r\n",
       "   [5]:\r\n",
       "      13\r\n",
       "   [6]:\r\n",
       "      16\r\n",
       "   [7]:\r\n",
       "      18\r\n",
       "   [8]:\r\n",
       "      20\r\n",
       "   [9]:\r\n",
       "      21\r\n",
       "   [10]:\r\n",
       "      22\r\n",
       "   [11]:\r\n",
       "      23\r\n",
       "   [12]:\r\n",
       "      24\r\n",
       "   [13]:\r\n",
       "      25\r\n",
       "   [14]:\r\n",
       "      26\r\n",
       "   [15]:\r\n",
       "      28\r\n",
       "[2]:\r\n",
       "   [1]:\r\n",
       "      _[1]=1\r\n",
       "      _[2]=1\r\n",
       "   [2]:\r\n",
       "      _[1]=x\r\n",
       "      _[2]=z\r\n",
       "   [3]:\r\n",
       "      _[1]=y\r\n",
       "      _[2]=z\r\n",
       "   [4]:\r\n",
       "      _[1]=x5+y4z\r\n",
       "      _[2]=z5\r\n",
       "   [5]:\r\n",
       "      _[1]=x6+xy4z+y2z4\r\n",
       "      _[2]=z6\r\n",
       "   [6]:\r\n",
       "      _[1]=x2\r\n",
       "      _[2]=z2\r\n",
       "   [7]:\r\n",
       "      _[1]=xy\r\n",
       "      _[2]=z2\r\n",
       "   [8]:\r\n",
       "      _[1]=y2\r\n",
       "      _[2]=z2\r\n",
       "   [9]:\r\n",
       "      _[1]=x7+x2y4z+xy2z4\r\n",
       "      _[2]=z7\r\n",
       "   [10]:\r\n",
       "      _[1]=x5y+y5z\r\n",
       "      _[2]=z6\r\n",
       "   [11]:\r\n",
       "      _[1]=x6y+xy5z+y3z4\r\n",
       "      _[2]=z7\r\n",
       "   [12]:\r\n",
       "      _[1]=x3\r\n",
       "      _[2]=z3\r\n",
       "   [13]:\r\n",
       "      _[1]=x5y2+x4z3+y6z\r\n",
       "      _[2]=z7\r\n",
       "   [14]:\r\n",
       "      _[1]=x2y\r\n",
       "      _[2]=z3\r\n",
       "   [15]:\r\n",
       "      _[1]=xy2\r\n",
       "      _[2]=z3\r\n"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setring s;\n",
    "list SUZUKI=Adj_div(x10+x3+y8+y);\n",
    "def RR=SUZUKI[1][2];\n",
    "setring RR;\n",
    "list WSS = Weierstrass(1,28,SUZUKI);\n",
    "WSS;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Singular",
   "language": "singular",
   "name": "singular"
  },
  "language_info": {
   "codemirror_mode": "singular",
   "file_extension": ".singular",
   "mimetype": "text/x-singular",
   "name": "Singular"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}