Worksheet III for quandle 2-cocycle and 3-cocycle invariants  

Mochizuki Polynomial Cases 

by Masahico Saito & Chad Smudde  

      These programs compute quandle cocycle invariants of classical knots where the two or three cocycles are Mochizuki polynomial cocycles for Alexander quandles.  

>

restart;

 

ALEXANDER QUANDLES 

First, we will look at Alexander quandles. In the previous worksheets, the quandles that we used were taken from the file "Quandle." The table of quandles that were used for this file came from the book, ``Surfaces in 4-space,'' by Carter, Kamada, and Saito, Springer-Verlag, 2004. We now are going to look at a special type of quandle called Alexander quandles.  Procedures to generate the Cayley tables for these quandles will be explained in the first part of this worksheet, and procedures that calculate the 2 and 3-cocycle invariants where the cocycles are Mochizuki polynomial cocycles will be explained in the second part.  

Step 1: Read the file "alexQuanpkg.m" into the worksheet.  

          Determine where the file "alexQuanpkg.m" is saved and make a note of the path.  

          Next use the read command followed by double quotes and the path where the file was saved. e.g. [> read "path to alexQuanpkg.m"; .
          Here are some examples that are platform specific.
          Windows:            [>. read "C:\\maple.local\\Project\\Top.txt".
          UNIX:                 [> read "/usr/local/maple.local/Project/Top.txt".
          Macintosh:           [> read "Main HD:Local Maple Files:Project:Top.txt"  
          If the files are saved in the same directory (folder) and that directory is currently the active directory, then you may only need to type the file name,
          such as [> read ``filename'' .
          For more information on reading the file into the worksheet  type ?read or ?file at the prompt to see Maples online help.
          If all else fails download the file "AlexQuandlepkgprocs.mws" and use this as a template for these and future calculations.
          The procedures included in the "alexQuanpkg.m" file are:
                       quandlesize(Quande),
                       Alexmult(a,b,polym,p),
                       rres(polym,p),
                       findelt(L,pol),
                       AlexQuandle(polym,p).
            The procedure AlexQuandle() is the main procedure that will be used. The other local procedures will be discussed in less detail. 

>	read "alexQuanpkg.m";

 

>

 

Recall that Z_p[t,t^-1]/(h(t)) where h(t)=a_0+a_1*t+...+a_n*t^n is a polynomial in t with quandle operation a*b=ta+(1-t)b is a finite quandle. The procedure AlexQuandle() will generate the Cayley table for this quandle and return an isomorphic quandle whose Cayley table has elements in {0..n-1} where n is the order of the quandle.
This will allow us to reuse old programs that are set to only accept quandles that are zero indexed two dimensional arrays with elements in {0..n-1}.   

>	Aquandle:=AlexQuandle(t+1,3):

 

>	print(convert(Aquandle,matrix));

 

Since p is prime and h(t)=a_0+a_1*t+...+a_n*t^n is a polynomial (in t),  elements of Z_p[t,t^-1]/(h(t)) are represented by the reduced residue system, i.e., polynomials of the form b_0+b_1*t+...+b_(n-1)*t^(n-1) where b_i is in Z_p. Since p is prime 1..p-1 are units in Z_p, so that we can solve  (t^(-1))*h(t)=0 for t^-1. This implies that t^(-1) is expressed by a polynomial as above, and every element is represented by a polynomial of a positive degree. Then by taking the remainder when divided by h(t), every element is represented by a polynomial as above. The purpose of the local procedure rres() is to list all such polynomials. Then the procedure Alexmult() will multiply all possibilities a*b where a, b are in the reduced residue system. The resulting polynomial will then be reduced back into the reduced residue system. Then the procedure findelt() will find that polynomial in the list of reduced residues and return that integer value.  

Step 2: Read the braid words into the worksheet.
           The file "knotsLivingston.txt" contains the knot name, braid words, and Alexander polynomials  for the prime knots in the table up to and including 12 crossings. The knots are organized as follows. The array name is "Knot." There are 2977 such prime knots according to Charles Livingston's knot database. The array "Knot" is then first numbered from 0 to 2966. The second index 1,2, or 3 then represents the knot name , braid word, and the Alexander polynomial, respectively.  

>	read "knotsLivingston.txt":

 

The following example returns the knot name of the trefoil knot. 

>	Knot[0,1];

 

Next we get the braid word for the trefoil. 

>	Knot[0,2];

 

Finally, we get the Alexander polynomial from the third element or the row. 

>	Knot[0,3];

 

MOCHIZUKI POLYNOMIAL COCYCLE INVARIANTS 

First we need to read the procedures into the worksheet.  

>	read "PolycocInvpkg.m";

 

The following procedures are included into the package:  

         Invariants2_3Mochizuki(Xpolym,Apolym,p,m1,m2,a3,n1,b2,Knot),
         findgood3cocexp(g,p,n),
         Invar2Mochizuki(Xpolym,Apolym,p,m1,a2,Knot),
         cocycle2check(cocy,Xpolym,Apolym,p),
         Mochizuki2coc(Xpolym,Apolym,p,m1,a2),
         Xi(n),
         TableInvars(n,p,g,m1,m2,a3),
         Invar3Mochizuki(Xpolym,Apolym,p,m1,m2,a3,Knot),
         makeinv(Quandle),
         cocycle3check(cocy,Xpolym,Apolym,p),
         Mochizuki3coc(Xpolym,Apolym,p,m1,m2,a3),
         MochizukiDihedral3coc(p),
         CalcDihinvars(filePATH,p,numberofKnots),
         Calcinvars(filePATH,p ,polym,n,b,m1,m2,a3,numberofKnots),
         ismult(charstar),
         calc3cocInvar(Quandle,Knot,m::posint,(optional) cocycle values),
 

Let X=Z_p[t,t^-1]/((h(t)) be an Alexander quandle and A=Z_p[t,t^-1]/(g(t)) be an Alexander quandle used for the coefficient group. Here g(t) must divide h(t) mod p.  Following Mochizuki, we compute that for x_i in X, f(x_1,x_2,...,x_n)=(x_1-x_2)^(p^m1)*(x_2-x_3)^(p^m2)*...*(x_(n-1)-x_n)^(p^m_(n-1))*x_n^(a_n) is a cocycle where p is prime and either a_n is 0 or a power of p such that g(t) divides 1-t^((p^m1)+(p^m2)+...+a_n) mod p. Mochizuki2coc:=proc(Xpolym,Apolym,p,m1,a2) and Mochizuki3coc:=proc(Xpolym,Apolym,p,m1,m2,a3) are procedures that will generate the values for the 2 and 3-cocycle cases respectively. All possible elements are taken from the quandle X and the value for f(x,y) (or f(x,y,z)) are calculated and reduced mod p and mod g(t). This happens only if either a_n is zero or if a_n<>0 and g(t) divides 1-t((p^m1)+(p^m2)+...+a_n) mod p. These procedures will either return a table of values for the cocycle or will print Mochizuki conditions not satisfied and return false.  

First an example in the 2-cocycle case. Mochizuki2coc:=proc(Xpolym,Apolym,p,m1,a2) takes as its first and second arguments the polynomials for the quandles X and A (Xpolym=h(t) and Apolym=g(t)). The third argument is a prime p used for both quandles and the cocycle formula. The argument m1 is the exponent of p for the first term of the product( (x_1-x_2)^(p^m1) ) and a2 is the exponent for the last term, x_2. The argument a_2  can be zero or a power of p. In the case that a power of p is desired, the complete term must be passed not just the power of p (eg. a_2=p^3). In the case that the final term is a prime power, the procedure does not test that it is indeed a prime power, but it only checks that g(t) divides 1-  t^((p^m1)+(p^m2)+...+a_n) mod p. 

>	ex1_2coc:=Mochizuki2coc(t^2-t+1,t^2-t+1,3,2,0);

 

>	print(ex1_2coc);

 

In the above example, the term a_2 was zero so the quandle A was not restricted at all. The following example has term a_2 a prime power. 

>	ex2_2coc:=Mochizuki2coc(t^2-t+1,t^2-t+1,3,2,3^3);

 

>	print(ex2_2coc);

 

In this case the procedure performs a divides test to make sure the choices satisfy the Mochizuki conditions. 

>	Divide(1-t^(3^2+3^3),t^2-t+1) mod 3;

 

The following is an example where the final term is nonzero and the Mochizuki conditions are not satisfied. Here the polynomial for the Alexander quandle A=Z_p[t,t^-1]/(g(t)) was changed. 

>	ex3_2coc:=Mochizuki2coc(t^2-t+2,t^2-t+2,3,2,3^3);

 

The next statement shows where the previous example fails. 

>	Divide(1-t^(3^2+3^3),t^2-t+2) mod 3;

 

The 3-cocycle case is similar except that there are more terms in the product. 

>	ex4_3coc:=Mochizuki3coc(t^2-t+1,t^2-t+1,2,2,1,0);

 

>	print(ex4_3coc);

 

One should observe the values that the 3-cocycle example above has. In the beginning of this worksheet we generated the Alexander quandle and created a isomorphic quandle whose elements were in {0.. n-1}. These are the values that are used for coloring the braids. This same isomorphism is used in generating the cocycle values. The arguments to the Mochizuki cocycle formula are in the set {0..n-1} and then calculations of the Mochizuki formula use the polynomial that represents the integer. The formula is then reduced in the Alexander quandle A=Z_p[t,t^-1]/(g(t)) and stays in polynomial form. These values in A will carry over to the state sum and be seen in the value of the invariant. More about this later when that procedure is explained. 

The above two procedures do not check that the values calculated actually satisfy the 2 or 3 cocycle conditions. There are special local functions for this. They are cocycle3check:=proc(cocy,Xpolym,Apolym,p) and cocycle2check:=proc(cocy,Xpolym,Apolym,p). The last three parameters are the same as described above. The first parameter is the table of values returned from the procedures Mochizuki2coc:=proc(Xpolym,Apolym,p,m1,a2) or Mochizuki3coc:=proc(Xpolym,Apolym,p,m1,m2,a3) . This procedure substitutes these values into the cocycle conditions and checks that they vanish. The return value is either true or false. 

>	cocycle2check(ex2_2coc,t^2-t+1,t^2-t+1,3);

 

>	cocycle3check(ex4_3coc,t^2-t+1,t^2-t+1,2);

 

I will now change a value of the cocycles to show a false output. 

The value of f (0,0,0) in example 4 before manipulation. 

>	ex4_3coc[0,0,0];

 

Now we change the value of one of the terms to create a false output. 

>	ex4_3coc[0,0,0]:=t+1;

 

Now we check if the altered table satisfies the cocycle conditions (which it shouldn't). 

>	cocycle3check(ex4_3coc,t^2-t+1,t^2-t+1,2);

 

>	ex4_3coc[0,0,0]:=0;cocycle3check(ex4_3coc,t^2-t+1,t^2-t+1,2);

 

Now we look at calculating the value of the Mochizuki 2 and 3-cocycle invariants with the procedures Invar2Mochizuki:=proc(Xpolym,Apolym,p,m1,a2,Knot) and Invar3Mochizuki:=proc(Xpolym,Apolym,p,m1,m2,a3,Knot). The only parameter that is different in these two procedures when compared to the procedures, Mochizuki2coc:=proc(Xpolym,Apolym,p,m1,a2) and Mochizuki3coc:=proc(Xpolym,Apolym,p,m1,m2,a3), calculating the cocycle values is the last parameter which is the braid word. These procedures will calculate the cocycle values and test if they satisfy the cocycle condition by calling the above described procedures. It will then proceed to color the braid and return the value of the invariant. 

>	Knot[0,1];Invar3Mochizuki(t^2+t+1,t^2+t+1,2,0,1,0,Knot[0,2]);

 

One can see that the coefficient group is Z_2[t,t^-1]/(t^2+t+1) which has the reduced residue system {0,1,t,1+t}. Recall that the procedure calculating the values for the cocycles left the value in polynomial form. The polynomial form is carried through to the output of the invariant. Therefore, the "t" in the above example represents an element of {0,1,t,1+t}. The value of the invariant shows that there were 48 colorings that took the value of t in {0,1,t,1+t}. One must be careful here since in the first worksheet t (really t was an array) represented a free variable. The 2-cocycle invariant is similar. 

Given the complexity of coloring the braid with the quandle, we may wish to get the most out of our calculation. Since the shadow coloring case uses only those colorings of the braid that are "valid" we could calculate a 3-cocyle invariant at the same time as the two cocycle invariant with the small added cost of calculating the colorings of the regions of only the "valid" braid colorings. The procedure Invariants2_3Mochizuki:=proc(Xpolym,Apolym,p,m1,m2,a3,n1,b2,Knot)
will do this. The first six parameters are the same as the 3-cocycle invariant procedure. Now the variables n1 and b1 represent the exponents for the Mochizuki 2-cocycle formula.  Finally, a braid word is given as the last parameter. 

A special procedure Xi(n) is given to produce the alternating polynomial in t Sum((-t)^i,i = 0 .. n-1). This is useful for creating polynomials for the Alexander quandles. 

>	T3:=Xi(3);

 

>	Knot[0,1];Invariants2_3Mochizuki(T3,T3,5,0,1,0,2,0,Knot[0,2]);

 

The first value returned, 625 in this example, represents the value of the 2-cocycle invariant, and the second element returned, ,  is the value of the 3-cocycle invariant.
Recall that the exponents represent elements in the reduced residue system of the Alexander quandle used for the coefficient group A=Z_5[t,t^-1]/(T3).  

There is one more special procedure to cover in this worksheet, TableInvars:=proc(n,p,g,m1,m2,a3). This procedure is used to calculate Mochizuki 3-cocycle invariants for the Mochizuki formula f(x,y,z)=(x-y)^(p^m1)*(y-z)^(p^m2)*z^a3. In this case the Alexander quandles used for coloring and the coefficient group are taken to be the same. Therefore, by giving one polynomial, g, in t, and the prime modulus we calculate both quandles. The first parameter n represents how far through the file of knots, knotsLivingston.txt",  you wish to calculate. For example n=83 gives all prime knots with 9 and fewer crossings (n=248 for 10 and fewer crossings, n=800 for 11 and fewer, and n=2976 for 12 and fewer). Any other special point you wish to stop at can be found by examining the knotsLivingston.txt file. 

MOCHIZUKI POLYNOMIAL 3-COCYCLE INVARIANTS FOR DIHEDRAL QUANDLES 

The Cayley table for the Dihedral quandle can be obtained by using the AlexQuandle() procedure. This is just the special case when the polynomial, polym, passed to the procedure is t+1.Therefore R3 can be obtained from the following call. 

>	R3:=AlexQuandle(t+1,3);

 

>	print(convert(R3,matrix));

 

The Mochizuki 3-cocycle formula is given by f[i,j,k]:=((i-j)*((2*k^p-j^p)-(2*k-j)^p)/p) mod p. The procedure MochizukiDihedral3coc:=proc(p) will generate the values for the 3-cocycle. In this case the prime for the Mochizuki 3-cocycle formula and quandle R3 are the same. Therefore, only the prime number needs to be passed to the procedure.   

>	M3Dcoc:=MochizukiDihedral3coc(3);

 

>	print(M3Dcoc);

 

The procedure, calc3cocInvar:=proc(Quandle,Knot,m::posint), from worksheet #1 (the untwisted worksheet) can be used to calculate the invariant. Recall that this procedure had an optional 4th argument that would take the table of cocycle values. So in this case we just use the above procedures to get the desired case. 

>	Knot[0,1];calc3cocInvar(R3,Knot[0,2],3,M3Dcoc);

 

The next worksheet will look at procedures that help in doing mass calculations in a effective and effortless (for the user) way