tutorials/cubic_hecke_algebra_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "# Using  the SageMath CubicHeckeAlgebra class\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_cubic_hecke/blob/main/tutorials/cubic_hecke_algebra_tutorial.ipynb)) that may have been exported to a [pdf](https://github.com/soehms/database_cubic_hecke/blob/main/tutorials/cubic_hecke_algebra_tutorial.pdf), [html](https://github.com/soehms/database_cubic_hecke/blob/main/tutorials/cubic_hecke_algebra_tutorial.html), [md](https://github.com/soehms/database_cubic_hecke/blob/main/tutorials/cubic_hecke_algebra_tutorial.md) or a [sage](https://github.com/soehms/database_cubic_hecke/blob/main/tutorials/cubic_hecke_algebra_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.7 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 `cubic_hecke_algebra_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.7 (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/cubic_hecke_algebra_tutorial.ipynb`. After the notebook has opened select the *SageMath* kernel in the right top corner of the sheet. 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.7. 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_cubic_hecke/main/tutorials/cubic_hecke_algebra_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_cubic_hecke/main/tutorials/cubic_hecke_algebra_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_cubic_hecke/main/tutorials/cubic_hecke_algebra_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 `cubic_hecke_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/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html) from the [SageMath](http://www.sagemath.org/) library which is available since [release 9.7](https://wiki.sagemath.org/ReleaseTours/sage-9.7). It allows to do calculations in [cubic Hecke algebras](https://arxiv.org/abs/1110.6621), which are certain [epimorphic images](https://en.wikipedia.org/wiki/Epimorphism) of [group algebras](https://en.wikipedia.org/wiki/Group_ring) of [Artin braid groups](https://en.wikipedia.org/wiki/Braid_group).\n",
    "\n",
    "More explicitly, we consider the factors such that the images $s_i$ of the braid generators satisfy a cubic equation:\n",
    "\n",
    "$$ s_i^3 = u s_i^2 - v s_i + w $$\n",
    "\n",
    "Here $u, v, w$ are elements in an arbitrary [integral domain](https://en.wikipedia.org/wiki/Integral_domain). By the analogue to the [Iwahori Hecke algebras](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/iwahori_hecke_algebra.html), in which the braid generators satisfy a quadratic relation these algebras have been called *cubic Hecke algebras*.\n",
    "\n",
    "The relations inherited from the braid group are:\n",
    "\n",
    "$$s_i s_{i+1} s_i = s_{i+1} s_i s_{i+1} \\text{ for } 1 \\leq i < n - 1\n",
    "    \\mbox{ and } s_i s_j = s_j s_i \\text{ for } 1 \\leq i < j - 1 < n - 1.$$\n",
    "\n",
    "\n",
    "The algebra epimorphism from the [braid group algebra](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html#sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeAlgebra.braid_group_algebra) over the same base ring is realized inside the [element constructor](https://doc.sagemath.org/html/en/reference/structure/sage/structure/parent.html?highlight=element%20constructor#sage.structure.parent.Parent.__call__) of the present class which is executed when in instance of the class is applied to appropriate data. For example in the case of the 3 strand cubic Hecke algebra we obtain the braid group by the method [braid_group](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html#sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeAlgebra.braid_group) and define a braid with its help:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c0*c1*c0^-1*c1^2*c0^-1"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3 = algebras.CubicHecke(3)\n",
    "BG3 = CHA3.braid_group()\n",
    "braid = BG3((1,2,-1,2,2,-1)); braid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Its image in the cubic Hecke algebra is: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u*c1*c0^-1*c1 + u*v*c0*c1^-1*c0^-1 + (-u^2)*c0^-1*c1 + ((u^2*v-v^2)/w)*c0*c1*c0^-1 + ((u^2-v)/w)*c0*c1*c0 + ((-u^3+u*v)/w)*c0*c1 + (-u*v+w)*c1^-1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3(braid)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the ring elements $u, v, w$ (which will be called the [cubic equation parameters](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html#sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeAlgebra.cubic_equation_parameters) in the sequel) are taken to be $u = v = 0, w = 1$ the cubic Hecke algebra specializes to the group algebra of the [cubic braid group](https://doc.sagemath.org/html/en/reference/groups/sage/groups/cubic_braid.html?highlight=cubic%20braid%20group#cubic-braid-groups), which is the factor group of the Artin braid\n",
    "group under setting the generators order to be three. A class to work with these groups\n",
    "is attached to this class and can be obtained by the [cubic_braid_group](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html#sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeAlgebra.cubic_braid_group)-method. \n",
    "\n",
    "\n",
    "It is well known, that these algebras are free of finite rank as long as the number of braid generators is less than six and infinite dimensional else-wise. In the former (non trivial) cases they are also known as [cyclotomic Hecke algebras](https://www.researchgate.net/publication/1768251_On_the_cyclotomic_Hecke_algebras_of_complex_reflection_groups) corresponding to the [complex reflection groups](https://doc.sagemath.org/html/en/reference/categories/sage/categories/complex_reflection_groups.html?highlight=complex%20reflection%20groups#complex-reflection-groups)\n",
    "having Shepard-Todd number $4, 25$ and $32$ (see the table at [Wikipedia](https://en.wikipedia.org/wiki/Complex_reflection_group)).\n",
    "\n",
    "Since the [Broué, Malle and Rouquiere](https://arxiv.org/abs/1606.08456) conjecture has been proved in all these cases (for references see [Mar2012](https://arxiv.org/abs/1110.6621) below) there exists a finite free basis of the cubic Hecke algebra which is in bijection to the cubic braid group and compatible with the specialization to the cubic braid group algebra as explained above.\n",
    "\n",
    "For the algebras corresponding to braid groups of less than five strands such a basis has been calculated by Ivan Marin. This one is used here via a [Python wrapper](https://github.com/soehms/database_cubic_hecke#readme). In the case of 5 strands such a basis is not available, right now. Instead the elements of the cubic braid group class themselves are used as basis elements. This is also the case when the cubic braid group is infinite, even though it is not known if these elements span all of the cubic Hecke algebra.\n",
    "\n",
    "Accordingly, be aware that the realization of the coercion map from the group algebra of the cubic braid groups is known to be an isomorphism of free modules only in the cases of less than five strands. \n",
    "\n",
    "\n",
    "REFERENCES:\n",
    "\n",
    "- [CM2012](https://arxiv.org/abs/1010.1465) M. Cabanes, I. Marin, On ternary quotients of cubic Hecke algebras, Comm. Math. Phys. August 2012, Volume 314, Issue 1, pp 57-92, [doi](https://doi.org/10.1007/s00220-012-1519-7).\n",
    "- [Mar2012]( https://arxiv.org/abs/1110.6621) Ivan Marin: The cubic Hecke algebra on at most 5 strands. Journal of Pure and Applied Algebra 216 (2012) 2754-2782, [doi](https://doi.org/10.1016/j.jpaa.2012.04.013).\n",
    "- [Mar2018](http://www.lamfa.u-picardie.fr/marin/arts/GQ.pdf) Ivan Marin: Preprint A  MAXIMAL  CUBIC  QUOTIENT  OF  THE  BRAID  ALGEBRA."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First steps\n",
    "\n",
    "In the global namespace of Sage the cubic Hecke algebra is present as `algebras.CubicHecke`. Online help can be requested with a question mark right behind the last character: `algebras.CubicHecke?`. This also works for all instances of classes and methods that you may define in the sequel, for examples `CHA3?` after running the next cell gives the same information, but `CHA3.cubic_hecke_subalgebra?` displays the online-help for that specific method.\n",
    "\n",
    "To define the cubic Hecke algebra on 3 strands,type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 - u*h^2 + v*h - w = 0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3 = algebras.CubicHecke(3); CHA3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining c0, c1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "c0*c1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3.inject_variables(); c0*c1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you like to use your own names it is possible to include a generator declaration inside the algebra declaration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in a, b, c over Integer Ring localized at (c,) with cubic equation: h^3 - a*h^2 + b*h - c = 0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3abc.<c1, c2> = algebras.CubicHecke(3, cubic_equation_parameters='a, b, c', cubic_equation_roots='x, y, z'); CHA3abc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The underlying cubic equation of the algebra can be obtained by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h^3 - u*h^2 + v*h - w"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3.cubic_equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "h^3 - a*h^2 + b*h - c"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3abc.cubic_equation()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far, the only difference between these both definitions of a cubic Hecke algebra consists in the names of the parameters. The argument `cubic_equation_parameters` can also be used to define the algebra over a specialized ring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Fraction Field of Multivariate Polynomial Ring in p, q, r over Integer Ring with cubic equation: h^3 - p*h^2 + q*h - r = 0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BRQ.<p,q,r> = FractionField(ZZ['p,q,r'])\n",
    "CHA3pqr = algebras.CubicHecke(3, cubic_equation_parameters=(p, q, r)); CHA3pqr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The roots are constructed in a maximal extension ring if they don't belong to the domain of the `cubic_equation_parameters`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[a, b, -b - a + p]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - p*h^2 + q*h - r with roots [a, b, -b - a + p] over Fraction Field of Multivariate Polynomial Ring in p, q, r over Integer Ring"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots = CHA3pqr.cubic_equation_roots(); print(roots)\n",
    "roots[0].parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Cyclotomic Field of order 3 and degree 2 with cubic equation: h^3 - zeta3*h^2 + (-zeta3 - 1)*h - 1 = 0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z3 = CyclotomicField(3)\n",
    "e = Z3.gen()\n",
    "CHA3z3 = algebras.CubicHecke(3, cubic_equation_parameters=(e, e**2, 1)); CHA3z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[S^2 - 1, S, -S]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Number Field in S with defining polynomial h^4 - h^2 + 1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots = CHA3z3.cubic_equation_roots(); print(roots)\n",
    "roots[0].parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Integer Ring localized at (11,) with cubic equation: h^3 - 5*h^2 + 7*h - 11 = 0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3int = algebras.CubicHecke(3, cubic_equation_parameters=(5, 7, 11)); CHA3int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[a, b, -b - a + 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - 5*h^2 + 7*h - 11 with roots [a, b, -b - a + 5] over Integer Ring localized at (11,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots = CHA3int.cubic_equation_roots(); print(roots)\n",
    "roots[0].parent()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can define the roots of the cubic equation, as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Finite Field in t of size 5^2 with cubic equation: h^3 + (4*t + 1)*h^2 + (4*t + 3)*h + 2*t = 0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "GF25 = GF(25,'t')\n",
    "g2 = GF25(1)\n",
    "g3 = GF25.gen()\n",
    "g4 = GF25(3)\n",
    "CHA3gf25 = algebras.CubicHecke(3, cubic_equation_roots=(g2, g3, g4)); CHA3gf25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples of Elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element of CHA3 (-w)*c0*c1^-1 + v*c0 + u*c1 + ((-v*w+u)/w)\n",
      "Element of CHA3abc (-c)*c1*c2^-1 + b*c1 + a*c2 + ((-b*c+a)/c)\n",
      "Element of CHA3pqr (-r)*c0*c1^-1 + q*c0 + p*c1 + ((-q*r+p)/r)\n",
      "Element of CHA3z3 -c0*c1^-1 - (zeta3+1)*c0 - (-zeta3)*c1 + (2*zeta3+1)\n",
      "Element of CHA3int -11*c0*c1^-1 + 7*c0 + 5*c1 - 72/11\n",
      "Element of CHA3gf25 2*t*c0*c1^-1 + (4*t+3)*c0 + (t+4)*c1 + (2*t+3)\n"
     ]
    }
   ],
   "source": [
    "print('Element of CHA3 %s' %(CHA3.an_element()))\n",
    "print('Element of CHA3abc %s' %(CHA3abc.an_element()))\n",
    "print('Element of CHA3pqr %s' %(CHA3pqr.an_element()))\n",
    "print('Element of CHA3z3 %s' %(CHA3z3.an_element()))\n",
    "print('Element of CHA3int %s' %(CHA3int.an_element()))\n",
    "print('Element of CHA3gf25 %s' %(CHA3gf25.an_element()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplication is possible without any restriction in the cubic Hecke algebra up to four strands:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-w)*c0*c1^-1*c0 + u*c1*c0 + v*w*c0^-1 + ((u*v*w-v*w+u)/w)*c0 + (-v^2)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ele3 = CHA3.an_element()\n",
    "ele3*c0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix representations\n",
    "\n",
    "To each element you can obtain matrix representations of different types. By default this is a block-matrix, whose blocks are the  split irreducible representation which are available at [Ivan Marin's hompage](http://www.lamfa.u-picardie.fr/marin/softs/H4/RepresentationsH25):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v*c0 + ((-v*w+u)/w)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[              v*a + (-v*w + u)/w                                0                                0]\n",
       "[                               0               v*b + (-v*w + u)/w                                0]\n",
       "[                               0                                0 -v*b - v*a + (u*v*w - v*w + u)/w]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA2 = CHA3.cubic_hecke_subalgebra()\n",
    "ele2 = CHA2.an_element(); print(ele2)\n",
    "m = ele2.matrix(); m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the entries are taken from an extension of the base ring (indeterminates u, v, w) splitting the cubic equation with roots a, b, c. This ring is called the extension ring of `CHA3`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.base_ring() == CHA2.extension_ring()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The original version with entries being Laurent polynomials in $a, b, c$ can be obtained using the keyword option `original` or by changing the base ring to the *generic* extension ring:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo = ele2.matrix(original=True)\n",
    "mo == m.change_ring(CHA2.extension_ring(generic=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A single irreducible representation can be obtained by array index which can be an integer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[v*b + (-v*w + u)/w]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[a*b^2 + a*b*c + b^2*c - a*b - a*c - b*c + b^-1*c^-1 + a^-1*c^-1 + a^-1*b^-1]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or an enum naming the representation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[a^2*b + a^2*c + a*b*c - a*b - a*c - b*c + b^-1*c^-1 + a^-1*c^-1 + a^-1*b^-1]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mo[CHA2.irred_repr.W2_100]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other representation types are the left and right regular representations, which are taken from Ivan Marin's home page, as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[       (-v*w + u)/w                -v^2                   v]\n",
       "[                  v (u*v*w - v*w + u)/w                   0]\n",
       "[                  0                 v*w        (-v*w + u)/w]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ml = ele2.matrix(representation_type=CHA2.repr_type.RegularLeft); ml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and (in case [GAP3](https://webusers.imj-prg.fr/~jean.michel/gap3/) is installed together with its package `CHEVIE`) the split irreducibles available from there. In case of the two strand algebra they coincide with Marin's version: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mg = ele2.matrix(representation_type=CHA2.repr_type.SplitIrredChevie)\n",
    "m == m.parent()(mg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but not in general:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3 = algebras.CubicHecke(3)\n",
    "c1, c2 = CHA3.gens()\n",
    "m1 = c1.matrix()\n",
    "m1g = c1.matrix(representation_type=CHA3.repr_type.SplitIrredChevie)\n",
    "m1.dict() == m1g.dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, you may obtain irreducible matrix representations for cubic Hecke algebras on 5 strands by using `SplitIrredChevie` which is not possible for the other types (see the examples in the last section)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markov traces\n",
    "\n",
    "A Markov trace is a family of class functions $tr_n$ on the family of braid groups $B_n$ into some commutative ring $R$ depending on a unit $s \\in R$ such that for all $b \\in B_n$ the following two conditions are satisfied (see [Louis Kauffman: Knots and Physics](https://doc.sagemath.org/html/en/reference/references/index.html#kau1991), section 7):\n",
    "\n",
    "\n",
    "$$\\begin{array}{lll}\n",
    "    tr_{n+1}(b g_n)      &  = &  s\\, tr_n(b), \\\\\n",
    "    tr_{n+1}(b g^{-1}_n) &  = &  s^{-1} tr_n(b).\n",
    "    \\end{array}\n",
    "$$\n",
    "\n",
    "The unit $s$ is often called the writhe factor and corresponds to the additional variable mentioned above. Each Markov trace can be transformed into a polynomial Link invariant. Most of the Markov traces come from the well known Link invariants that factor through the cubic Hecke algebra. This covers Markov traces corresponding to the\n",
    "\n",
    "- [HOMFLY-PT polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html?highlight=homfly#sage.knots.link.Link.homfly_polynomial)\n",
    "- [Kauffman polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/knotinfo.html#sage.knots.knotinfo.KnotInfoBase.kauffman_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",
    "\n",
    "In addition this is also true for:\n",
    "\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",
    "- [Jones polynomial](https://doc.sagemath.org/html/en/reference/knots/sage/knots/link.html#sage.knots.link.Link.jones_polynomial)\n",
    "\n",
    "\n",
    "since these can be obtained from the HOMFLY-PT polynomial. Furthermore, the [Brandt-Lickorish-Millett-Ho polynomial(LMBH)](https://encyclopediaofmath.org/wiki/Brandt-Lickorish-Millett-Ho_polynomial) is such an invariant, too, as a specialization of the Kauffman polynomial. These connections are displayed in the following chart which can be found in [Louis Kauffman: Knots and Physics](https://doc.sagemath.org/html/en/reference/references/index.html#kau1991) on page 54:\n",
    "\n",
    "<p><img src=\"pictures/chart.jpg\" title=\"Chart\" /></p>\n",
    "\n",
    "If there exists something replacing the question mark in this picture there is a good chance that the corresponding Markov trace factors through the cubic Hecke algebra, as well.\n",
    "\n",
    "It's just a matter of linear algebra calculations to find all such traces on the cubic Hecke algebra on four strands which might have an extension to a Markov trace. The result of these calculations can be obtained using the method [formal_markov_trace](https://doc.sagemath.org/html/en/reference/algebras/sage/algebras/hecke_algebras/cubic_hecke_algebra.html#sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeElement.formal_markov_trace).\n",
    "\n",
    "This method returns elements of a sub-module of the module of linear forms on the cubic Hecke algebra the base ring of which is an extension of the generic base ring of it by an additional variable $s$ representing the writhe factor. All variables of this base ring extension are invertible.\n",
    "\n",
    "### Note\n",
    "\n",
    "> Currently it is not known if all linear forms of this sub-module belong to a Markov trace, i.e. can be extended to the full tower of cubic Hecke algebras. Anyway, at least the four basis elements ($U1$, $U2$, $U3$ and $K4$) can be reconstructed form the HOMFLY-PT and Kauffman polynomial.\n",
    "\n",
    "### Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((-u^2*s^2+s^4-u*w)/(w*s^2))*B[U1] + u*v/(w*s)*B[U2] + v/w*B[K4]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sage.knots.knotinfo import KnotInfo\n",
    "L5a1_0 = KnotInfo.L5a1_0\n",
    "L5a1_0b = L5a1_0.braid()\n",
    "L5a1_0c = CHA3(L5a1_0b)\n",
    "L5a1_0m = L5a1_0c.formal_markov_trace(); L5a1_0m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This expression is an element of a module of rank 4 over the generic base ring of `CHA3` adjoined with the element `s`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Free module generated by {U1, U2, U3, K4} over Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = L5a1_0m.parent(); M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The basis is indexed by elements of an [enum class](https://docs.python.org/3/library/enum.html) which represent certain links:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('U1', 'one unlink', 1),\n",
       " ('U2', 'two unlinks', -L*M^-1 - L^-1*M^-1),\n",
       " ('U3', 'three unlinks', L^2*M^-2 + 2*M^-2 + L^-2*M^-2),\n",
       " ('K4', 'knot 4_1', -L^2 + M^2 - 1 - L^-2)]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basis_index = M.basis().keys()\n",
    "[(i.name, i.description(), i.regular_homfly_polynomial()) for i in basis_index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example the trace function corresponding to the basis element indexed by `K4` is a linear form vanishing on all braids on three strands whose closure is a union of between one and three unlinks but evaluate to `1` on braids whose closure is the figure eight knot. \n",
    "\n",
    "For all these basis indices you may obtain the corresponding two variate polynomial invariant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['links_gould_polynomial', 'regular_homfly_polynomial', 'regular_kauffman_polynomial']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2*t0*t1 - 3*t0 - 3*t1 + t0*t1^-1 + 7 + t0^-1*t1 - 3*t1^-1 - 3*t0^-1 + 2*t0^-1*t1^-1"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K4 = basis_index[3]\n",
    "print([meth for meth in dir(K4) if meth.endswith('polynomial')])\n",
    "K4.links_gould_polynomial()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's verify the specialization for `L5a1_0`. First we need to perform a transition from invariance with respect to [regular isotopy](https://en.wikipedia.org/wiki/Regular_isotopy) to [ambient isotopy](https://en.wikipedia.org/wiki/Ambient_isotopy). This is done by multiplying by $s^{-\\omega}$ where $\\omega$ is the writhe of the link. In our case $\\omega = -1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "((-u^2*s^2+s^4-u*w)/(w*s))*B[U1] + u*v/w*B[U2] + v*s/w*B[K4]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SupportView({U2: u*v/w, U1: (-u^2*s^2 + s^4 - u*w)/(w*s), K4: v*s/w})"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MB = L5a1_0m.base_ring(); print(MB)\n",
    "s = MB.gen(3)\n",
    "L5 = L5a1_0m*s; print(L5)\n",
    "sup = L5.support(); sup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need epimorphisms from the base ring of our module to the rings of the well known invariants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H: Composite map:\n",
      "  From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "  To:   Multivariate Laurent Polynomial Ring in L, M over Integer Ring\n",
      "  Defn:   Ring morphism:\n",
      "          From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "          To:   Multivariate Polynomial Ring in L, M over Integer Ring localized at (M, M - 1, L)\n",
      "          Defn: u |--> -M + 1\n",
      "                v |--> -M + 1\n",
      "                w |--> 1\n",
      "                s |--> L\n",
      "        then\n",
      "          Conversion map:\n",
      "          From: Multivariate Polynomial Ring in L, M over Integer Ring localized at (M, M - 1, L)\n",
      "          To:   Multivariate Laurent Polynomial Ring in L, M over Integer Ring\n",
      "K: Composite map:\n",
      "  From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "  To:   Multivariate Laurent Polynomial Ring in a, z over Integer Ring\n",
      "  Defn:   Ring morphism:\n",
      "          From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "          To:   Multivariate Polynomial Ring in a, z over Integer Ring localized at (z, a, a + z, a*z + 1)\n",
      "          Defn: u |--> (a*z + 1)/a\n",
      "                v |--> (a + z)/a\n",
      "                w |--> 1/a\n",
      "                s |--> a\n",
      "        then\n",
      "          Conversion map:\n",
      "          From: Multivariate Polynomial Ring in a, z over Integer Ring localized at (z, a, a + z, a*z + 1)\n",
      "          To:   Multivariate Laurent Polynomial Ring in a, z over Integer Ring\n",
      "L: Composite map:\n",
      "  From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "  To:   Multivariate Laurent Polynomial Ring in t0, t1 over Integer Ring\n",
      "  Defn:   Ring morphism:\n",
      "          From: Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u)\n",
      "          To:   Multivariate Polynomial Ring in t0, t1 over Integer Ring localized at (t1, t0, t0 + t1 - 1, t0*t1 - t0 - t1)\n",
      "          Defn: u |--> t0 + t1 - 1\n",
      "                v |--> t0*t1 - t0 - t1\n",
      "                w |--> -t0*t1\n",
      "                s |--> 1\n",
      "        then\n",
      "          Conversion map:\n",
      "          From: Multivariate Polynomial Ring in t0, t1 over Integer Ring localized at (t1, t0, t0 + t1 - 1, t0*t1 - t0 - t1)\n",
      "          To:   Multivariate Laurent Polynomial Ring in t0, t1 over Integer Ring\n"
     ]
    }
   ],
   "source": [
    "specH = MB.specialize_homfly(); print('H:', specH)\n",
    "specK = MB.specialize_kauffman(); print('K:', specK)\n",
    "specL = MB.specialize_links_gould(); print('L:', specL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can do the comparison:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H: L^3*M - L*M^3 + 2*L*M - L*M^-1 + L^-1*M - L^-1*M^-1\n",
      "K: a^4*z^2 + 2*a^3*z^3 + a^2*z^4 - 2*a^3*z + 3*a*z^3 + z^4 - 4*a*z - z^2 + a^-1*z^3 + a*z^-1 - 1 - 2*a^-1*z + a^-1*z^-1\n",
      "L: -2*t0*t1 + 4*t0 + 4*t1 - 3*t0*t1^-1 - 10 - 3*t0^-1*t1 + t0*t1^-2 + 9*t1^-1 + 9*t0^-1 + t0^-2*t1 - 3*t1^-2 - 8*t0^-1*t1^-1 - 3*t0^-2 + 2*t0^-1*t1^-2 + 2*t0^-2*t1^-1\n",
      "H: True\n",
      "K: True\n",
      "L: True\n"
     ]
    }
   ],
   "source": [
    "pH = sum(specH(L5.coefficient(b)) * b.regular_homfly_polynomial() for b in sup); print('H:', pH)\n",
    "pK = sum(specK(L5.coefficient(b)) * b.regular_kauffman_polynomial() for b in sup); print('K:', pK)\n",
    "pL = sum(specL(L5.coefficient(b)) * b.links_gould_polynomial() for b in sup); print('L:', pL)\n",
    "\n",
    "l5a1_0 = L5a1_0.link()\n",
    "print('H:', pH == l5a1_0.homfly_polynomial())\n",
    "print('K:', pK == L5a1_0.kauffman_polynomial()) # taken from KnotInfo since not available in Sage, yet\n",
    "print('L:', pL == l5a1_0.links_gould_polynomial())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Application: Defining minimal quasi-idempotents \n",
    "\n",
    "Let's apply the `CubicHeckeAlgebra` to some investigation concerning the obstruction `b` of the *triple quadratic algebra* from section 2.6 of [Mar2018](http://www.lamfa.u-picardie.fr/marin/arts/GQ.pdf). It generates the vanishing ideal inside the cubic Hecke algebra on three strands. We will construct scalar multiples of two minimal idempotents (called minimal quasi-idempotents) summing up to it. We start with definition of `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "w*c0^-1*c1 + (-w)*c0*c1^-1 + (-w)*c1*c0^-1 + w*c1^-1*c0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA3 = algebras.CubicHecke(3)\n",
    "c1, c2 = CHA3.gens()\n",
    "BR = CHA3.base_ring()\n",
    "u, v, w = BR.gens()\n",
    "b = c1^2*c2 - c2*c1^2 - c1*c2^2 + c2^2*c1; b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For convenience we will rather use a scalar multiple `b1` of the original `b` dividing by the invertible constant coefficient `-w` of the cubic equation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "c0^-1*c1 - c0*c1^-1 - c1*c0^-1 + c1^-1*c0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1  = ~w*b; b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third power of `b1` is a scalar multiple of `b1` itself (in fact it operates as a projection onto a two dimensional submodule of the three dimensional irreducible module `W3_111` of `CHA3`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b2 = b1*b1\n",
    "b3 = b2*b1\n",
    "f =  BR(b3.coefficients()[0]/2)\n",
    "ER = CHA3.extension_ring()\n",
    "ER(f) == CHA3.schur_element(CHA3.irred_repr.W3_111) # that means: f is the Schur element of the 3 dimensional irreducible "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b3 == 2*f*b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, lets split it into a sum of two minimal quasi-idempotents:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by = b2 - b1*~c1*c2*b1 \n",
    "yb = b2 - b1*c1*~c2*b1 \n",
    "f*b1 == yb - by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The choice of their names matches the following visualization (yellow-blue, blue-yellow) which is set upon the *Turaev-Kassel concept* of *tangles with coupon*. Here the coupon should be looked as pieces of ribbons which are colored opposite at corresponding backside spaces, such that they appear to be identical when turning horizontally to the backside (thus `yb` is the backside of itself but the mirror image of `by`). Note, that we draw pictures from bottom to top according to the occurrence of factors from right to left.\n",
    "\n",
    "<p><img src=\"pictures/skeinrel.png\" title=\"Skein relation\" /></p>\n",
    "\n",
    "This visualization was driven by the hope that one day these coupon can be replaced by proper *tangle diagrams* leading to a useful *skein relation* for *cubic polynomial link invariants* in analogy (resp. generalization) of the *cap-cup tangle* of the *Kauffman polynomial skein relation* where this tangle represents a minimal quasi-idempotent, as well. The only purpose of the coloring of the coupon is to reflect their symmetry properties verified below.\n",
    "\n",
    "But first, let's verify that these elements are quasi-idempotents. To this aim let's introduce some auxiliary base ring elements:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g1 = 2*v - u^2\n",
    "g2 = 2*u*w - v^2\n",
    "g3 = 4*w - u*v\n",
    "f1 = f*g1/w\n",
    "f2 = f*g2/w\n",
    "f3 = f*g3/w\n",
    "\n",
    "w^2*f == 2*w*g3 - u*w*g1 - v*g2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can verify that these a quasi idempotents with factor $f_3$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yb^2 == f3*yb, by^2 == f3*by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Another interesting pair of minimal idempotents\n",
    "\n",
    "This can easily be obtained from the first pair. Graphically they are defined as follows:\n",
    "\n",
    "<p><img src=\"pictures/byybdef1.png\" title=\"byyb1\" /></p>\n",
    "<p><img src=\"pictures/byybdef2.png\" title=\"byyb2\" /></p>\n",
    "\n",
    "We choose according notation reading the colors from bottom to top and left to right."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb =  yb*~c1\n",
    "byyb == yb*~c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb == ~c1*by, byyb == ~c2*by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Similarily in the mirror case:\n",
    "\n",
    "<p><img src=\"pictures/ybbydef1.png\" title=\"byyb1\" /></p>\n",
    "<p><img src=\"pictures/ybbydef2.png\" title=\"byyb2\" /></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby =  by*c1   \n",
    "ybby == by*c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby == c1*yb, ybby == c2*yb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For these the quasi idempotent factors differ:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb^2 == f1*byyb, ybby^2 == f2*ybby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graphically the quasi-idempotent property looks like this, for example:\n",
    "\n",
    "<img src=\"pictures/byyb_qid.png\" title=\"byyb-quasi-idempotent\" />\n",
    "<img src=\"pictures/ybby_qid.png\" title=\"ybby-quasi-idempotent\" />\n",
    "\n",
    "\n",
    "### Symmetry properties\n",
    "\n",
    "Looking into the mirror:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_mirror() == yb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this is not true since the parents are different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_mirror().parent() == yb.parent()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 + ((-v)/w)*h^2 + u/w*h + (-1)/w = 0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_mirror().parent()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But the coefficient vectors agree:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_mirror().to_vector() == yb.to_vector()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby.revert_mirror().to_vector() == byyb.to_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turning to the backside:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_garside() == by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yb.revert_garside() == yb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby.revert_garside() == ybby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb.revert_garside() == byyb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverting the orientation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby.revert_orientation() == ybby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb.revert_orientation() == byyb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by.revert_orientation() == yb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Consequent melting rules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby * byyb == f3 * by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "that is: <img src=\"pictures/ybby_byyb.png\" title=\"ybby_byyb_melt\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb * ybby == f3 *yb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "that is: <img src=\"pictures/byyb_ybby.png\" title=\"byyb_ybby_melt\" />\n",
    "\n",
    "Furthermore:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by * ybby == f3 *ybby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ybby * yb == f3 *ybby"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yb * byyb == f3 *byyb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "byyb * by == f3 *byyb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compensation of half-turn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "halfturn = c1*c2*c1\n",
    "yb * halfturn == -w * yb, halfturn * yb == -w * yb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "by * halfturn == -w * by, halfturn * by == -w * by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " byyb * halfturn == -w*byyb,  ybby * halfturn == -w*ybby\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Examples with more than 3 stands\n",
    "\n",
    "To use the cubic Hecke algebra functionality for larger cases you need to install an optional package into your Sage distribution. There are two ways to do this:\n",
    "\n",
    "1. Run `sage -i database_cubic_hecke` in a bash command-line shell.\n",
    "2. Run `sage -pip install database_cubic_hecke` in a bash command-line shell.\n",
    "\n",
    "The advantage of the first option is that you will get a version of the optional package which is compatible with the documentation of your current Sage version. The disadvantage is that it may fail on some systems and runs much longer compared to the second option.\n",
    "\n",
    "The advantage of the second option is that it gives you the latest version and installation is very fast. On the other hand (since this version can be newer than the version of your Sage distribution) it is not guaranteed that all examples of the Sage documentation are still valid.\n",
    "\n",
    "The examples of this section only work if this optional package has been installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-w)*c0*c1^-1 + v*c0*c2^-1 + u*c2*c1 + ((-v*w+u)/w)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA4 = algebras.CubicHecke(4)\n",
    "ele4 = CHA4.an_element(); ele4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain a sorted list of the involved basis elements in the former expression type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[c0*c1^-1, c0*c2^-1, c2*c1, 1]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sup = sorted(ele4.support()); sup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, that these are not embedded in the `CHA4` automatically. As basis elements they belong to the cubic braid group:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cubic Braid group on 4 strands"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sup1 = sup[0]\n",
    "sup1.parent()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But they can be mapped into the algebra by applying `CHA4` to them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-w)*(c0^-1*c1)^2 + (-v)*c0*c1^-1*c0 + u*w*c0^-1*c1*c0^-1 + v*c1*c0^-1*c1 + v*w*c0^-1*c2^-1*c1^-1 + (-u)*c0*c1*c0^-1*c1 + u*c0^-1*c2*c1*c0 + u*v*c0*c2^-1*c1^-1 + ((-v*w+u)/w)*c0*c1^-1 + (-u*v)*c1*c0^-1 + u^2*c0*c1*c0^-1 + (-v^2)*c2^-1*c1^-1"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ele4 * CHA4(sup1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Infinite dimensional algebras\n",
    "\n",
    "If the optional package is present you can even work with the infinite dimensional algebras, but just under certain restrictions. Be aware that this part of the functionality is in an experimental state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defining c0, c1, c2, c3, c4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "c0*c1*c2*c3*c4"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA6 = algebras.CubicHecke(6)\n",
    "CHA6.inject_variables()\n",
    "s = c0*c1*c2*c3*c4; s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Caution\n",
    "\n",
    "The basis is still indexed by the cubic braid group but build up randomly according to the sequence of your definition of elements: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(c0*c1*c2*c3*c4)^2]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted((s^2).support())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[c0*c1*c2*c3*c4*c1^-1, c0*c1*c2*c3*c4*c1, c0*c1*c2*c3*c4]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted((s*c1^2).support())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can obtain the randomly added basis elements by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[c3,\n",
       " c3^-1,\n",
       " c0*c1*c2*c3,\n",
       " c4,\n",
       " c4^-1,\n",
       " c0*c1*c2*c3*c4,\n",
       " (c0*c1*c2*c3*c4)^2,\n",
       " c0*c2^-1*c4,\n",
       " c0*c1^-1*c4,\n",
       " c2*c1*c4,\n",
       " c0*c1*c2*c3*c4*c1,\n",
       " c0*c1*c2*c3*c4*c1^-1]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA6.get_order()[648:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of them have also been added to the sub-algebra on 5 strands:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[c3, c3^-1, c0*c1*c2*c3]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CHA5 = CHA6.cubic_hecke_subalgebra()\n",
    "CHA5.get_order()[648:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can even obtain some irreducible matrix representations for elements of `CHA5`. But this needs `gap3` and its package `CHEVIE` to be present in your Sage: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(225, 225)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ele5 = CHA5.an_element()\n",
    "m5 = ele5.matrix(representation_type=CHA5.repr_type.SplitIrredChevie)\n",
    "m5.dimensions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m5[CHA5.irred_repr.W5_013].dimensions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(-u*a + u^2)*b - u*a^2 + u^2*a + (-u*v*w - w^2 + u)/w]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m5[CHA5.irred_repr.W5_010]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cashing intermediate results in the local filesystem\n",
    "\n",
    "The new basis elements constructed as shown above for cubic Hecke algebras on more than 4 strands are saved in your local file system under `~/.sage/cubic_hecke/basis_extensions_<strands>.sobj`. If you want to reset this you can just delete or move the corresponding file to another place or name or use the `reset_filecache` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "be = CHA5.filecache_section().basis_extensions\n",
    "CHA5.reset_filecache(section=be)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file-cache is used for other intermediate calculation results, too. Here is the list of all of them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<section.matrix_representations: 'matrix_representations'>,\n",
       " <section.braid_images: 'braid_images'>,\n",
       " <section.basis_extensions: 'basis_extensions'>,\n",
       " <section.markov_trace: 'markov_trace'>]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(CHA5.filecache_section())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix representations are cached for all basis elements. So, for at most 4 strands this cache may reach a final state. Braid images are cached after each intermediate step in the calculation which needs an application of the regular representations. The section for Markov traces is not used any more. If you call `reset_filecache` without a certain section then the complete cash will be erased."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Area for your own experiments\n",
    "\n",
    "Feel free to create more cells below to figure out the functionality. You may use all variables that have been declared above if you select the *run all*  or *run all above* item of the *Cell* drop down menu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 9.8.beta3",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}