Printable Manual

From Knot Atlas

Jump to: navigation, search


Download / Setup
Download / Setup

This manual describes the Mathematica package KnotTheory`, the main tool used to produce The Knot Atlas.

Return to the wiki manual.

Contents

Acknowledgement

This Atlas is partially (and indirectly) supported by NSERC grant RGPIN 262178. As a Wiki project, it doesn't make sense anymore to acknowledge individual contributors. Yet for historical purposes, here's our acknowledgement as of the conversion to Wiki formnat on August 2005:

Setup

Start by downloading either the file KnotTheory.tar.gz or the file KnotTheory.zip (around 3MB each), and unpack either one. This will create a subdirectory KnotTheory/ in your current working directory. This done, no installation is required (though you may wish to check out Further Data Files and/or Setting the Path below). Start Mathematica and you're ready to go:

In[1]:= << KnotTheory`

Loading KnotTheory` version of July 7, 2007, 9:53:56.5473. Read more at http://katlas.org/wiki/KnotTheory.

Notice the little "prime" at the end of KnotTheory above. It is a backquote (find it on the upper left side of most keyboards) and not a quote, and it really has to be there for things to work.

Let us check that everything is working well:

In[2]:= Alexander[Knot[6, 2]][t]
Out[2]= -2 3 2 -3 - t + - + 3 t - t t
In[3]:= ?KnotTheoryVersion
KnotTheoryVersion[] returns the date of the current version of the package KnotTheory`. KnotTheoryVersion[k] returns the kth field in KnotTheoryVersion[].
In[4]:= ?KnotTheoryVersionString
KnotTheoryVersionString[] returns a string containing the date and time of the current version of the package KnotTheory`. It is generated from KnotTheoryVersion[].
In[5]:= ?KnotTheoryWelcomeMessage
KnotTheoryWelcomeMessage[] returns a string containing the welcome message printed when KnotTheory` is first loaded.

Thus on the day this manual page was last changed, we had:

In[6]:= {KnotTheoryVersion[], KnotTheoryVersionString[]}
Out[6]= {{2007, 7, 7, 9, 53, 56.5473}, July 7, 2007, 9:53:56.5473}
In[7]:= KnotTheoryWelcomeMessage[]
Out[7]= Loading KnotTheory` version of July 7, 2007, 9:53:56.5473. Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.
In[8]:= ?KnotTheoryDirectory
KnotTheoryDirectory[] returns the best guess KnotTheory` has for its location on the host computer. It can be reset by the user.
In[9]:= KnotTheoryDirectory[]
Out[9]= C:\drorbn\projects\KnotTheory\svn\trunk\KnotTheory

KnotTheoryDirectory may not work under some operating systems/environments. Please let Dror know if you encounter any difficulties.

Notes

Precomputed Data

KnotTheory` comes with a certain amount of precomputed data which is loaded "on demand" just when it is needed. When a precomputed data file is read by KnotTheory`, a notification message is displayed. To prevent these messages from appearing execute the command Off[KnotTheory::loading].

Further Data Files

To access the Hoste-Thistlethwaite enumeration of knots with 12 to 16 crossings (see Naming and Enumeration), also download either the file DTCodes4Knots12To16.tar.gz or the file DTCodes4Knots12To16.zip (about 9MB each), and unpack either one into the directory KnotTheory/.

Setting the Path

The directions above are written on the assumption that the package KnotTheory` (more precisely, the directory KnotTheory/ containing the files that make this package), is somewhere on your Mathematica search path. Usually this will be the case if KnotTheory/ is a subdirectory of your current working directory. If for some reason Mathematica cannot find KnotTheory`, you may tell it where to look in either of the following three ways. Assume KnotTheory/ is a subdirectory of FullPathToKnotTheory:

  1. If you are using KnotTheory` rarely and you don't want to change system defaults, evaluate AppendTo[$Path,"FullPathToKnotTheory"] within Mathematica before attempting to load KnotTheory`.
  2. If you plan to use KnotTheory` often, you may want to move the directory KnotTheory/ into one of the directories on your path. Evaluate $Path within Mathematica to see what those are.
  3. Alternatively, you may permanently add FullPathToKnotTheory to your $Path. To do that, find your Mathematica base directory by evaluating $BaseDirectory (on Dror's laptop, this comes out to be C:\ProgramData\Mathematica), and then add the line AppendTo[$Path,"FullPathToKnotTheory/"] to the file $BaseDirectory/Kernel/init.m and restart Mathematica.

Naming and Enumeration

KnotTheory` comes loaded with some knot tables; currently, the Rolfsen table of prime knots with up to 10 crossings [Rolfsen], the Hoste-Thistlethwaite tables of prime knots with up to 16 crossings and the Thistlethwaite table of prime links with up to 11 crossings (see Knotscape):

