{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This program has been checked with $\\texttt{SageMath 10.5}$ with $\\texttt{Sirocco}$ so that the fundamental group package can run. \n",
    "Otherwise, a presentation for the groups has been included for convenience.\n",
    "The following code computes twisted Alexander polynomials."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#################################################################\n",
    "#Twisted Fox derivative of x_n with respect to x_m\n",
    "#associated with the morphism \"hom\" (hom(x_i)=hom[i]) and\n",
    "#the linear representation \"subs_repres\".\n",
    "#OPTIONS: \"mmod\" can be either a number or a list [n,p1,...] \n",
    "# where n is a natural number and p1,... is a list of \n",
    "# one-variable polynomials\n",
    "def tw_dif(n,subs_repres,hom,m,R):\n",
    "    QR=R.fraction_field()\n",
    "    QR.inject_variables(verbose=False)\n",
    "    subs_repres_aux=[_.change_ring(QR) for _ in subs_repres]\n",
    "    dd=subs_repres_aux[0].dimensions()\n",
    "    if dd[0]!=dd[1]:\n",
    "        return 'Wrong representation matrix'\n",
    "    else: \n",
    "        d=dd[0]\n",
    "    uno=identity_matrix(d)\n",
    "    cero=0*uno\n",
    "    mod_rels=[]\n",
    "    if m<=0:\n",
    "        return 'Error'\n",
    "    elif n==-m:\n",
    "        return (-subs_repres_aux[m-1]^(-1))*(1/hom[m-1])\n",
    "    elif n==m:\n",
    "        return uno\n",
    "    else: \n",
    "        return cero\n",
    "\n",
    "#################################################################\n",
    "#Twisted Fox derivative of \"list\" with respect to x_m\n",
    "#associated with the morphism \"hom\" (hom(x_i)=hom[i]) and\n",
    "#relative to the linear representation \"subs_repres\" \n",
    "#OPTIONS: \"mmod\" can be either a number or a list [n,p1,...] \n",
    "# where n is a natural number and p1,... is a list of \n",
    "# one-variable polynomials\n",
    "def tw_dif_list(list,subs_repres,hom,m,R):\n",
    "    QR=R.fraction_field()\n",
    "    QR.inject_variables(verbose=False)\n",
    "    l=len(list)\n",
    "    subs_repres_aux=[_.change_ring(QR) for _ in subs_repres]\n",
    "    if l==1:\n",
    "        return tw_dif(list[0],subs_repres_aux,hom,m,R)\n",
    "    elif sign(list[0])==-1:\n",
    "        aux=subs_repres_aux[abs(list[0])-1]^(-1)*(1/hom[abs(list[0])-1])\n",
    "    else: \n",
    "        aux=subs_repres_aux[abs(list[0])-1]*hom[abs(list[0])-1]\n",
    "    return tw_dif(list[0],subs_repres_aux,hom,m,R)+aux*tw_dif_list([list[i+1] for i in range(l-1)],subs_repres_aux,hom,m,R)\n",
    "\n",
    "########################################################################\n",
    "#tw_alex_matrix(list_rels,subs_repres,hom) it produces the Alexander\n",
    "#matrix for the twisted case relative to the relations \"list_rels\",\n",
    "#to the morphism \"hom\" and to the linear representation \"subs_repres\".\n",
    "#OPTIONS: \"mmod\" can be either a number or a list [n,p1,...] \n",
    "# where n is a natural number and p1,... is a list of \n",
    "# one-variable polynomials\n",
    "def tw_alex_matrix(list_rels,subs_repres,hom,R):\n",
    "    QR=R.fraction_field()\n",
    "    QR.inject_variables(verbose=False)\n",
    "    subs_repres_aux=[_.change_ring(QR) for _ in subs_repres]\n",
    "    dd=subs_repres_aux[0].dimensions()\n",
    "    if dd[0]!=dd[1]:\n",
    "        return 'Wrong representation matrix'\n",
    "    else: \n",
    "        d=dd[0]\n",
    "    lrels=len(list_rels)\n",
    "    lrepres=len(subs_repres_aux)\n",
    "    m=max(flatten(list_rels))\n",
    "    if m!=lrepres:\n",
    "        return print(\"error\")\n",
    "    A_aux=block_matrix(lrels,m,[tw_dif_list(i,subs_repres_aux,hom,j,R) for i in list_rels for j in [1..m]])\n",
    "    A_aux_simpl=[QR(_) for _ in A_aux.list()]\n",
    "    A=matrix(dd[0]*lrels,dd[0]*m,A_aux_simpl)\n",
    "    return A\n",
    "\n",
    "########################################################################\n",
    "#rep_check(As,rels) checks if the list of matrices \"As\" produces a representation \n",
    "#of a finitely presented group whose relations are given in \"rels\".\n",
    "def rep_check(As,rels):\n",
    "    n=len(As)\n",
    "    d=As[0].dimensions()[0]\n",
    "    for k in As:\n",
    "        if k.determinant()!=1:\n",
    "            print(k)\n",
    "            return 'False'\n",
    "    for k in rels:\n",
    "        for i in range(n):\n",
    "            kk=identity_matrix(d)\n",
    "            for j in range(len(k)):\n",
    "                kk=kk*As[abs(k[j])-1]^(sign(k[j]))\n",
    "            if kk!=identity_matrix(d):\n",
    "                print(j,kk)\n",
    "                return 'False'\n",
    "    return 'True'\n",
    "\n",
    "########################################################################\n",
    "#reps(As,rels) produces a list of equations required by the entries of the matrices \"As\" \n",
    "#to define a representation of a finitely presented group whose relations are given in \"rels\".\n",
    "def reps(As,rels):\n",
    "    n=len(As)\n",
    "    d=As[0].dimensions()[0]\n",
    "    eqs_aux=[_.det()-1 for _ in As]\n",
    "    for k in rels:\n",
    "        for i in range(n):\n",
    "            kk=identity_matrix(d)\n",
    "            for j in range(len(k)):\n",
    "                kk=kk*As[abs(k[j])-1]^(sign(k[j]))\n",
    "            kk=kk-identity_matrix(d)\n",
    "            eqs_aux=eqs_aux+[_.numerator() for _ in kk.list()]\n",
    "    return eqs_aux"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the equations of the curves $C_1$ and $C_2$ and calculate the fundamental groups of their complements. If $\\texttt{Sirocco}$ is not installed, skip this cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var('x,y,z')\n",
    "A.<x,y> = (QQ[I])[]\n",
    "f=x^6+y^6+6*x*y\n",
    "g1aux=(f+4)*(f-4)\n",
    "g2aux=(f+4)*(f-4*I)\n",
    "g1=A(g1aux)\n",
    "g2=A(g2aux)\n",
    "C1=Curve(g1)\n",
    "C2=Curve(g2)\n",
    "G1=C1.fundamental_group()\n",
    "G2=C2.fundamental_group()\n",
    "G1_rels=[list(_.Tietze()) for _ in G1.relations()]\n",
    "G2_rels=[list(_.Tietze()) for _ in G2.relations()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "G1_rels=[[-3, -2, -1, 2, 3, -2, 1, 2], [1, 2, -3, -2, 3, -1, 2, 3, -2, -2, -1, 2], [-1, -3, -1, 3, -2, -1, 2, 1, 3, 2, 3, -2], [3, 1, 2, 2, 3, -2, -1, -3, -2, -2, -1, 2], [2, 3, 2, -3, -2, -2, 1, 2, -3, 1, -2, -1], [-1, 2, 3, 3, -2, -3, -2, -2, 3, -2, -1, 2, 2, 1, 2, -1]]\n",
    "G2_rels=[[1,-1],[2,-2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We check that both Characteristic Varieties coincide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G1.characteristic_varieties()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G2.characteristic_varieties()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the number field $F=\\mathbb Q[\\xi]$, where $\\xi$ is an 8-primitive root of unity and $R=F[t,t^{-1}]$ Laurent polynomial ring over $F$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "var('t')\n",
    "sqI = -QQ[x](x^4+1).roots(QQbar)[0][0]\n",
    "F = NumberField((sqI).minpoly(), 'sqI', embedding=sqI)\n",
    "F.inject_variables(verbose=False)\n",
    "R= LaurentPolynomialRing(F,[t], order='degrevlex')\n",
    "R.inject_variables(verbose=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a $U(2)$ representation for $G_1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html>\\(\\displaystyle \\left[\\left(\\begin{array}{rr}\n",
       "\\mathit{sqI} & 0 \\\\\n",
       "0 & -\\mathit{sqI}^{3}\n",
       "\\end{array}\\right), \\left(\\begin{array}{rr}\n",
       "-\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI} & -\\frac{1}{2} \\mathit{sqI}^{2} \\\\\n",
       "-\\mathit{sqI}^{2} & -\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI}\n",
       "\\end{array}\\right), \\left(\\begin{array}{rr}\n",
       "-\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI} & -\\frac{1}{2} \\\\\n",
       "1 & -\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI}\n",
       "\\end{array}\\right)\\right]\\)</html>"
      ],
      "text/latex": [
       "$\\displaystyle \\left[\\left(\\begin{array}{rr}\n",
       "\\mathit{sqI} & 0 \\\\\n",
       "0 & -\\mathit{sqI}^{3}\n",
       "\\end{array}\\right), \\left(\\begin{array}{rr}\n",
       "-\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI} & -\\frac{1}{2} \\mathit{sqI}^{2} \\\\\n",
       "-\\mathit{sqI}^{2} & -\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI}\n",
       "\\end{array}\\right), \\left(\\begin{array}{rr}\n",
       "-\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI} & -\\frac{1}{2} \\\\\n",
       "1 & -\\frac{1}{2} \\mathit{sqI}^{3} + \\frac{1}{2} \\mathit{sqI}\n",
       "\\end{array}\\right)\\right]$"
      ],
      "text/plain": [
       "[\n",
       "[   sqI      0]  [-1/2*sqI^3 + 1/2*sqI           -1/2*sqI^2]\n",
       "[     0 -sqI^3], [              -sqI^2 -1/2*sqI^3 + 1/2*sqI],\n",
       "\n",
       "[-1/2*sqI^3 + 1/2*sqI                 -1/2]\n",
       "[                   1 -1/2*sqI^3 + 1/2*sqI]\n",
       "]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "A1=matrix(2,2,[sqI,0,0,-sqI^3]);\n",
    "A2=matrix(2,2,[-(sqI^3 - sqI)/2,-sqI^2/2,-sqI^2,-(sqI^3 - sqI)/2]);\n",
    "A3=matrix(2,2,[-(sqI^3 - sqI)/2,-1/2,1,-(sqI^3 - sqI)/2]);\n",
    "As=[A1,A2,A3];show(As)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check As is a valid representation, that is, the matrices of As satisfy the relations in the presentation of $G_1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'True'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rep_check(As,G1_rels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the twisted Alexander polynomial associated with the representation As anf the morphism $\\varepsilon:G_1\\to \\mathbb Z$ defined as $\\varepsilon(x_1)=\\varepsilon(x_2)=\\varepsilon(x_3)=1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<html>\\(\\displaystyle (t + \\mathit{sqI}^{3}) \\cdot (t - \\mathit{sqI})\\)</html>"
      ],
      "text/latex": [
       "$\\displaystyle (t + \\mathit{sqI}^{3}) \\cdot (t - \\mathit{sqI})$"
      ],
      "text/plain": [
       "(t + sqI^3) * (t - sqI)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Asi=As\n",
    "A=tw_alex_matrix(G1_rels,Asi,[t,t,t],R)\n",
    "A_red=A.delete_columns([0,1])\n",
    "i=4\n",
    "Fi=[_.numerator() for _ in A_red.minors(i)];\n",
    "Delta1=gcd(Fi)\n",
    "Delta0=(Asi[0]*t-identity_matrix(2)).determinant()\n",
    "show((Delta1/Delta0).factor())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 10.5",
   "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}