User:Ben/KRhomology

Actual calculations

Here is a table of known KR homologies. We let $KR_{K}(q,s,t)$ be the Hilbert series of KR homology. Note that a factor of the Hilbert series of the unknot appears in all of them. This will not be true of links, I believe.

Unfortunately, computation seems to bog down very fast. 6_1 has been giving me a lot of trouble, probably because it has braid index 4. If someone with a faster machine would run it, I would be very appreciative.

Warning the polynomial for 5_2 here is incorrect. The correct value appears on the main Knot Atlas page for 5_2. --Scott 12:48, 3 Dec 2005 (EST)

0_1	${\frac {{q}{t}+1}{1-t}}$
3_1	$\left({\frac {{q}{t}+1}{1-t}}\right)(s^{2}t^{2}+{q}t^{2}+1)$
4_1	$\left({\frac {{q}{t}+1}{1-t}}\right)(t^{-1}+{q}{t}+{q}s^{-1}+{q}s^{-{2}}t^{-1}+q^{2}s^{-{2}}{t})$
5_1	$\left({\frac {{q}{t}+1}{1-t}}\right)(1+s^{2}t^{2}+s^{4}t^{4}+{q}s^{2}t^{4}+{q}t^{2})$
5_2	$\left({\frac {{q}{t}+1}{1-t}}\right)({q}+q^{2}s^{-{2}}+t^{-{2}}+q^{2}s^{-{3}}t^{-1}+{q}s^{-{2}}t^{-{2}})$
6_2	$\left({\frac {{q}{t}+1}{1-t}}\right)({q}{t}+q^{2}s^{-{2}}{t}+{q}s^{-1}+t^{-1}+2{q}s^{-{2}}t^{-1}+s^{-1}t^{-{2}}+q^{2}s^{-{4}}t^{-1}+{q}s^{-{3}}t^{-{2}}+s^{-{2}}t^{-{3}}+{q}s^{-{4}}t^{-{3}})$
6_3	${\left({\frac {{q}{t}+1}{1-t}}\right)(q}{s}t^{2}+q^{2}s^{-1}t^{2}+{q}{t}+{s}+q^{2}s^{-{2}}{t}+3{q}s^{-1}+t^{-1}+q^{2}s^{-{3}}+{q}s^{-{2}}t^{-1}+s^{-1}t^{-{2}}+{q}s^{-{3}}t^{-{2}})$

I've been running more calculations on panda and neuron, two of the fast computers in the math department. I've got panda working through all the braid index 3 knots, and it's started giving some results. 7_3 took about half an hour, and consumed about a gig of memory. --Scott 02:16, 30 Nov 2005 (EST)

7_3	$\left({\frac {{q}{t}+1}{1-t}}\right)({q}s^{3}t^{5}+s^{4}t^{4}+q^{2}{s}t^{5}+{q}s^{2}t^{4}+s^{3}t^{3}+2{q}{s}t^{3}+s^{2}t^{2}+q^{2}s^{-1}t^{3}+{q}t^{2}+{s}{t}+{q}s^{-1}{t}+1)$
7_5	$\left({\frac {{q}{t}+1}{1-t}}\right)(q^{2}s^{-{2}}+{q}s^{-1}t^{-1}+q^{2}s^{-{3}}t^{-1}+2{q}s^{-{2}}t^{-{2}}+s^{-1}t^{-{3}}+2q^{2}s^{-{4}}t^{-{2}}+2{q}s^{-{3}}t^{-{3}}+s^{-{2}}t^{-{4}}+q^{2}s^{-{5}}t^{-{3}}+2{q}s^{-{4}}t^{-{4}}+s^{-{3}}t^{-{5}}+q^{2}s^{-{6}}t^{-{4}}+{q}s^{-{5}}t^{-{5}})$

neuron is working on braid index 4 knots, starting with 6_1, and seems to be working fine. 6_1 took over an hour, and about 1.2 gigs of memory. --Scott 02:59, 30 Nov 2005 (EST)