(For In[1] see Setup)

In[2]:= ?Knot
Knot[n, k] denotes the kth knot with n crossings in the Rolfsen table. Knot[n, Alternating, k] (for n between 11 and 16) denotes the kth alternating n-crossing knot in the Hoste-Thistlethwaite table. Knot[n, NonAlternating, k] denotes the kth non alternating n-crossing knot in the Hoste-Thistlethwaite table.
In[3]:= ?Link
Link[n, Alternating, k] denotes the kth alternating n-crossing link in the Thistlethwaite table. Link[n, NonAlternating, k] denotes the kth non alternating n-crossing link in the Thistlethwaite table.
6_1
6_1
9_46
9_46

Thus, for example, let us verify that the knots 6_1 and 9_46 have the same Alexander polynomial:

In[4]:= Alexander[Knot[6, 1]][t]
Out[4]= 2 5 - - - 2 t t
In[5]:= Alexander[Knot[9, 46]][t]
Out[5]= 2 5 - - - 2 t t
L6a4
L6a4

We can also check that the Borromean rings, L6a4 in the Thistlethwaite table, is a 3-component link:

In[6]:= Length[Skeleton[Link[6, Alternating, 4]]]
Out[6]= 3
In[7]:= ?AllKnots
AllKnots[] return a list of all knots with up to 11 crossings. AllKnots[n_] returns a list of all knots with n crossings, up to 16. AllKnots[{n_,m_}] returns a list of all knots with between n and m crossings, and AllKnots[n_,Alternating|NonAlternating] returns all knots with n crossings of the specified type.
In[8]:= ?AllLinks
AllLinks[] return a list of all links with up to 11 crossings. AllLinks[n_] returns a list of all links with n crossings, up to 12.

Thus at the moment there are 1701936 knots and 5700 links known to KnotTheory`:

In[9]:= Length /@ {AllKnots[{0,16}], AllLinks[{2,12}]}
Out[9]= {1701936, 5700}
In[10]:= Show[DrawPD[Knot[13, NonAlternating, 5016], {Gap -> 0.025}]]
Image:Naming_and_Enumeration_Out_10.gif
Out[10]= -Graphics-

(Shumakovitch had noticed that this nice knot has interesting Khovanov homology; see [Shumakovitch]).

T(5,3)
T(5,3)

In addition to the tables, KnotTheory` also knows about torus knots:

In[11]:= ?TorusKnot
TorusKnot[m, n] represents the (m,n) torus knot.
In[12]:= ?TorusKnots
TorusKnots[n_] returns a list of all torus knots with up to n crossings.

For example, the torus knots T(5,3) and T(3,5) have different presentations with different numbers of crossings, but they are in fact isotopic, and hence they have the same invariants (and in particular the same type 3 Vassiliev invariant V3):

In[13]:= Crossings /@ {TorusKnot[5, 3], TorusKnot[3, 5]}
Out[13]= {10, 12}
In[14]:= Vassiliev[3] /@ {TorusKnot[5, 3], TorusKnot[3, 5]}
Out[14]= {20, 20}

KnotTheory` knows how to plot torus knots; see Drawing with TubePlot.

You can also use the function Knot to parse certain string representations of named knots:

In[15]:= Knot /@ {"K11a14", "11a_14", "L8a1", "T(3,5)"}
Out[15]= {Knot[11, Alternating, 14], Knot[11, Alternating, 14], Link[8, Alternating, 1], TorusKnot[3, 5]}

In the opposite direction, the function NameString produces the standard name for a knot, used throughout the Knot Atlas.

In[16]:= NameString /@ {Knot[11, Alternating, 14], TorusKnot[3,5]}
Out[16]= {K11a14, T(3,5)}

References

[Rolfsen] ^  D. Rolfsen, Knots and Links, Publish or Perish, Mathematics Lecture Series 7, Wilmington 1976.

[Shumakovitch] ^  A. Shumakovitch, Torsion of the Khovanov Homology, arXiv:math.GT/0405474.

Presentations

KnotTheory` uses several presentations for knots/links.

Planar Diagrams

The PD notation
The PD notation

In the "Planar Diagrams" (PD) presentation we present every knot or link diagram by labeling its edges (with natural numbers, 1,...,n, and with increasing labels as we go around each component) and by a list crossings presented as symbols Xijkl where i, j, k and l are the labels of the edges around that crossing, starting from the incoming lower edge and proceeding counterclockwise. Thus for example, the PD presentation of the knot above is:

X1928X3,10,4,11X5362X7,1,8,12X9,4,10,5X11,7,12,6.

