tutorials/sage_knotinfo_interface_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SageMath interface to the KnotInfo and LinkInfo databases\n",
    "\n",
    "\n",
    "## Introduction\n",
    "\n",
    "### Instructions for use\n",
    "\n",
    "This tutorial comes as a [Jupyter notebook](https://en.wikipedia.org/wiki/Project_Jupyter) \n",
    "([ipynb](https://github.com/soehms/database_knotinfo/blob/main/tutorials/sage_knotinfo_interface_tutorial.ipynb)) that may have been exported to a [pdf](https://github.com/soehms/database_knotinfo/blob/main/tutorials/sage_knotinfo_interface_tutorial.pdf), [html](https://github.com/soehms/database_knotinfo/blob/main/tutorials/sage_knotinfo_interface_tutorial.html), [md](https://github.com/soehms/database_knotinfo/blob/main/tutorials/sage_knotinfo_interface_tutorial.md) or a [sage](https://github.com/soehms/database_knotinfo/blob/main/tutorials/sage_knotinfo_interface_tutorial.sage)-file. The purpose of the `html`, `md` and `pdf` formats is for reading only. But, if you're using it in a [Jupyter client](https://docs.jupyter.org/en/latest/start/index.html) (i.e. the `ipynb`-version) you may experiment with the examples by running the appropriate cells.\n",
    "\n",
    "#### Working with the Jupyter notebook\n",
    "\n",
    "##### Using your local device\n",
    "\n",
    "If you have a [SageMath](https://en.wikipedia.org/wiki/SageMath) distribution with a version of at least 9.4 then you can also run the cells of this tutorial on your own computer. To do this, enter\n",
    "\n",
    "```\n",
    "sage -n\n",
    "```\n",
    "\n",
    "in a bash shell located in a directory where you downloaded the `sage_knotinfo_interface_tutorial.ipynb` file (or rather the entire contents of the folder containing this file, so that local links work). This will open a new tab in your default browser showing the contents of that directory. Clicking on the tutorial file there will open another tab showing the file in a Jupyter client.\n",
    "\n",
    "Note, that some of the examples require optional packages (as explained in the context of the examples). These examples will fail unless you install the corresponding package.\n",
    "\n",
    "If you don't have a running Sage version of 9.4 (or newer) on your computer and are considering installing it, please see the [installation instructions](https://doc.sagemath.org/html/en/installation/index.html).\n",
    "\n",
    "#####  Using Notebook Player\n",
    "\n",
    "You can run all cells that don't rely on optional packages in the [Notebook Player](https://dahn-research.eu/nbplayer/). To do this first download the `ipynb`  file. Then use the *Browse*-Button of the *Notebook Player* to select the file from your local device.\n",
    "\n",
    "##### Using Docker\n",
    "\n",
    "If you don't want to install Sage on your machine but have [Docker](https://en.wikipedia.org/wiki/Docker_(software)) on it, you can run all cells of this notebook (including those depending on optional packages) after entering\n",
    "\n",
    "```\n",
    "docker run -p8888:8888 -w /home/sage/tutorials soehms/sagemath_knots:latest sage-jupyter\n",
    "```\n",
    "\n",
    "and following the instructions shown in the shell to open it in your browser. For more information see the [Docker repository](https://hub.docker.com/r/soehms/sagemath_knots).\n",
    "\n",
    "\n",
    "##### Using Gitpod\n",
    "\n",
    "Open [this pinned and shared](https://sagemath-sage-vvjhs5sv7yz.ws-eu77.gitpod.io/) [Gitpod workspace](https://gitpod.io/) in your browser (this may take some minutes). Then click on the *Open File* menu and select `/workspace/sage/tutorials/sage_knotinfo_interface_tutorial.ipynb`. After the notebook has opened select the *SageMath* kernel in the right top corner of the sheet (see the screenshots on [this page](https://soehms.github.io/gitpod_workspaces.html)). As for the Docker image you may run all cells of the notebook, here.\n",
    "\n",
    "You're welcome to make your own experiments there. However, be aware that you share this workspace with others. Thus, please make a copy of the original file for this (for example by saving it under a different name).\n",
    "\n",
    "\n",
    "#### Working in the command-line\n",
    "\n",
    "\n",
    "##### Using your local device\n",
    "\n",
    "You can also copy-paste the contents of the cells into a [Sage command line](https://doc.sagemath.org/html/en/reference/repl/index.html) session if the Sage version is at least 9.4. If you just want to use the tutorial examples for your own experiments then you can import its variables by loading the corresponding `sage` file, that is\n",
    "\n",
    "```\n",
    "sage: load('https://raw.githubusercontent.com/soehms/database_knotinfo/main/tutorials/sage_knotinfo_interface_tutorial.sage')\n",
    "```\n",
    "\n",
    "If this fails with a `FeatureNotPresentError` error install the missing optional packages or use the reduced version of the file:\n",
    "\n",
    "```\n",
    "sage: load('https://raw.githubusercontent.com/soehms/database_knotinfo/main/tutorials/sage_knotinfo_interface_tutorial_reduced.sage')\n",
    "```\n",
    "\n",
    "\n",
    "##### Using SageMathCell\n",
    "\n",
    "If you don't want to install Sage on your machine you can also run most of the examples in the [SageMathCell](https://sagecell.sagemath.org/). To pre-define the variables of this tutorial evaluate first\n",
    "\n",
    "```\n",
    "load('https://raw.githubusercontent.com/soehms/database_knotinfo/main/tutorials/sage_knotinfo_interface_tutorial_reduced.sage')\n",
    "```\n",
    "\n",
    "\n",
    "##### Using Docker\n",
    "\n",
    "You can also use the above Docker image to run all examples in a Sage command line by typing\n",
    "\n",
    "```\n",
    "docker run -it soehms/sagemath_knots:latest\n",
    "```\n",
    "\n",
    "To have the variable declarations of the tutorial available load the `sage_interface_knotinfo_tutorial.sage` file as described above. For more information see the [Docker repository](https://hub.docker.com/r/soehms/sagemath_knots).\n",
    "\n",
    "\n",
    "##### Using Gitpod\n",
    "\n",
    "The command line version can also be used in the terminal of the [Gitpod workspace](https://gitpod.io/start/#sagemath-sage-vvjhs5sv7yz). This is similar as for the Docker case.\n",
    "\n",
    "\n",
    "\n",
    "### About\n",
    "\n",
    "This tutorial is about a [class](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html) from the [SageMath](http://www.sagemath.org/) library which is available since [release 9.4](https://wiki.sagemath.org/ReleaseTours/sage-9.4). It implements an [interface to the databases](https://doc.sagemath.org/html/en/reference/databases/sage/databases/knotinfo_db.html) provided at the web-pages [KnotInfo](https://knotinfo.math.indiana.edu/) and [LinkInfo](https://linkinfo.sitehost.iu.edu/) which contain a classification of [mathematically knots and links](https://en.wikipedia.org/wiki/Knot_(mathematics)).\n",
    "\n",
    "The tutorial follows a [talk](https://github.com/soehms/database_knotinfo/blob/main/tutorials/introduction_knotinfo.md) held at the LKS-Seminar, University of Regensburg, on 2021/03/18\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Knots, links and braids in SageMath\n",
    "\n",
    "[Reference manual](https://doc.sagemath.org/html/en/reference/knots/index.html)\n",
    "[as pdf](https://doc.sagemath.org/pdf/en/reference/knots/knots.pdf)\n",
    "\n",
    "Sage has a mostly native [implementation of knots](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knot.html) and [links](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html) but also uses some third party software for this as [libbraiding](https://github.com/miguelmarco/libbraiding) and [libhomfly](https://github.com/miguelmarco/libhomfly) for the [braid group class](https://doc.sagemath.org/html/en/reference/groups/sage/groups/braid.html). Furthermore, many other interfaces are used indirectly, for example [Gap](http://www.gap-system.org) (for the braid group, as well) but also interfaces for graph theory, polynomial rings or plotting.\n",
    "\n",
    "\n",
    "### Links\n",
    "\n",
    "#### [Construction](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link)\n",
    "\n",
    "Links can be constructed using  [pd_code](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.pd_code):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "Graphics object consisting of 14 graphics primitives"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L3 = Link([[1, 5, 2, 4], [5, 3, 6, 2], [3, 1, 4, 6]])\n",
    "L3.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### using [braid_notation](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.braid):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "Graphics object consisting of 30 graphics primitives"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = BraidGroup(4)\n",
    "b = B([-1, -1, -1, -2, 1, -2, 3, -2])\n",
    "Lb = Link(b)\n",
    "Lb.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Links can also be constructed from [oriented Gauss code](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.oriented_gauss_code).\n",
    "\n",
    "### Knots\n",
    "\n",
    "#### [Construction](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knot.html#sage.knots.knot.Knot)\n",
    "\n",
    "Construction methods for links work for knots, too. For example using the `pd_code`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K3 = Knot([[1, 5, 2, 4], [5, 3, 6, 2], [3, 1, 4, 6]])\n",
    "K3 == L3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As element of a different [parent](https://doc.sagemath.org/html/en/reference/structure/sage/structure/parent.html?highlight=parent#sage.structure.parent.Parent) it differs from the corresponding link, even though they are [isotopic](https://en.wikipedia.org/wiki/Homotopy#Isotopy):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sage: L3.is_isotopic(K3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Knots, <class 'sage.knots.link.Link'>)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K3.parent(), L3.parent()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some special things only apply to knots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       " ╭─╮ \n",
       " │╭│╮\n",
       "╭─│╯│\n",
       "│╰╯ │\n",
       "╰───╯"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unicode_art(K3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Link with 1 component represented by 3 crossings"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unicode_art(L3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition to the construction methods for links, knots can be obtained using [classical Gauss code](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.gauss_code) or the [Dowker-Thistlethwaite code](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knot.html#sage.knots.knot.Knots.from_dowker_code).\n",
    "\n",
    "#### If the input represents a proper link\n",
    "\n",
    "In this case a [ValueError](https://docs.python.org/3/library/exceptions.html#ValueError) is raised:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong input: the input has more than 1 connected component\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Knot(b)\n",
    "except ValueError as err:\n",
    "    print('Wrong input:', err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Further examples\n",
    "\n",
    "#### Obtaining polynomial invariants\n",
    "\n",
    "* [HOMFLY-PT polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.homfly_polynomial)\n",
    "* [Jones polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.jones_polynomial)\n",
    "* [colored Jones polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knot.html#sage.knots.knot.Knot.colored_jones_polynomial)\n",
    "* [Alexander polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.alexander_polynomial)\n",
    "* [Conway polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.conway_polynomial)\n",
    "* [Links-Gould polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.links_gould_polynomial)\n",
    "* [Khovanov polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.khovanov_polynomial)\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-L^4 + L^2*M^2 - 2*L^2"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = L3.homfly_polynomial(); h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Multivariate Laurent Polynomial Ring in L, M over Integer Ring"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair'>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h == K3.homfly_polynomial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(M, L)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.variables()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Other invariants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1 - t1^-1 - t0^-1 + t1^-2 + 2*t0^-1*t1^-1 + t0^-2 - t0^-1*t1^-2 - t0^-2*t1^-1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L3.links_gould_polynomial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^-1 + q^-3 + q^-5*t^-2 + q^-9*t^-3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L3.khovanov_polynomial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q^-1 + q^-3 + q^-5*t^-2 + q^-7*t^-2 + q^-9*t^-3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L3.khovanov_polynomial(base_ring=GF(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{-9: {-3: Z},\n",
       " -7: {-3: 0, -2: C2},\n",
       " -5: {-3: 0, -2: Z, -1: 0, 0: 0},\n",
       " -3: {-3: 0, -2: 0, -1: 0, 0: Z},\n",
       " -1: {0: Z}}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L3.khovanov_homology()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using [braid](https://doc.sagemath.org/html/en/reference/groups/sage/groups/braid.html#sage.groups.braid.Braid) and [braid group](https://doc.sagemath.org/html/en/reference/groups/sage/groups/braid.html#sage.groups.braid.BraidGroup) functionality:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "s^-3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "br = L3.braid(); br"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[           -t^-2 + t^-1         t^-2 - t^-1 + 1]\n",
       "[     t^-3 - t^-2 + t^-1 -t^-3 + t^-2 - t^-1 + 1]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brm = br.burau_matrix(); brm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Full MatrixSpace of 2 by 2 dense matrices over Univariate Laurent Polynomial Ring in t over Integer Ring"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brm.parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Braid group on 2 strands"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = br.parent(); B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Group endomorphism of Braid group on 2 strands"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mirr = B.mirror_involution(); mirr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mirr(br) == br.mirror_image()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to access knots and links in Sage by name?\n",
    "\n",
    "Internally there is just a small list of Knots from the [Rolfsen Table](https://en.wikipedia.org/wiki/List_of_prime_knots):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K10_165 = Knots().from_table(10, 165)\n",
    "K10_165m = K10_165.mirror_image()\n",
    "K10_165.is_isotopic(K10_165m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More links can be defined by name if the optional package [SnapPy](https://snappy.math.uic.edu/index.html) is installed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Plink failed to import tkinter.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import snappy\n",
    "K10_166 = snappy.Link('10_166').sage_link()\n",
    "K10_166.is_isotopic(K10_165)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Access to the KnotInfo and LinkInfo databases\n",
    "\n",
    "This is possible since [release 9.4](https://wiki.sagemath.org/ReleaseTours/sage-9.4).\n",
    "\n",
    "Lets have a look at some of the examples:\n",
    "\n",
    "### Declaration using list selection (tab-completion)\n",
    "\n",
    "The easiest way to define an interface instance for a special link or knot is to select it as an item of the [KnotInfo class](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoBase). This can be done by [tab-completion](https://en.wikipedia.org/wiki/Command-line_completion). For example if you type `KnotInfo.L6a4` and than hit the [Tab-key](https://en.wikipedia.org/wiki/Tab_key) you can select a link whose name starts with `L6a4` from a list.\n",
    "\n",
    "<p><img src=\"pictures/tab_completion_link.png\" title=\"tab-completion link\" /></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<KnotInfo.L6a4_0_0: 'L6a4{0,0}'>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6 = KnotInfo.L6a4_0_0; L6"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The properties of the link can be obtained by the methods of the interface instance. Available methods can be viewed by tab-completion, too:\n",
    "\n",
    "<p><img src=\"pictures/tab_completion_meth.png\" title=\"tab-completion method\" /></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6, 1, 7, 2],\n",
       " [12, 8, 9, 7],\n",
       " [4, 12, 1, 11],\n",
       " [10, 5, 11, 6],\n",
       " [8, 4, 5, 3],\n",
       " [2, 9, 3, 10]]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6pd = L6.pd_notation(); L6pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default behavior of the methods of the `KnotInfo` class is to convert the string from the original table to a Sage or Python object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'list'>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L6pd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain the original string from the table you have to use the keyword `original`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{{6, 1, 7, 2}, {12, 8, 9, 7}, {4, 12, 1, 11}, {10, 5, 11, 6}, {8, 4, 5, 3}, {2, 9, 3, 10}}'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6pdo = L6.pd_notation(original=True); L6pdo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'str'>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(L6pdo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6.is_knot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6.num_components()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Knots need a prefix `K`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K4 = KnotInfo.K4_1\n",
    "K4.is_amphicheiral()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Declaring a link directly by its internal name\n",
    "\n",
    "Using the [inject method](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoBase.inject) you may easily declare the interface instance by its name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining K5_1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[6, 8, 10, 2, 4]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KnotInfo.K5_1.inject()\n",
    "K5_1.dt_notation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtaining a link by its original name\n",
    "\n",
    "This is possible by using the string of the original name as an argument of the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining L6a1_1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KnotInfo('L6a1{1}').inject()\n",
    "L6a1_1.is_alternating()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obtaining Sage (and SnapPy) instances "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(s0*s1^-1)^3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6br = L6.braid(); L6br"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Braid group on 3 strands"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6br.parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Link with 3 components represented by 6 crossings"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l6 = L6.link(); l6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "t^-2 - 4*t^-1 + 6 - 4*t + t^2"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l6.alexander_polynomial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Link: 3 comp; 6 cross>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l6s = L6.link(snappy=True); l6s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion methods\n",
    "\n",
    "KnotInfo and LinkInfo list more than 120 properties (in sum). Not all of them have already conversion methods to Sage. At the moment this holds for about a quarter of them including all polynomial invariants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-v^2*z^2 + z^4 + 2*z^2 + v^2*z^-2 - v^-2*z^2 - 2*z^-2 + v^-2*z^-2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h6 = L6.homfly_polynomial(); h6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Multivariate Laurent Polynomial Ring in v, z over Integer Ring"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h6.parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h6 == L6.link().homfly_polynomial(normalization='vz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Everyone is invited to extend the amount of conversions!** But anyway, as a string all properties can be obtained, right now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'6'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K4[K4.items.arc_index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Launching web pages\n",
    "\n",
    "The following examples will launch the corresponding web-pages in your default browser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6.diagram()\n",
    "L6.knot_atlas_webpage()\n",
    "L6.items.jones_polynomial.description_webpage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example launches the web-pages of all diagrams of knots with less than 9 crossings and [three genus](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoBase.three_genus) equal to three: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listg3 = [K for K in KnotInfo if K.is_knot() and K.crossing_number() < 9 and K.three_genus() == 3]\n",
    "len(listg3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all(K.diagram() for K in listg3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now declare all of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining K7_1\n",
      "Defining K8_2\n",
      "Defining K8_5\n",
      "Defining K8_7\n",
      "Defining K8_9\n",
      "Defining K8_10\n",
      "Defining K8_16\n",
      "Defining K8_17\n",
      "Defining K8_18\n",
      "Defining K8_19\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any(K.inject() for K in listg3)\n",
    "K7_1.is_alternating() == K8_10.is_alternating()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### From Sage to KnotInfo\n",
    "\n",
    "If you want to identify a link defined in Sage with an isotopic link from the KnotInfo or LinkInfo databases you can use the [get_knotinfo method](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.get_knotinfo):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<KnotInfo.K0_1: '0_1'>, None)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = Link([[3,1,2,4], [8,9,1,7], [5,6,7,3], [4,18,6,5],\n",
    "          [17,19,8,18], [9,10,11,14], [10,12,13,11],\n",
    "          [12,19,15,13], [20,16,14,15], [16,20,17,2]])\n",
    "L.get_knotinfo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<KnotInfo.K10_165: '10_165'>, True)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K10_165.get_knotinfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### KnotInfoSeries\n",
    "\n",
    "To each interface instance there is a series of knots or links where the instance belongs to. Use the [series method](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoBase.series) to declare it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining L6a\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Series of links L6a1,\n",
       " Series of links L6a2,\n",
       " Series of links L6a3,\n",
       " Series of links L6a4,\n",
       " Series of links L6a5]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L6.series().inject()\n",
    "list(L6a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining L6a1\n"
     ]
    }
   ],
   "source": [
    "L6a[0].inject()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<KnotInfo.L6a1_0: 'L6a1{0}'>, <KnotInfo.L6a1_1: 'L6a1{1}'>]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(L6a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to define a series is to use the constructor of the corresponding [class](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoSeries) directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining K10\n",
      "<Link 10_160: 1 comp; 10 cross> ---> (<KnotInfo.K10_160: '10_160'>, False)\n",
      "<Link 10_161: 1 comp; 10 cross> ---> (<KnotInfo.K10_161: '10_161'>, True)\n",
      "<Link 10_162: 1 comp; 10 cross> ---> (<KnotInfo.K10_161: '10_161'>, False)\n",
      "<Link 10_163: 1 comp; 10 cross> ---> (<KnotInfo.K10_162: '10_162'>, False)\n",
      "<Link 10_164: 1 comp; 10 cross> ---> (<KnotInfo.K10_163: '10_163'>, False)\n",
      "<Link 10_165: 1 comp; 10 cross> ---> (<KnotInfo.K10_164: '10_164'>, False)\n"
     ]
    }
   ],
   "source": [
    "KnotInfoSeries(10, True, True).inject()\n",
    "for i in range(160, 166):\n",
    "    K = K10(i)\n",
    "    k = K.link(K.items.name, snappy=True)\n",
    "    print(k, '--->', k.sage_link().get_knotinfo())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note the differences to the naming of SnapPy concerning the [Perko-Pair](https://en.wikipedia.org/wiki/Perko_pair)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<KnotInfo.K10_165: '10_165'>, True)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import snappy\n",
    "snappy.Link('10_166').sage_link().get_knotinfo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What does `# optional - snappy`  and `# optional - database_knotinfo` mean in the examples of the reference manual?\n",
    "\n",
    "This is needed in the development proccess. After each commit which is pushed to the repository all examples are automatically tested by *patchbots*. The examples marked as *optional* prevent the patchbot to do that if the corresponding package is not installed.\n",
    "\n",
    "Conversely this means that all examples which are not marked like this will be tested permanently on further development of Sage. They are perfomed on a subset of 20 links and about 20 properties hold statically in the Sage library for demonstration purpose. This prevents the interface to run out of compatibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How can you use KnotInfo in Sage?\n",
    "\n",
    "The demonstration cases are shipped with the binaries of Sage since release 9.4. The complete Database can be installed typing\n",
    "\n",
    "```\n",
    "sage -i database_knotinfo\n",
    "```\n",
    "\n",
    "in a comand line. If you don't have Sage of a release 9.4 or newer please see the hints in the introduction section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.8.beta6",
   "language": "sage",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}