6_1	$\left({\frac {{q}{t}+1}{1-t}}\right)(q^{2}s^{-1}t^{2}+{q}{t}+q^{3}s^{-{3}}t^{2}+q^{2}s^{-{2}}{t}+2{q}s^{-1}+t^{-1}+q^{2}s^{-{3}}+{q}s^{-{2}}t^{-1})$

Theoretical stuff

I have some ideas which I hope will be of interest to ya'll, but I'd like to mull them a bit longer. Maybe when I get back on Wednesday.

Macaulay2 program

Save this as a file (called KR.m2), open Macaulay2 (in command line or emacs), and type load "KR.m2". KRpoly is probabby the command you want (but it only works for knots at the moment). It outputs ${\frac {1-t}{qt+1}}KR_{K}(q,s,t)$. Using texMath puts things in format for LaTeX.

Here's a sample session:

Macaulay 2, version 0.9
--Copyright 1993-2001, D. R. Grayson and M. E. Stillman
--Singular-Factory 1.3b, copyright 1993-2001, G.-M. Greuel, et al.
--Singular-Libfac 0.3.2, copyright 1996-2001, M. Messollen

i1 : load "KR.m2"
KR.m2:113:11: warning: local declaration of N shields variable with same name
--loaded KR.m2

i2 : texMath KRpoly K01

o2 = 1

i3 : texMath KRpoly K31

o3 = s^{2} t^{2}+{q} t^{2}+1

i4 : 

Here's the code for the program.

--KR.m2
--This file defines a new object for Macaulay2, called a "Link."
--Like all objects in Macaulay2, a Link is just a hash table.
--Defining a link lets you store information about it for later use.  

Link = new Type of MutableHashTable 
Link.synonym = "link"
new Link := Link => (cl) -> (
     C:=newClass(Link,new MutableHashTable);
     C)

--braidClosure is currently the only useful way of defining a link.  
--I think it should be clear from the examples below how to use it.
--(Remember to use {}, not () or [])
braidClosure = L ->(
     K=new Link;
     K#braid=L;
     K)

--This defines all links of 7 or fewer crossings by a braid closure.
K01=braidClosure {1};
K31=braidClosure {1,1,1};
K41=braidClosure {1,-2,1,-2};
K51=braidClosure {1,1,1,1,1};
--Warning: early versions of this program included the wrong braid representation for 5_2 (missing the first -1). Scott.
K52=braidClosure {-1,-1,-1,-2,1,-2};
K61=braidClosure {1,1,2,-1,-3,2,-3};
K62=braidClosure {-1,-1,-1,2,-1,2};
K63=braidClosure {-1,-1,2,-1,2,2};
K71=braidClosure {-1,-1,-1,-1,-1,-1,-1}
K72=braidClosure {-1,-1,-1,-2,1,-2,-3,2,-3}
K73=braidClosure {1,1,1,1,1,2,-1,2}
K74=braidClosure {1,1,2,-1,2,2,3,-2,3}
K75=braidClosure {-1,-1,-1,-1,-2,1,-2,-2}
K76=braidClosure {-1,-1,2,-1,-3,2,-3}
K77=braidClosure {1,-2,1,-2,3,-2,3}