(This of course is the Miller Institute knot, the mirror image of the knot 6_2)

(For In[1] see Setup)

In[1]:= ?PD
PD[v1, v2, ...] represents a planar diagram whose vertices are v1, v2, .... PD also acts as a "type caster", so for example, PD[K] where K is is a named knot (or link) returns the PD presentation of that knot.
In[2]:= PD::about
The PD to GaussCode and to MorseLink conversions were written by Siddarth Sankaran at the University of Toronto in the summer of 2005.
In[3]:= ?X
X[i,j,k,l] represents a crossing between the edges labeled i, j, k and l starting from the incoming lower strand i and going counterclockwise through j, k and l. The (sometimes ambiguous) orientation of the upper strand is determined by the ordering of {j,l}.

Thus, for example, let us compute the determinant of the above knot:

In[4]:= K = PD[ X[1,9,2,8], X[3,10,4,11], X[5,3,6,2], X[7,1,8,12], X[9,4,10,5], X[11,7,12,6] ];
In[5]:= Alexander[K][-1]
Out[5]= -11

Some further details

In[6]:= ?Xp
Xp[i,j,k,l] represents a positive (right handed) crossing between the edges labeled i, j, k and l starting from the incoming lower strand i and going counter clockwise through j, k and l. The upper strand is therefore oriented from l to j regardless of the ordering of {j,l}. Presently Xp is only lightly supported.
In[7]:= ?Xm
Xm[i,j,k,l] represents a negative (left handed) crossing between the edges labeled i, j, k and l starting from the incoming lower strand i and going counter clockwise through j, k and l. The upper strand is therefore oriented from j to l regardless of the ordering of {j,l}. Presently Xm is only lightly supported.
In[8]:= ?P
P[i,j] represents a bivalent vertex whose adjacent edges are i and j (i.e., a "Point" between the segment i and the segment j). Presently P is only lightly supported.

For example, we could add an extra "point" on the Miller Institute knot, splitting edge 12 into two pieces, labeled 12 and 13:

In[9]:= K1 = PD[ X[1,9,2,8], X[3,10,4,11], X[5,3,6,2], X[7,1,8,13], X[9,4,10,5], X[11,7,12,6], P[12,13] ];

At the moment, many of our routines do not know to ignore such "extra points". But some do:

In[10]:= Jones[K][q] == Jones[K1][q]
Out[10]= True
In[11]:= ?Loop
Loop[i] represents a crossingsless loop labeled i.

Hence we can verify that the A2 invariant of the unknot is q−2 + 1 + q2:

In[12]:= A2Invariant[Loop[1]][q]
Out[12]= -2 2 1 + q + q

Gauss Codes

The Gauss Code of an n-crossing knot or link L is obtained as follows:

  • Number the crossings of L from 1 to n in an arbitrary manner.
  • Order the components of L is some arbitrary manner.
  • Start "walking" along the first component of L, taking note of the numbers of the crossings you've gone through. If in a given crossing crossing you cross on the "over" strand, write down the number of that crossing. If you cross on the "under" strand, write down the negative of the number of that crossing.
  • Do the same for all other components of L (if any).

