{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "#This program contains the class CFKinfty as well as some accompanying code to construct standard examples\n", "#We now describe the main methods for the user.\n", " #The main object is the class CFKinfty.\n", " #To initialize a CFKinfty object, one passes two lists, gen and diff.\n", " #The ith entry of gen is a two element list [gr_w(x_i), A(x_i)], where x_0, ..., x_n\n", " #is an enumeration of the point in Ta\\cap Tb.\n", " #diff is a list of integer lists. diff[i] should contain j\n", " #iff there is a Maslov index 1 disk from x_i to x_j,\n", "\n", " #An example of instantiating a CFKinfty class is the following:\n", " \n", " #genFig8=[[0,0],[0,0],[-1,-1],[1,1],[0,0]]\n", " #diffFig8=[[],[2,3],[4],[4],[]]\n", " #Fig8=CFKinfty(genFig8,diffFig8)\n", " \n", " #Main attributes of the CFKinfty class:\n", " #gen\n", " #the list of generators which is passed when instantiating\n", " #diff\n", " #the differential which is passed in\n", " #rank\n", " #the number of generators\n", " #Phi\n", " #a list\n", " # Phi[i] is the list of j such that Phi(x_i) contains a summand of y_j with some powers of variables.\n", " #Phi is the map obtained by applying \"d/d U\" to the differential, written as a matrix with entries in F[U,V]\n", " #Psi\n", " #similar to Phi, but with \"d/dV\"\n", " \n", " #If C is a CFKinfty complex, then an attribute is viewed by typing \"C.gen\" and pressing enter.\n", " \n", " #Methods of the CFKinfty class\n", " \n", " #If C is a CFKinfty complex, then C.dual() is the dual\n", " \n", " #If C1 and C2 are two CFKinfty complexes, then C1.tensor(C2) is the tensor product CFKinfty complex.\n", " \n", " \n", " #The program views a map from F[U,V] to CFK^infty(K) as a list of indices\n", " # the list T=[0,2] means the sum of x_0 U^{i_0}V^{j_0}+ x_2 U^{i_2}V^{j_2} for the\n", " #unique i_0, j_0, i_1 and j_2 which put the expression into Maslov and Alexander grading zero\n", " #implicitly, we are always assuming that x_0 and x_2 are in mod 2 grading 0.\n", " \n", " #T will usually correspond to the element t_{D_1}(1)-t_{D_2}(1)\n", " \n", " #C.V0(T)\n", " #input is a list T, as above\n", " #returns an integer V_0(T)\n", " #C.Vk(T,n)\n", " #T is a list, n is a positive integer, returns integer V_n(T)\n", " #C.V(T)\n", " #returns the list [V_0(T),...V_k(T), V_{k+1}(T)] where $V_{k+1}(T)$ is the first local\n", " #h-invariant which is zero\n", " #C.tau(T)\n", " #returns the integer tau\n", " #C.Upsilon(T,t)\n", " #t is a number in [0,2]\n", " #returns a real number\n", " #C.UpsilonCoordinates(T,k)\n", " #k is a positive integer\n", " #returns a list of elements of the form [i/k, Upsilon_T(i/k)] where i is in {0,1,...,2k}\n", " #C.PlotUpsilon(T,k)\n", " #k positive integer\n", " #returns a plot of the Upsilon function, evaluated at the points i/k for i in {0,1,...,2k}\n", " \n", " #Additional methods\n", " # rotatespuninfty(C)\n", " #returns a pair [C',T] where C' is a new CFKinfty complex, corresponding to K#K#K*#K* and T is\n", " #a list corresponding to the map which is the difference between the t_D's of the canonical slice disk,\n", " #and the deform spun slice disk for the pi radian rotation of K#K\n", " # rollspun(C)\n", " #returns a pair [C',T] where C is a new CFKinfty complex, corresponding to K#K* and T\n", " #is the difference between the t_D's of the canonical slice disk and the 1-roll spun slice disk.\n", "\n", "class CFKinfty(object):\n", " #gen should be a list of 2 element lists of the form [M,A] where M is the Maslov (gr_w) grading\n", " #A is the Alexander grading\n", " #gen should be the Maslov and Alexander gradings of the intersection points in T_a\\cap T_b\n", " #diff is a list of lists. diff[i] is a list of integers. j is in diff[i] if the total count of index 1 disks going from\n", " #x_i to x_j is 1 mod 2.\n", " #Total length of diff should be the rank=the number of generators.\n", " #indexing starts at 0\n", " def __init__(self, gen, diff):\n", " self.gen=gen\n", " self.diff=diff\n", " self.rank=len(gen)\n", " #C0 is the list of generators in grading 0\n", " #it's a list of elements of the form [n,i,j]\n", " #n is the original index, and i and j are the bifiltrations\n", " #note bilfiltrations are the polynomial convention (opposite Ozsvath-Szabo convention)\n", " #so [n,i,j] means x_n U^i V^j\n", " #C1 is the list of generators in grading 1.\n", " #this part of the code builds C0 and C1\n", " C0=[]\n", " C1=[]\n", " for i in range(self.rank):\n", " L=self.gen[i]\n", " Mw=L[0]\n", " A=L[1]\n", " if Mw%2==1:\n", " x=[i,(Mw-1)/2, (Mw-2*A-1)/2]\n", " C1.append(x)\n", " if Mw%2==0:\n", " x=[i,Mw/2, (Mw-2*A)/2]\n", " C0.append(x)\n", " self.C0=C0\n", " self.C1=C1\n", " #rank0 and rank1 are the ranks of C0 and C1\n", " self.rank0=len(C0)\n", " self.rank1=len(C1)\n", " C0ind=[]\n", " for x in C0:\n", " C0ind.append(x[0])\n", " self.C0ind=C0ind\n", " Alex=[]\n", " Mas=[]\n", " for i in range(self.rank):\n", " Alex.append(gen[i][1])\n", " Mas.append(gen[i][0])\n", " #Alex and Mas are just the 0 and 1 components of the components of gen\n", " self.Alex=Alex\n", " self.Mas=Mas\n", " \n", " self.Phi=[]\n", " self.Psi=[]\n", " for i in range(self.rank):\n", " x=self.gen[i]\n", " Phix=[]\n", " Psix=[]\n", " for j in self.diff[i]:\n", " y=self.gen[j]\n", " if ((x[0]-y[0]-1)/2)%2==1:\n", " Phix.append(j)\n", " if ((x[0]-2*x[1]-y[0]+2*y[1]-1)/2)%2==1:\n", " Psix.append(j)\n", " self.Phi.append(Phix)\n", " self.Psi.append(Psix)\n", " \n", " \n", " \n", " \n", " #T is the difference between the two maps tD_1 and tD_2\n", " #T is a list of integers, corresponding to the x_i (with original indices)\n", " # which have non-zero component in (tD1-tD2)(1)\n", " # T is assumed to be in grading 0.\n", " #powers of U are filled in by the program.\n", " def V0(self,T):\n", " #instead of multiplying by powers of U, we expand which elements of C1 contribute to the differential from C1 to C0.\n", " # we consider intersection points [x,i,j] with i>=-shift and j>=-shift.\n", " #C1_remain consists of the remaining intersection points which haven't been considered.\n", " C1_remain=copy(self.C1)\n", " shift=0\n", " #deleted is the number of entries of C1 which have been added to C1k\n", " #deleted will be equal to the number of intersection \n", " #points [x,i,j] in grading 1 with i\\ge -shift and j\\ge -shift\n", " deleted_tot=0\n", " #we now make T into a vector of in F^(rank0)\n", " T0=vector(GF(2), self.rank0, sparse=true)\n", " if T0==vector(GF(2), self.rank0,sparse=true):\n", " return 0\n", " for y in T:\n", " T0+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true) \n", " #Ds is the matrix for the differential restricted to Diff1(i>=-shift, j>=-shift)\n", " Ds=matrix(GF(2),len(self.C0),0, sparse=true)\n", " #we now build Ds for shift=0\n", " while deleted_tot=-shift and x[2]>=-shift:\n", " C1_remain.pop(i-deleted_shift)\n", " deleted_shift+=1\n", " deleted_tot+=1\n", " vectordiffx=vector(GF(2),self.rank0,sparse=true)\n", " for y in self.diff[x[0]]:\n", " vectordiffx+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true)\n", " Ds=Ds.augment(vectordiffx)\n", " #PivotsAugmented is the list of pivot columns of the augmented matrix (Ds|T0)\n", " PivotsAugmented=Ds.augment(T0).pivots()\n", " NumPivots=len(PivotsAugmented)\n", " if NumPivots>0:\n", " if PivotsAugmented[len(PivotsAugmented)-1]!=deleted_tot:\n", " return shift\n", " shift+=1\n", " return \"T does appear to be a boundary\"\n", " #computes Vk(T)\n", " #the code is basically the same as V0, but with a slight tweak.\n", " #def Vk(self,T,k):\n", " def Vk(self,T,k):\n", " #instead of multiplying by powers of U, we expand which elements of C1 contribute to the differential from C1 to C0.\n", " # we consider intersection points [x,i,j] with i>=-shift and j>=-shift-k.\n", " #C1_remain consists of the remaining intersection points which haven't been considered.\n", " C1_remain=copy(self.C1)\n", " shift=0\n", " #deleted is the number of entries of C1 which have been added to C1k\n", " #deleted will be equal to the number of intersection \n", " #points [x,i,j] in grading 1 with i\\ge -shift and j\\ge -shift-k\n", " deleted_tot=0\n", " #we now make T into a vector of in F^(rank0)\n", " T0=vector(GF(2), self.rank0, sparse=true)\n", " for y in T:\n", " T0+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true) \n", " #Ds is the matrix for the differential restricted to Diff1(i>=-shift, j>=-shift-k)\n", " if T0==vector(GF(2), self.rank0,sparse=true):\n", " return 0\n", " Ds=matrix(GF(2),len(self.C0),0, sparse=true)\n", " #we now build Ds for shift=0\n", " while deleted_tot=-shift and x[2]>=-shift-k:\n", " C1_remain.pop(i-deleted_shift)\n", " deleted_shift+=1\n", " deleted_tot+=1\n", " vectordiffx=vector(GF(2),self.rank0,sparse=true)\n", " for y in self.diff[x[0]]:\n", " vectordiffx+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true)\n", " Ds=Ds.augment(vectordiffx)\n", " #PivotsAugmented is the list of pivot columns of the augmented matrix (Ds|T0)\n", " PivotsAugmented=Ds.augment(T0).pivots()\n", " NumPivots=len(PivotsAugmented)\n", " \n", " if NumPivots>0:\n", " if PivotsAugmented[len(PivotsAugmented)-1]!=deleted_tot:\n", " return shift\n", " shift+=1\n", " return \"T does appear to be a boundary\"\n", " \n", " #returns the tuple [V0,V1,V2,... ,0]\n", " def V(self,T):\n", " nonzero=true\n", " V=[]\n", " index=0\n", " while(nonzero):\n", " V_index=self.Vk(T,index)\n", " V.append(V_index)\n", " index+=1\n", " if V_index<=0:\n", " nonzero=false\n", " return V\n", " \n", " #t is a real number in [0,2]\n", " def Upsilon(self,T,t):\n", " T0=vector(GF(2), self.rank0, sparse=true)\n", " for y in T:\n", " T0+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true) \n", " if T0==vector(GF(2), self.rank0,sparse=true):\n", " return 0\n", " #C1trem is a list of elements of the form [n,s] corresponding to an intersection point in C1\n", " # n is the original index from gen.\n", " # s is (t/2) i+(1-t/2)j\n", " #the entries will be deleted as the terms are added to the differential \n", " C1tRemain=[]\n", " for L in self.C1:\n", " C1tRemain.append([L[0],(t/2)*L[1]+(1-t/2)*L[2]])\n", " C1tRemain=sorted(C1tRemain,key=lambda entry: entry[1],reverse=true)\n", " #intersection points will be removed from C1tRemain in the order of their second component\n", " #tfiltlevel denotes the current filtration level.\n", " tfiltlevel=C1tRemain[0][1]\n", " #D is the matrix denoting the differential, initialized with zero columns and rank0 rows\n", " D=matrix(GF(2),len(self.C0),0, sparse=true)\n", " while len(C1tRemain)>0:\n", " x=C1tRemain.pop(0)\n", " vectordiffx=vector(GF(2),self.rank0,sparse=true)\n", " for y in self.diff[x[0]]:\n", " vectordiffx+=vector(GF(2), self.rank0, {self.C0ind.index(y):1}, sparse=true)\n", " D=D.augment(vectordiffx)\n", " previousfiltration=tfiltlevel\n", " if len(C1tRemain)>0:\n", " tfiltlevel=C1tRemain[0][1]\n", " if tfiltlevel<0 and tfiltlevel!=previousfiltration or len(C1tRemain)==0:\n", " #PivotsAugmented is the list of pivot columns of the augmented matrix (D|T0)\n", " PivotsAugmented=D.augment(T0).pivots()\n", " NumPivots=len(PivotsAugmented)\n", " if NumPivots>0 and PivotsAugmented[NumPivots-1]!=D.ncols():\n", " return -previousfiltration\n", " return \"Error\"\n", " #returns a list of elements of the form [i/k, Upsilon_T(t)] where i is in {0,1,...,2k}\n", " #k is an integer\n", " #Computes Upsilon at i/k for i in {1/k,..., 1} and uses symmetry and basic properties to fill in rest\n", " def UpsilonCoordinates(self,T,k):\n", " L=[[0,0]]\n", " for i in range(1,k+1):\n", " L.append([i/k,self.Upsilon(T,i/k)])\n", " for i in range(k):\n", " L.append([(k+i+1)/k,L[k-1-i][1]])\n", " return L\n", " def PlotUpsilon(self,T,k):\n", " from sage.plot.point import Point\n", " L=self.UpsilonCoordinates(T,k)\n", " P=point(L)\n", " return plot(P)\n", " \n", "\n", " \n", " \n", " \n", " \n", " def tensor(self,Comp):\n", " newgen=[]\n", " newdiff=[]\n", " newAlex=[]\n", " newMas=[]\n", " r1=self.rank\n", " r2=Comp.rank\n", " for i in self.Mas:\n", " for j in Comp.Mas:\n", " newMas.append(i+j)\n", " for i in self.Alex:\n", " for j in Comp.Alex:\n", " newAlex.append(i+j)\n", " newgen=zip(newMas,newAlex)\n", " for n in range(len(self.diff)):\n", " D1=self.diff[n]\n", " for m in range(len(Comp.diff)):\n", " D1D2=[]\n", " D2=Comp.diff[m]\n", " for y1 in D1:\n", " D1D2.append(y1*r2+m)\n", " for y2 in D2:\n", " D1D2.append(n*r2+y2)\n", " newdiff.append(D1D2)\n", " return CFKinfty(newgen,newdiff)\n", " def dual(self):\n", " newgen=[[-x for x in y] for y in self.gen]\n", " newdiff=[[] for x in self.diff]\n", " for j in range(len(self.diff)):\n", " L=self.diff[j]\n", " for i in L:\n", " newdiff[i].append(j)\n", " return CFKinfty(newgen,newdiff)\n", "\n", " #diffUto0returns is a list of integer lists. Length is rank(C)\n", " #it corresponds to the differential on the complex obtained by setting U=0.\n", " def diffUto0(self):\n", " diffUto0=[]\n", " for i in range(len(self.gen)):\n", " x=self.gen[i]\n", " diffUto0x=[]\n", " for j in self.diff[i]:\n", " y=self.gen[j]\n", " if x[0]-y[0]==1:\n", " diffUto0x.append(j)\n", " diffUto0.append(diffUto0x)\n", " return diffUto0\n", " \n", " ##returns tau of the complex with the element T\n", " def tau(self, T):\n", " #C0hat and C1hat are just the lists of intersection points which are in grading 0 or 1\n", " C1hat=[]\n", " C0hat=[]\n", " for i in range(self.rank):\n", " gr=self.Mas[i]\n", " if gr==0:\n", " C0hat.append(i)\n", " if gr==1:\n", " C1hat.append(i)\n", " diffhat=self.diffUto0()\n", " #diff1 is a reindexing of diffhat, in the bases of C0hat and C1hat.\n", " #diff1 is a list of len(C1hat) lists. \n", " #The i^th sublist consists of the y_i in C0hat where D(x_j) has nonzero coefficient.\n", " diff1=[]\n", " for i in C1hat:\n", " D1new=[]\n", " D1old=diffhat[i]\n", " for j in D1old:\n", " D1new.append(C0hat.index(j))\n", " diff1.append(D1new)\n", " #r1 and r0 are the ranks of C0hat and C1hat\n", " r1=len(C1hat)\n", " r0=len(C0hat)\n", " #D an r_0 x r_1 matrix. It is the differential. It is initialized to zero.\n", " #We iterate over Alexander gradings, adding columns corresponding to int points of Alexander grading i\n", " #We assume the differential decreases Alexander grading (so it's the V=0 version)\n", " #We assume that the d(C1hat)subset C0hat\n", " D=matrix(GF(2), r0,r1, sparse=true)\n", " #makes D the restriction of diffhat to Alex<=0.\n", " for i in range(len(C1hat)):\n", " if self.Alex[C1hat[i]]<=0:\n", " for j in diff1[i]:\n", " D[j,i]+=1\n", " #makes a vector T0 in R^r0, corresponding to the element T0 in C0hat.\n", " T0=vector(GF(2),r0, sparse=true)\n", " for i in T:\n", " if self.Mas[i]==0:\n", " indi=C0hat.index(i)\n", " T0[indi]+=1\n", " #sees whether T0 is in image of DT0. Computes pivot rows \n", " DT0=D.augment(T0)\n", " Piv=DT0.pivots()\n", " if len(Piv)>0:\n", " if len(C1hat)!=Piv[len(Piv)-1]:\n", " return 0\n", " for i in range(1,max(self.Alex)+1):\n", " for j in C1hat:\n", " if self.Alex[j]==i:\n", " jnew=C1hat.index(j)\n", " for k in diff1[jnew]:\n", " D[k,jnew]+=1\n", " DT0=D.augment(T0)\n", " Piv=DT0.pivots()\n", " if len(Piv)>0: \n", " if len(C1hat)!=Piv[len(Piv)-1]:\n", " return i\n", " return \"error\"\n", " \n", " \n", " \n", " \n", "\n", "#The following is some code outside of the CFKinfty class to help build examples.\n", " \n", " \n", "# maptoelement(F) sends the endomorphism F: C to C, the element in C\\otimes C*\n", "# code can be modified to word to a map F: A to B, to give the element in B \\otimes A*,\n", "# but will need another argument for rank(B)\n", "def endotoelmt(F):\n", " E=[]\n", " rank=len(F)\n", " for i in range(len(F)):\n", " for y in F[i]:\n", " E.append(rank*y+i)\n", " return E\n", "# gives the identity function in list form\n", "def idenfunc(n):\n", " newmap=[]\n", " for i in range(n):\n", " newmap.append([i])\n", " return newmap\n", "# gives the sum of two maps, in list form. Assumes that F and G have the same number of entries.\n", "def summaps(F,G):\n", " newmap=[]\n", " for i in range(len(F)):\n", " newterm=[]\n", " newterm.extend(F[i])\n", " newterm.extend(G[i])\n", " newterm=mod2(newterm)\n", " newmap.append(newterm)\n", " return newmap\n", "\n", "def swap(n):\n", " newmap=[]\n", " for i in range(n):\n", " for j in range(n):\n", " newmap.append([n*j+i])\n", " return newmap\n", "\n", "\n", " #deletes pairs of repeated elements from a list of integers\n", "def mod2(L):\n", " K=copy(L)\n", " for x in L:\n", " if K.count(x)>1:\n", " K.remove(x)\n", " K.remove(x)\n", " return K\n", "\n", "#builds the swap map on A\\otimes A, as a list. The input n is the rank of A\n", "def composemaps(G,F):\n", " newmap=[]\n", " for x in F:\n", " L=[]\n", " for y in x:\n", " L.extend(G[y])\n", " L=mod2(L) \n", " newmap.append(L)\n", " return newmap\n", "\n", "\n", "#builds the tensor product of two maps F and G\n", "#on the tensor product of their domains, to the tensor product of their codomains\n", "#rG is the rank of the codomain of G \n", "def tensormaps(F,G,rG):\n", " newmap=[]\n", " for x1 in F:\n", " for x2 in G:\n", " T=[]\n", " for y1 in x1:\n", " for y2 in x2:\n", " T.append(y1*rG+y2)\n", " newmap.append(T)\n", " return newmap\n", "\n", "\n", " \n", "\n", "#returns a pair [C,T] where C is the CFKinfty object for K#K #K*#K* and T is the\n", "# difference of the maps for the the pi/2 rotate-spun slice disk and the canonical slice disk\n", "def rotatespuninfty(K):\n", " Kdual=K.dual()\n", " SuperK=K.tensor(K.tensor(Kdual.tensor(Kdual)))\n", " rank=K.rank\n", " X=swap(rank)\n", " PhiPsi=composemaps(K.Phi,K.Psi)\n", " PhixPsi=tensormaps(K.Phi,K.Psi,rank)\n", " Ir=idenfunc(rank)\n", " Ir2=idenfunc(rank^2)\n", " PhiPsixI=tensormaps(PhiPsi,Ir,rank)\n", " D=composemaps(X,summaps(Ir2,summaps(PhixPsi,PhiPsixI)))\n", " T=endotoelmt(summaps(D,Ir2))\n", " return [SuperK,T]\n", "\n", " #returns the [C,T] where C is the CFKinfty complex for K# K^* and T\n", " #is the difference of the maps for the 1-rollspin and the canonical slice disk\n", "def rollspun(K):\n", " KKdual=K.tensor(K.dual())\n", " rank=K.rank\n", " PhiPsi=composemaps(K.Phi,K.Psi)\n", " T=endotoelmt(PhiPsi)\n", " return [KKdual,T]\n", " \n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#some examples built using the T34 torus knot\n", "genT34=[[-6,-3],[-5,-2],[-2,0],[-1,2],[0,3]]\n", "diffT34=[[],[0,2],[],[2,4],[]]\n", "T34=CFKinfty(genT34,diffT34)\n", "# the rotate spun T34#T34\n", "R34big=rotatespuninfty(T34)\n", "R34=R34big[0]\n", "T_R34=R34big[1]\n", "#The 1-rollspin of T34#T34\n", "RollT34T34big=rollspun(T34.tensor(T34))\n", "RollT34T34=RollT34T34big[0]\n", "TRollT34T34=RollT34T34big[1]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "#Plotting Upsilon of the 1 rotatespin of T34#T34\n", "P34=R34.PlotUpsilon(T_R34,40)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "P34.plot()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#tau of the rotate spin of T34#T34\n", "R34.tau(T_R34)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 1, 0]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#[V_0,V_1,V_2] of the rotate spin of T34#T34\n", "R34.V(T_R34)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#[V_0,V_1] of the 1-roll spin of T34#T34\n", "RollT34T34.V(TRollT34T34)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Upsilon of the 1-roll spin of T34#T34\n", "RollT34T34.PlotUpsilon(TRollT34T34,10)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "#The knot complex for T45\n", "genT45=[[-12,-6],[-11,-5],[-6,-2],[-5,0],[-2,2],[-1,5],[0,6]]\n", "diffT45=[[],[0,2],[],[2,4],[],[4,6],[]]\n", "T45=CFKinfty(genT45,diffT45)\n", "#the complex and map for the rotate spin of T45#T45\n", "R45big=rotatespuninfty(T45)\n", "R45=R45big[0]\n", "T_R45=R45big[1]" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Upsilon of the rotate spin of T45#T45\n", "R45.PlotUpsilon(T_R45,40)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "P.save('UpsilonR45.pdf')" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#tau of the rotate spun T45#45\n", "R45.tau(T_R45)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, 1, 1, 0]" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "R45.V(T_R45)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "#The figure 8 complex \n", "genFig8=[[0,0],[0,0],[-1,-1],[1,1],[0,0]]\n", "diffFig8=[[],[2,3],[4],[4],[]]\n", "Fig8=CFKinfty(genFig8,diffFig8)\n", "#The rotate spin of Fig8#Fig8\n", "RFig8big=rotatespuninfty(Fig8)\n", "RFig8=RFig8big[0]\n", "T_RFig8=RFig8big[1]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#tau of the rotate spun slice disk for Fig8#Fig8\n", "RFig8.tau(T_RFig8)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#Upsilon of the rotate spin of Fig8#Fig8\n", "RFig8.PlotUpsilon(T_RFig8,10)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#[V0,V1] of the rotate spin of Fig8#Fig8\n", "RFig8.V(T_RFig8)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "RollFig8big=rollspun(Fig8)\n", "RollFig8=RollFig8big[0]\n", "TRollFig8=RollFig8big[1]" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "p=RollFig8.PlotUpsilon(TRollFig8,40)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "p.save('rollspunfig8upsilon.pdf')" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1 graphics primitive" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "p.plot()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "T45T34=T45.tensor(T34)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "RollT45T34big=rollspun(T34.tensor(T34))\n", "RollT45T34=RollT34T34big[0]\n", "TRollT45T34=RollT34T34big[1]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "RollT45T34.V(TRollT45T34)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "Fig8T45=Fig8.tensor(T45)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "Roll8T45big=rollspun(Fig8T45)\n", "Roll8T45=Roll8T45big[0]\n", "TRoll8T45=Roll8T45big[1]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Roll8T45.V(TRoll8T45)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "T34cubed=T34.tensor(T34.tensor(T34))" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "RT34cubedbig=rollspun(T34cubed)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "R=RT34cubedbig[0]\n", "T=RT34cubedbig[1]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "R.V(T)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "genT94=[[0,12],[-1,11],[-2,8],[-3,7],[-4,4],[-7,2],[-8,0],[-11,-2],[-12,-4],[-17,-7],[-18,8],[-23,11],[-24,12],]\n", "diffT94=[[],[0,2],[],[2,4],[],[4,6],[],[6,8],[],[8,10],[],[10,12],[]]\n", "T94=CFKinfty(genT94,diffT94)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "RollT94big=rollspun(T94)\n", "RT94=RollT94big[0]\n", "TT94=RollT94big[1]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "RT94.tau(TT94)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "RollT94sqbig=rollspun(T94.tensor(T94))\n", "RT94sq=RollT94sqbig[0]\n", "TT94sq=RollT94sqbig[1]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 0]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "RT94sq.V(TT94sq)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "SageMath 8.2", "language": "", "name": "sagemath" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.14" } }, "nbformat": 4, "nbformat_minor": 2 }