--This outputs a List of complexes, one in each Hochschild degree.
--The homology of these complexes is actual KR homology.  Mostly this function
--just feeds into others.
KR = K -> (
     if K#?KR then return K#KR else (
     	  if not K#?braid then error "no braid representation" else (
     	       Kb=K#braid;
	       P=K#nbcross=#Kb;
     	       Ka=apply(Kb,abs);
     	       Kt=apply(Kb,i->(i>0));
     	       Ks=sort Ka;
     	       --error Ks;
     	       bind=K#bindex=last(Ks)+1;
     	       R=QQ[vars(1 .. 2*P+bind)];
     	       Kmod = chainComplex( gradedModule(R^1));
     	       Cvars=new MutableList from toList (0..bind);
      	       --error Cvars#3;
     	       for I from 0 to P-1 do (
	  	    Kmod=Kmod**KhMods(Cvars#(Ka_I)-1,Cvars#(Ka_I+1)-1,bind+2*I,R,Kt_I);
	  	    Cvars#(Ka_I)=bind+2*I+1;
	  	    Cvars#(Ka_I+1)=bind+2*I+2;
	  	    );
               Ml=toList (1..bind);
     	       M=matrix {apply(Ml, I-> R_(Cvars#I-1)-R_(I-1))};
     	       K#KR=Torify(Kmod,M);
	       return K#KR)
       	  )
     )

--this function just makes the modules used in the complex above.
KhMods = (H,I,J,S,W) -> (
          Mp=S^1/ideal(S_H+S_I-S_J-S_(J+1),S_H*S_I-S_J*S_(J+1));
	  Np=S^{-1}/ideal(S_H-S_J,S_I-S_(J+1));
	  Mn=S^{1}/ideal(S_H+S_I-S_J-S_(J+1),S_H*S_I-S_J*S_(J+1));
	  Nn=S^{1}/ideal(S_H-S_J,S_I-S_(J+1));
	  if W then C=chainComplex(map(Mp,Np,(S_J-S_I))) else C=chainComplex(map(Nn,Mn))[1];
	  C)

--these extend Macaulay2's ability to take tensor products and induced maps.
ChainComplex ** Matrix := ChainComplexMap => (C,f) ->(
     map(C ** target f,C** source f,i -> id_(C_i)**f))

RingMap ** GradedModule := GradedModule => (f,C) -> (
     D := new GradedModule;
     D#ring= target f;
     scan(spots C, i->D#i=f**C#i);
     D) 

inducedchainMap = (C,D,f) -> (
     map(
	  C,D,i->inducedMap(C_i,D_i)
	  )
     )

--This has input a chain complex C and output a list of the complexes
--Tor^i(C,coker M), provided M is a regular sequence.
Torify = (C,M) -> (
     J:=rank source M;
     L:=(0..J);
     Lt=apply(L,I->(
	  F:=koszul(I,M);
	  G:=koszul(I+1,M);
	  FB=C**F;
	  GB=C**G;
	  CB=source FB;
     	  --error CB==target GB;
	  H=inducedchainMap(ker FB,image GB,id_CB);
	  --error H;
	  E=coker H;
	  E));
     Lt)

--input, a link.  output, KR homology (as modules).  this is less useful than you think, just because of the difficulty of reading the output.
KRHom = K -> (
     if K#?KRHom then N:=K#KRHom else (
     	  L:=KR(K);
     	  M:=apply(L,homology);
     	  N:=apply(M,prune);
	  K#KRHom=N;
	  );
     stack(apply(N,net)))

--This sends a chain complex to the list of degrees for which Macaulay2 remembers a module in it.
spots = C -> select(keys C, i -> class i === ZZ)

degrees(GradedModule) := Function => C -> (
     i -> degrees C_i)

--input, a knot K. output ((1-t)/(1+q*t))*(the graded Hilbert 
--polynomial of K).  THIS CURRENTLY ONLY WORKS FOR KNOTS, NOT LINKS.
KRpoly = K -> (
     if K#?KRpoly then return K#KRpoly;
     if not K#?KRHom then KRHom(K);
     L:=K#KRHom;
     R:=ring L_0;
     Rn:=#generators R;
     S:=QQ[t];
     f=map(S,R,apply(toList (1..Rn),i->t));
     M:=apply(L, C -> f**C);
     N:=apply(M,degrees);
     K#KRdeg=N;
     Pring=QQ[q,s,t,Inverses=>true];
     spoM:=sort (spots M_0);
     P:=sum(apply(toList (0..#M-1), i-> (
		    q^i*sum(apply(spoM, j-> (
				   s^j*sum(apply(flatten N_i j, k->t^k))
				   )
			 ))
	       )
	)); 
     K#KRpoly=P;
     P//(q*t+1))
     
KRdisp =K -> (
     if not K#?KRdeg then KRpoly K;
     N=K#KRdeg;
     spoM=spots K#KRHom_0;
     net P || "  " || ( "  " || stack apply(spoM, net)) | "  " | horizontalJoin between("  ", apply(
	       toList (0..#M-1),i-> net i || stack(
		    apply(
			 spoM,j->net(flatten(N_i j))
			 )
		    )
	       )
	  )
     )