The resulting list of signed integers (in the case of a knot) or list of lists of signed integers (in the case of a link) is called the Gauss Code of L. KnotTheory` has some rudimentary support for Gauss codes:

(For In[1] see Setup)

In[1]:= ?GaussCode
GaussCode[i1, i2, ...] represents a knot via its Gauss Code following the conventions used by the knotilus website, http://srankin.math.uwo.ca/cgi-bin/retrieve.cgi/html/start.html. Likewise GaussCode[l1, l2, ...] represents a link, where each of l1, l2,... is a list describing the code read along one component of the link. GaussCode also acts as a "type caster", so for example, GaussCode[K] where K is is a named knot (or link) returns the Gauss code of that knot.

Thus for example, the Gauss codes for the trefoil knot and the Borromean link are:

In[2]:= GaussCode /@ {Knot[3, 1], Link[6, Alternating, 4]}
Out[2]= {GaussCode[-1, 3, -2, 1, -3, 2], GaussCode[{1, -6, 5, -3}, {4, -1, 2, -5}, {6, -4, 3, -2}]}
3_1
3_1
L6a4
L6a4

Ralph Furmaniak, working under the guidance of Stuart Rankin and Ortho Flint at the University of Western Ontario, wrote a web-based server called "Knotilus" that takes Gauss codes and outputs pictures of the desired knots and links in several standard image formats.

In[3]:= ?KnotilusURL
KnotilusURL[K_] returns the URL of the knot/link K on the knotilus website, http://srankin.math.uwo.ca/cgi-bin/retrieve.cgi/html/start.html.

Thus,

In[4]:= KnotilusURL /@ {Knot[3, 1], Link[6, Alternating, 4]}
Out[4]= {http://srankin.math.uwo.ca/cgi-bin/retrieve.cgi/-1,3,-2,1,-3,2/goTop.h\ tml, http://srankin.math.uwo.ca/cgi-bin/retrieve.cgi/1,-6,5,-3:4,-1,\ 2,-5:6,-4,3,-2/goTop.html}

DT (Dowker-Thistlethwaite) Codes

Knots

The "DT Code" ("DT" after Clifford Hugh Dowker and Morwen Thistlethwaite) of a knot K is obtained as follows:

  • Start "walking" along K and count every crossing you pass through. If K has n crossings and given that every crossing is visited twice, the count ends at 2n. Label each crossing with the values of the counter when it is visited, though when labeling by an even number, take it with a minus sign if you are walking "over" the crossing.
  • Every crossing is now labeled with two integers whose absolute values run from 1 to 2n. It is easy to see that each crossing is labeled with one odd integer and one even integer. The DT code of K is the list of even integers paired with the odd integers 1, 3, 5, ..., taken in this order. Thus for example the pairing for the knot in the figure below is ((1,−8),(3,−10),(5,−2),(7,−12),(9,−4),(11,−6)), and hence its DT code is (−8,−10,−2,−12,−4,−6) (and as DT codes are insensitive to overall mirrors, this is equivalent to (8,10,2,12,4,6)).
The DT notation
The DT notation

KnotTheory` has some rudimentary support for DT codes:

(For In[1] see Setup)

In[2]:= ?DTCode
DTCode[i1, i2, ...] represents a knot via its DT (Dowker-Thistlethwaite) code, while DTCode[{i11,...}, {i21...}, ...] likewise represents a link. DTCode also acts as a "type caster", so for example, DTCode[K] where K is is a named knot or link returns the DT code of K.

Thus for example, the DT codes for the last 9 crossing alternating knot 9_41 and the first 9 crossing non alternating knot 9_42 are:

In[3]:= dts = DTCode /@ {Knot[9, 41], Knot[9, 42]}
Out[3]= {DTCode[6, 10, 14, 12, 16, 2, 18, 4, 8], DTCode[4, 8, 10, -14, 2, -16, -18, -6, -12]}

(The DT code of an alternating knot is always a sequence of positive numbers but the DT code of a non alternating knot contains both signs.)

9_41
9_41
9_42
9_42

DT codes and Gauss codes carry the same information and are easily convertible:

In[4]:= gcs = GaussCode /@ dts
Out[4]= {GaussCode[1, -6, 2, -8, 3, -1, 4, -9, 5, -2, 6, -4, 7, -3, 8, -5, 9, -7], GaussCode[1, -5, 2, -1, 3, 8, -4, -2, 5, -3, -6, 9, -7, 4, -8, 6, -9, 7]}
In[5]:= DTCode /@ gcs
Out[5]= {DTCode[6, 10, 14, 12, 16, 2, 18, 4, 8], DTCode[4, 8, 10, -14, 2, -16, -18, -6, -12]}

Conversion between DT codes and/or Gauss codes and PD codes is more complicated; the harder side, going from DT/Gauss to PD, was written by Siddarth Sankaran at the University of Toronto:

In[6]:= PD[DTCode[4, 6, 2]]
Out[6]= PD[X[4, 2, 5, 1], X[6, 4, 1, 3], X[2, 6, 3, 5]]

Links

A DT notation example, for the link L7n2
A DT notation example, for the link L7n2

DT Codes for links are defined in a similar way (see [DollHoste]). Follow the same numbering process as for knots, except when you finish traversing one component, jump straight to the next. It is not difficult to see that there is always a choice of starting points along the components for which the resulting pairing is a pairing between odd and even numbers. (On the figure above one possible choice is indicated). Again, it is enough to only list the even numbers corresponding to 1, 3, 5, \ldots; call the resulting list λ. (Above, λ = (6,−8,−10,12,−14,2,−4)). Notice that the odd indices are naturally subdivided into sublists according to the component of the link on which they lie, and this induces a subdivision of λ into sublists. Thus with the choices made in the figure above, the DT code for the link L7n2 is (6,-8\mid -10,12,-14,2,-4).

KnotTheory` knows about DT codes for links:

In[7]:= DTCode[Link[7, NonAlternating, 2]]
Out[7]= DTCode[{6, -8}, {-10, 12, -14, 2, -4}]
In[8]:= MultivariableAlexander[DTCode[{6, -8}, {-10, 12, -14, 2, -4}]][t]
Out[8]= -1 + t[1] + t[2] - t[1] t[2]

[DollHoste] ^  H. Doll and J. Hoste, A tabulation of oriented links, Mathematics of Computation 57-196 (1991) 747-761.

Braid Representatives

Every knot and every link is the closure of a braid. KnotTheory` can also represent knots and links as braid closures:

(For In[1] see Setup)

In[1]:= ?BR
BR stands for Braid Representative. BR[k,l] represents a braid on k strands with crossings l={i1,i2,...}, where a positive index i within the list l indicates a right-handed crossing between strand number i and strand number i+1 and a negative i indicates a left handed crossing between strands numbers |i| and |i|+1. Each ij can also be a list of non-adjacent (i.e., commuting) indices. BR also acts as a "type caster": BR[K] will return a braid whose closure is K if K is given in any format that KnotTheory` understands. BR[K] where K is is a named knot with up to 10 crossings returns a minimum braid representative for that knot.
In[2]:= BR::about
The minimum braids representing the knots with up to 10 crossings were provided by Thomas Gittings. See his article on the subject at arXiv:math.GT/0401051. Vogel's algorithm was implemented by Dan Carney in the summer of 2005 at the University of Toronto.
In[3]:= ?Mirror
Mirror[br] return the mirror braid of br.

Thus for example,

In[4]:= br1 = BR[2, {-1, -1, -1}];


In[5]:= PD[br1]
Out[5]= PD[X[6, 3, 1, 4], X[4, 1, 5, 2], X[2, 5, 3, 6]]
In[6]:= Jones[br1][q]
Out[6]= -4 -3 1 -q + q + - q
In[7]:= Mirror[br1]
Out[7]= BR[2, {1, 1, 1}]
T(5,4)
T(5,4)
K11a362
K11a362

KnotTheory` has the braid representatives of some knots and links pre-loaded, and for all other knots and links it will find a braid representative using Vogel's algorithm. Thus for example,

In[8]:= BR[TorusKnot[5, 4]]
Out[8]= BR[4, {1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}]
In[9]:= BR[Knot[11, Alternating, 362]]
Out[9]= BR[10, {1, 2, -3, -4, 5, 6, 5, 4, 3, -2, -1, -4, 3, -2, -4, 3, 5, 4, -6, 7, -6, 5, 8, 7, 6, 5, -4, -3, 2, 5, -6, 9, -8, 7, -6, 5, 4, -3, 5, 6, 5, 4, 5, -7, 8, -7, 6, 5, -9, -8, -7}]

(As we see, Vogel's algorithm sometimes produces scary results. A 51-crossings braid representative for an 11-crossing knot, in the case of K11a362).

10_1
10_1
5_2
5_2

The minimum braid representative of a given knot is a braid representative for that knot which has a minimal number of braid crossings and within those braid representatives with a minimal number of braid crossings, it has a minimal number of strands (full details are in [Gittings]). Thomas Gittings kindly provided us the minimum braid representatives for all knots with up to 10 crossings. Thus for example, the minimum braid representative for the knot 10_1 has length (number of crossings) 13 and width 6 (number of strands, also see Invariants from Braid Theory):

In[10]:= br2 = BR[Knot[10, 1]]
Out[10]= BR[6, {-1, -1, -2, 1, -2, -3, 2, -3, -4, 3, 5, -4, 5}]
In[12]:= Show[BraidPlot[CollapseBraid[br2]]]
Image:Braid_Representatives_Out_11.gif
Out[12]= -Graphics-

Already for the knot 5_2 the minimum braid is shorter than the braid produced by Vogel's algorithm. Indeed, the minimum braid is

In[14]:= Show[BraidPlot[CollapseBraid[BR[Knot[5, 2]]]]]
Image:Braid_Representatives_Out_13.gif
Out[14]= -Graphics-

To force KnotTheory` to run Vogel's algorithm on 5_2, we first convert it to its PD form,

In[15]:= pd = PD[Knot[5, 2]]
Out[15]= PD[X[1, 4, 2, 5], X[3, 8, 4, 9], X[5, 10, 6, 1], X[9, 6, 10, 7], X[7, 2, 8, 3]]

and only then run BR:

In[17]:= Show[BraidPlot[CollapseBraid[BR[pd]]]]
Image:Braid_Representatives_Out_16.gif
Out[17]= -Graphics-

(Check Drawing Braids for information about the command BraidPlot and the related command CollapseBraid.)

[Gittings] ^  T. A. Gittings, Minimum braids: a complete invariant of knots and links, arXiv:math.GT/0401051.

MorseLink Presentations

The MorseLink presentation describes an oriented knot or link diagram as a sequence of 'events'. To begin, we fix an axis in the plane, so that each event in the MorseLink description occurs in successive intervals along this axis. The 'events' that comprise a knot or link are 'cups' (creations), 'caps' (annihilations), and crossings, where cups and caps are the minima and maxima (respectively) relative to the chosen axis. The conventions used by MorseLink are as follows:

  • Cup[m,n] represents a creation, where the new strands are in position m and n, with m and n differing by 1, and is directed from m to n.
  • Cap[m,n] represents an annihilation of the strands m and n, again with m and n differing by 1, and is directed from m to n.
  • X[n, d, a, b] is a crossing of the n-th and the (n+1)-th strands. 'd' signifies whether the n-th strand goes 'Over' or 'Under' the (n+1)-th strand. 'a' indicates whether the n-th strand is moving 'Up' or 'Down' through the crossing, relative to the chosen axis; 'b' does the same for the (n+1)-th strand.

For concreteness, let us find a MorseLink presentation of the knot 4_1, based on the following diagram:

A diagram of the knot 4_1
A diagram of the knot 4_1

We fix the chosen axis to be the positive x axis, and we number the strands at each interval from bottom to top. Clearly the first event to take place is a cup, creating strands 1 and 2, and directed from 1 to 2. The next event is also a cup; this time, the strands 3 and 4 are created, from 3 to 4. So the first two elements of our MorseLink presentation are {Cup[1,2], Cup[3,4], ...}.

A crossing event
The next event to take place is a crossing. This crossing has strand 2 going under strand 3; following the orientations, strand 2 moves to the right through the crossing, while strand 3 comes from the left. Since the chosen axis is pointing to the right, this event is described as X[2, Under, Up, Down]. We may proceed in a similar way for the rest of the crossings.


Two cap events
After three more crossings, we encounter two cap events. The first annihilates strands 2 and 3, and is directed from 2 to 3. The second annihilates strands 1 and 2, but is directed from 2 to 1. So the MorseLink presentation for the knot 4_1 is given by: MorseLink[Cup[1,2], Cup[3,4], X[2 , Under, Up, Down], X[2, Under, Down, Up], X[1, Over, Down, Up], X[1, Over, Up, Down], Cap[2,3], Cap[2,1]].

Further notes

KnotTheory` knows about Morse link presentations: (For In[1] see Setup)

In[2]:= ?MorseLink
MorseLink[K] returns a presentation of the oriented link K, composed, in successive order, of the following 'events': Cup[m,n] is a directed creation, starting at strand position n, towards position m, where m and n differ by 1. X[n,a = {Over/Under}, b = {Up/Down}, c={Up/Down}] is a crossing with lower-left edge at strand n, a determines whether the strand running bottom-left to top-right is over/under the crossing, b and c give the directions of the bottom-left and bottom-right strands respectively through the crossing. Cap[m,n] is a directed cap, from strand m to strand n.
In[3]:= MorseLink::about
MorseLink was added to KnotTheory` by Siddarth Sankaran at the University of Toronto in the summer of 2005.
  • Obviously, there is no unique Morse link presentation for a knot. One presentation may be considered 'better' than another if it generally has fewer strands. Unfortunately, this program makes only a half-hearted attempt in coming up with such presentations; it does a creation only when it can no longer do any caps or crossings, but exhibits a lack of foresight into which edges to create.

Arc Presentations

An Arc Presentation A of a knot K (in "grid form", to be precise) is a planar (toroidal, to be precise) picture of the knot in which all arcs are either horizontal or vertical, in which the vertical arcs are always "above" the horizontal arcs, and in which no two horizontal arcs have the same y-coordinate and no two vertical arcs have the same x-coordinate (read more at [1]). Without loss of generality, the x-coordinates of the vertical arcs in A are the integers 1 through n for some n, and the y-coordinates of the horizontal arcs in A are (also!) the integers 1 through n.

((5,2), (1,3), (2,4), (3,5), (4,1))
((5,2), (1,3), (2,4), (3,5), (4,1))

Thus for example, on the left is an arc presentation A of the trefoil knot. It can be represented numerically by the sequence of ordered pairs shown below it. This sequence reads: the lowest horizontal arc in A connects the 5th vertical arc with the 2nd; the next horizontal arc in A connects the 1st vertical with the 3rd, and so on. In general, an arc presentation involving n horizontal and n vertical arcs will be described in this way by a sequence of n ordered pairs of integers in the range between 1 and n.

Arc presentations are used extensively in the computation of Heegaard Floer Knot Homologies.


KnotTheory` knows about arc presentations:

(For In[1] see Setup)

In[1]:= ?ArcPresentation
ArcPresentation[{a1,b1}, {a2, b2}, ..., {an,bn}] is an arc presentation of a knot (as often used in the realm of Heegaard-Floer homologies), where the horizontal arc at row i connects column ai to column bi. ArcPresentation[K] returns an arc presentation of the knot K. ArcPresentation[K, Reduce -> r] attemps at most r reduction steps (using a naive reduction algorithm) following a naive creation of some arc presentation for K.
K11n11
K11n11
In[2]:= ap = ArcPresentation["K11n11"]
Out[2]= ArcPresentation[{12, 2}, {1, 10}, {3, 9}, {5, 11}, {9, 12}, {4, 8}, {2, 5}, {11, 7}, {8, 6}, {7, 4}, {10, 3}, {6, 1}]
In[4]:= Draw[ap]
Image:Arc_Presentations_Out_3.gif
Out[4]= -Graphics-
In[5]:= ap0 = ArcPresentation["K11n11", Reduce -> 0]
Out[5]= ArcPresentation[{13, 19}, {20, 23}, {19, 22}, {15, 14}, {14, 2}, {1, 13}, {3, 12}, {2, 4}, {16, 18}, {17, 15}, {8, 16}, {12, 17}, {5, 7}, {4, 6}, {7, 11}, {6, 8}, {18, 10}, {11, 9}, {10, 21}, {9, 20}, {21, 5}, {22, 3}, {23, 1}]
In[6]:= ?Draw
Draw[ap] draws the Arc Presentation ap. Draw[ap, OverlayMatrix -> M] overlays the matrix M on top of that draw.
In[8]:= Draw[ap0]
Image:Arc_Presentations_Out_7.gif
Out[8]= -Graphics-
In[9]:= Reflect[ap_ArcPresentation] := ArcPresentation @@ ( (Last /@ Sort[Reverse /@ Position[ap, #]]) & /@ Range[Length[ap]] )
In[11]:= Reflect[ap] // Draw
Image:Arc_Presentations_Out_10.gif
Out[11]= -Graphics-

The Minesweeper Matrix MA (name not generally accepted) of an arc presentation A of n rows/columns is the n\times n matrix whose (ij) entry is the rotation number of A around a point placed between the i and i + 1 rows of A and between the j and j + 1 column of A. Here's a little program to compute the minesweeper matrix of a given arc presentation, along with its output on the arc presentation of K11n11 that we have been studying above:

In[12]:= MinesweeperMatrix[ap_ArcPresentation] := Module[ {l, CurrentRow, c1, c2, k, s}, l = Length[ap]; CurrentRow = Table[0, {l}]; Table[ {c1, c2} = Sort[ap[[k]]]; s = Sign[{-1, 1}.ap[[k]]]; Do[ CurrentRow[[c]] += s, {c, c1, c2 - 1} ]; CurrentRow, {k, l} ] ];
In[14]:= Draw[ap, OverlayMatrix -> MinesweeperMatrix[ap]]
Image:Arc_Presentations_Out_13.gif
Out[14]= -Graphics-

If MA = (mij), it is known that the determinant of the matrix (t^{m_{ij}}) is the Alexander polynomial of the knot presented by A, up to signs and powers of t and (t−1). Let us check this in our case:

In[15]:= {Det[t^MinesweeperMatrix[ap]], Alexander[ap][t]} // Factor
Out[15]= 11 2 2 3 4 5 6 {(-1 + t) t (1 - 5 t + 13 t - 17 t + 13 t - 5 t + t ), 2 3 4 5 6 1 - 5 t + 13 t - 17 t + 13 t - 5 t + t -------------------------------------------} 3 t

Conway Notation

Conway notation and KnotTheory`

KnotTheory` understands the Conway notation for knots and links (see [Conway] and down below), although the conversion between Conway notation and other knot presentations known to KnotTheory` (a necessary first step for using most of the KnotTheory` functionality) requires the packages K2K (KNOT 2000, by M.Ochiai and N.Imafuji) and LinKnot (by S. Jablan and R. Sazdanovic). For the download and installation of the LinKnot package see Using the LinKnot package.

(For In[1] see Setup)

As in the section Using the LinKnot package, the first step is to add LinKnot to the Mathematica search path. This path will likely be different on your computer. (Note that you can also use Conway notations in KnotTheory` if you are using KnotTheory` and LinKnot "in parallel", as described in Using the LinKnot package.)

In[2]:= AppendTo[$Path, "C:/bin/LinKnot/"];
In[3]:= ?ConwayNotation
ConwayNotation[s] represents the knot or link whose Conway notation is the string s. ConwayNotation[K], where K is a knot or a link with up to 12 crossings, returns ConwayNotation[s], where s is a string containing the Conway notation of K.
In[4]:= ConwayNotation::about
The program ConwayNotation relies on code from the LinKnot package by Slavik Jablan and Ramila Sazdanovic.

A well known example of a knot with an Alexander polynomial equal to the Alexander polynomial of the unknot is the (-3,5,7)-pretzel knot K. Let us verify that, check (using the Jones polynomial) that K is not the unknot and find a (rather unattractive) braid whose closure is K:

In[6]:= DrawMorseLink[K = ConwayNotation["-3,5,7"]] // Show
Image:Conway_Notation_Out_5.gif
Out[6]= -Graphics-
In[7]:= Alexander[K][t]
Out[7]= 1
In[8]:= Jones[K][q]
Out[8]= -12 -11 -10 2 -8 -7 -5 -4 2 -2 1 q - q + q - -- + q - q + q - q + -- - q + - 9 3 q q q
In[9]:= br = BR[K]
Out[9]= BR[14, {1, 2, 3, -4, -5, -6, -7, 8, -7, 6, 5, 4, -3, -2, -1, -6, -5, -4, -3, -2, 9, 8, 7, 6, -5, 4, -3, 7, -8, -7, -9, -8, 10, 9, -8, -11, -10, 12, 11, -10, 9, -8, -13, -12, -11, 10, 9, -8, -7, 6, -5, 4, -5, -7, 8, -7, -6, -7, -9, 8, -7, 6, 5, -4, 3, 2, -6, -7, -10, -9, 11, 10, -9, 8, -7, 6, 5, -4, 3, -6, 5, 4, -6, 5, 7, 6, -7, -8, 9, 8, -7, 12, -11, 10, -9, 13, -12, 11, -10}]
In[11]:= BraidPlot[br] // Show
Image:Conway_Notation_Out_10.gif
Out[11]= -Graphics-

Some generalities about the Conway notation

Conway notation was introduced by J.H. Conway in 1967 (see [Conway]). The main building blocks for Conway notation are 4-tangles. A 4-tangle in a knot or link projection is a region in the projection plane {\mathbb R}^2 (or on the sphere S3) surrounded with a circle such that the projection intersects with the circle exactly four times. The elementary tangles are:

Image:tangle0.jpgImage:tangle1.jpg Image:tangle-1.jpg

Tangles can be combined and modified by a unary operation a\mapsto-a and three binary operations: sum, product and ramification, taking tangles a, b to new tangles a + b, a\,b and a,b. Here −a is the image of a under reflection in the NW-SE mirror line, a + b is obtained by placing a and b side by side with a on the left and b on the right. a\,b is simply (−a) + b, and finally, a,b = (−a) + (−b).

Image:033.jpgImage:ConwayRamification.jpg
Sum and product of tanglesRamification of tangles

A rational tangle is any tangle obtained from the elementary tangles using only the operation of product. A rational knot or a rational link is the numerator closure of a rational tangle. A knot or link is called algebraic if it can be obtained as the closure of a tangle obtained from rational tangles using the operations above.

Knot or links that can not be obtained in this way are called non-algebraic. They can all be obtained in the following manner: start with a basic polyhedron P, a 4-valent graph without digons, with vertices numbered 1 through n. Now substitute tangles t1 through tn into these vertices.

The Conway notation for such knots and links consists of the symbol ni^\star of a basic polyhedron P where n is the number of vertices and i is the index of P in some fixed list of basic polyhedra with n vertices, followed by the symbols for the tangles t1 through tn separated by dots.

For example, the knot 4_1 is denoted by "2 2", the knot 9_5 by "5 1 3", the link L5a1 is denoted by "2 1 2", the link L9a24 by "3 1,3,2" (all of them contain spaces between tangles), etc. A sequence of k pluses at the end of Conway symbol is denoted by +k, and the sequence of k minuses by +-k (e.g., knot 10_76 given in Conway notation as 3,3,2++ is denoted by "3,3,2+2", and the mirror of the link L9n21 whose Conway notation is 3,2,2,2-- is given by "3,2,2,2+-2"). The space is used in the same way in all other symbols.

For the basic polyhedra with N < 10 crossings the standard notation is used (.1 , 6*, 8*, 9*, where the symbol for 6* can be ommitted). For example, the knot 10_95 is denoted by ".2 1 0.2.2", and 10_101 by "2 1..2..2". For higher values of N a notation is used in which the first number is the number of crossings, and the next is the ordering number of polyhedron (e.g., 101*, 102*, 103* for N = 10 denoting 10*, 10**, 10***, respectively, and 111*, 112*, 113* for N = 11 denoting 11*, 11**, 11***, respectively, etc.).

The order of basic polyhedra for N = 12 corresponds to the list in [