Drorbn - User contributions [en]

User:Sankaran/06-1350-HW4

2006-12-12T22:04:45Z

Sankaran:

===The Generators===

Our generators are <math>T</math>, <math>R</math>, <math>\Phi</math> and <math>B^{\pm}</math>:
{| align=center cellpadding=10 style="border: solid orange 1px"
|- align=center valign=middle
|align=left|Picture
|[[Image:06-1350-T.svg|100px]]
|[[Image:06-1350-R.svg|100px]]
|[[Image:06-1350-Phi.svg|100px]]
|[[Image:06-1350-BPlus.svg|100px]]
|[[Image:06-1350-BMinus.svg|100px]]
|- align=center valign=middle
|align=left|Generator
|<math>T</math>
|<math>R</math>
|<math>\Phi</math>
|<math>B^+</math>
|<math>B^-</math>
|- align=center valign=middle
|align=left|Perturbation
|<math>t</math>
|<math>r</math>
|<math>\varphi</math>
|<math>b^+</math>
|<math>b^-</math>
|}

(Thanks [[User:Zak/06-1350-HW4|Zavosh]] for the nice picture)
===The Relations===

====The Reidemeister Move R2====
(Courtesy of Andy)

[[Image:06-1350-R2-weird.png|center]]
In formulas, this is
<center><math>1 = (123)^\star B^- (132)^\star B^+.</math></center>
Linearized and written in functional form, this becomes
{| align=center
|-
|<math>\rho_2(x_1,x_2,x_3) = - b^-(x_1,x_2,x_3) - b^+(x_1,x_3,x_2).</math>
|}

====The Reidemeister Move R3====
(Picture and first example courtesy of Dror)

There are eight of these (each crossing in the picture can be + or - ).
For example, if all the crossings are positive, the picture (with three sides of the shielding removed) is
[[Image:06-1350-R4.svg|400px|center]]
In formulas, this is
<center><math>(1230)^\star B^+ (1213)^\star B^+ (1023)^\star B^+ = (1123)^\star B^+ (1203)^\star B^+ (1231)^\star B^+</math>.</center>
Linearized and written in functional form, this becomes
{| align=center
|-
|<math>\rho_3[+++](x_1, x_2, x_3, x_4) = </math>
|<math>b^+(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + b^+(x_1,x_3,x_4)</math>
|-
|
|<math>- b^+(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_4) - b^+(x_1+x_4,x_2,x_3).</math>
|}

Here are the rest of them, linearized and in functional form - I think this is too many, but it's probably easier to write these out than to figure the relationships between them. Also, some better notation is needed.

<math>\rho_3[++-](x_1,x_2,x_3,x_4) = b^+(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + b^-(x_1,x_3,x_4)
- b^-(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_4) - b^+(x_1+x_4,x_2,x_3).</math>

<math>\rho_3[+-+](x_1,x_2,x_3,x_4) = b^+(x_1,x_2,x_3) + b^-(x_1+x_3,x_2,x_4) + b^+(x_1,x_3,x_4)- b^+(x_1+x_2,x_3,x_4) - b^-(x_1,x_2,x_4) - b^+(x_1+x_4,x_2,x_3). </math>

<math>\rho_3[-++](x_1,x_2,x_3,x_4) = b^-(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + b^+(x_1,x_3,x_4)- b^+(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_4) - b^-(x_1+x_4,x_2,x_3). </math>

<math>\rho_3[+--](x_1,x_2,x_3,x_4) = b^+(x_1,x_2,x_3) + b^-(x_1+x_3,x_2,x_4) + b^-(x_1,x_3,x_4)- b^-(x_1+x_2,x_3,x_4) - b^-(x_1,x_2,x_4) - b^+(x_1+x_4,x_2,x_3). </math>

<math>\rho_3[-+-](x_1,x_2,x_3,x_4) = b^-(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + b^-(x_1,x_3,x_4)- b^-(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_4) - b^-(x_1+x_4,x_2,x_3). </math>

<math>\rho_3[--+](x_1,x_2,x_3,x_4) = b^-(x_1,x_2,x_3) + b^-(x_1+x_3,x_2,x_4) + b^+(x_1,x_3,x_4)- b^+(x_1+x_2,x_3,x_4) - b^-(x_1,x_2,x_4) - b^-(x_1+x_4,x_2,x_3). </math>

<math>\rho_3[---](x_1,x_2,x_3,x_4) = b^-(x_1,x_2,x_3) + b^-(x_1+x_3,x_2,x_4) + b^-(x_1,x_3,x_4)- b^-(x_1+x_2,x_3,x_4) - b^-(x_1,x_2,x_4) - b^-(x_1+x_4,x_2,x_3). </math>
====The Reidemeister Move R4====
(Courtesy of Andy)

There are two (ostensibly) different versions:
[[Image:06-1350-R4a.png|center]]
In formulas, this is
<center><math>(1230)^\star B^+ (1213)^\star B^+ (1023)^\star \Phi = (1123)^\star \Phi (1233)^\star B^+</math>.</center>
Linearized and written in functional form, this becomes
{| align=center
|-
|<math>\rho_{4a}(x_1,x_2,x_3,x_4) = b^+(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + \phi(x_1,x_3,x_4) - \phi(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_3+x_4).</math>
|}

Second:
[[Image:06-1350-R4b.png|center]]
In formulas, this is
<center><math>(1123)^\star B^+ (1203)^\star B^+ (1231)^\star \Phi = (1230)^\star \Phi (1223)^\star B^+</math>.</center>
Linearized and written in functional form, this becomes
{| align=center
|-
|<math>\rho_{4b}(x_1,x_2,x_3,x_4) = b^+(x_1+x_2,x_3,x_4) + b^+(x_1,x_2,x_4) + \phi(x_1+x_4,x_2,x_3) - \phi(x_1,x_2,x_3) - b^+(x_1,x_2+x_3,x_4).</math>
|}

===The Syzygies===

====The "B around B" Syzygy====

The picture, with all shielding removed, is
{| align=center
|- align=center
|[[Image:06-1350-BAroundB.svg|center]]
|-
|align=right|(Drawn with [http://www.inkscape.org/ Inkscape]) (note that lower quality pictures are also acceptable)
|}

The functional form of this syzygy is

{| align=center
|-
|<math>BB(x_1,x_2,x_3,x_4,x_5) = </math>
|<math>\rho_3(x_1, x_2, x_3, x_5) + \rho_3(x_1 + x_5, x_2, x_3, x_4) - \rho_3(x_1 + x_2, x_3, x_4, x_5)</math>
|-
|
|<math>- \rho_3(x_1, x_2, x_4, x_5) - \rho_3(x_1 + x_4, x_2, x_3, x_5) - \rho_3(x_1, x_2, x_3, x_4)</math>
|-
|
|<math>+ \rho_3(x_1, x_3, x_4, x_5) + \rho_3(x_1 + x_3, x_2, x_4, x_5).</math>
|}

===A Mathematica Verification===

The following simulated Mathematica session proves that for our single relation and single syzygy, <math>d^2=0</math>. Copy paste it into a live Mathematica session to see that it's right!

{{In|n=1|in=<nowiki>d1 = {
rho3[x1_, x2_, x3_, x4_] :> bp[x1, x2, x3] + bp[x1 + x3, x2, x4] +
bp[x1, x3, x4] - bp[x1 + x2, x3, x4] - bp[x1, x2, x4] -
bp[x1 + x4, x2, x3]
};
d2 = {
BAroundB[x1_, x2_, x3_, x4_, x5_] :> rho3[x1, x2, x3, x5] +
rho3[x1 + x5, x2, x3, x4] - rho3[x1 + x2, x3, x4, x5] -
rho3[x1, x2, x4, x5] - rho3[x1 + x4, x2, x3, x5] -
rho3[x1, x2, x3, x4] + rho3[x1, x3, x4, x5] +
rho3[x1 + x3, x2, x4, x5]
};</nowiki>}}

{{InOut|n=3|in=<nowiki>BAroundB[x1, x2, x3, x4, x5] /. d2</nowiki>|out=<nowiki>- rho3[x1, x2, x3, x4] + rho3[x1, x2, x3, x5] - rho3[x1, x2, x4, x5]
+ rho3[x1, x3, x4, x5] - rho3[x1 + x2, x3, x4, x5]
+ rho3[x1 + x3, x2, x4, x5] - rho3[x1 + x4, x2, x3, x5]
+ rho3[x1 + x5, x2, x3, x4]</nowiki>}}

{{InOut|n=4|in=<nowiki>BAroundB[x1, x2, x3, x4, x5] /. d2 /. d1</nowiki>|out=<nowiki>0</nowiki>}}

User:Sankaran/06-1350-HW4

2006-12-12T16:05:34Z

Sankaran:

Warning - nothing new yet...

===The Generators===

Our generators are <math>T</math>, <math>R</math>, <math>\Phi</math> and <math>B^{\pm}</math>:
{| align=center cellpadding=10 style="border: solid orange 1px"
|- align=center valign=middle
|align=left|Picture
|
|
|
|[[Image:06-1350-BPlus.svg|100px]]
|
|- align=center valign=middle
|align=left|Generator
|<math>T</math>
|<math>R</math>
|<math>\Phi</math>
|<math>B^+</math>
|<math>B^-</math>
|- align=center valign=middle
|align=left|Perturbation
|<math>t</math>
|<math>r</math>
|<math>\varphi</math>
|<math>b^+</math>
|<math>b^-</math>
|}

===The Relations===

====The Reidemeister Move R3====
The picture (with three sides of the shielding removed) is
[[Image:06-1350-R4.svg|400px|center]]
In formulas, this is
<center><math>(1230)^\star B^+ (1213)^\star B^+ (1023)^\star B^+ = (1123)^\star B^+ (1203)^\star B^+ (1231)^\star B^+</math>.</center>
Linearized and written in functional form, this becomes
{| align=center
|-
|<math>\rho_3(x_1, x_2, x_3, x_4) = </math>
|<math>b^+(x_1,x_2,x_3) + b^+(x_1+x_3,x_2,x_4) + b^+(x_1,x_3,x_4)</math>
|-
|
|<math>- b^+(x_1+x_2,x_3,x_4) - b^+(x_1,x_2,x_4) - b^+(x_1+x_4,x_2,x_3).</math>
|}

===The Syzygies===

====The "B around B" Syzygy====

The picture, with all shielding removed, is
{| align=center
|- align=center
|[[Image:06-1350-BAroundB.svg|center]]
|-
|align=right|(Drawn with [http://www.inkscape.org/ Inkscape]) (note that lower quality pictures are also acceptable)
|}

The functional form of this syzygy is

{| align=center
|-
|<math>BB(x_1,x_2,x_3,x_4,x_5) = </math>
|<math>\rho_3(x_1, x_2, x_3, x_5) + \rho_3(x_1 + x_5, x_2, x_3, x_4) - \rho_3(x_1 + x_2, x_3, x_4, x_5)</math>
|-
|
|<math>- \rho_3(x_1, x_2, x_4, x_5) - \rho_3(x_1 + x_4, x_2, x_3, x_5) - \rho_3(x_1, x_2, x_3, x_4)</math>
|-
|
|<math>+ \rho_3(x_1, x_3, x_4, x_5) + \rho_3(x_1 + x_3, x_2, x_4, x_5).</math>
|}

===A Mathematica Verification===

The following simulated Mathematica session proves that for our single relation and single syzygy, <math>d^2=0</math>. Copy paste it into a live Mathematica session to see that it's right!

{{In|n=1|in=<nowiki>d1 = {
rho3[x1_, x2_, x3_, x4_] :> bp[x1, x2, x3] + bp[x1 + x3, x2, x4] +
bp[x1, x3, x4] - bp[x1 + x2, x3, x4] - bp[x1, x2, x4] -
bp[x1 + x4, x2, x3]
};
d2 = {
BAroundB[x1_, x2_, x3_, x4_, x5_] :> rho3[x1, x2, x3, x5] +
rho3[x1 + x5, x2, x3, x4] - rho3[x1 + x2, x3, x4, x5] -
rho3[x1, x2, x4, x5] - rho3[x1 + x4, x2, x3, x5] -
rho3[x1, x2, x3, x4] + rho3[x1, x3, x4, x5] +
rho3[x1 + x3, x2, x4, x5]
};</nowiki>}}

{{InOut|n=3|in=<nowiki>BAroundB[x1, x2, x3, x4, x5] /. d2</nowiki>|out=<nowiki>- rho3[x1, x2, x3, x4] + rho3[x1, x2, x3, x5] - rho3[x1, x2, x4, x5]
+ rho3[x1, x3, x4, x5] - rho3[x1 + x2, x3, x4, x5]
+ rho3[x1 + x3, x2, x4, x5] - rho3[x1 + x4, x2, x3, x5]
+ rho3[x1 + x5, x2, x3, x4]</nowiki>}}

{{InOut|n=4|in=<nowiki>BAroundB[x1, x2, x3, x4, x5] /. d2 /. d1</nowiki>|out=<nowiki>0</nowiki>}}

06-1350/Class Photo

2006-10-17T22:33:54Z

Sankaran:

Our class on September 28, 2006:

[[Image:06-1350-ClassPhoto.jpg|thumb|center|500px|Class Photo: click to enlarge]]
{{06-1350/Navigation}}
Please identify yourself in this photo! There are two ways to do that:

* [[Special:Userlogin|Log in]] to this Wiki and edit this page. Put your name, userid, email address and location in the picture in the alphabetical list below.
* Send [[User:Drorbn|Dror]] an email message with this information.

The first option is more fun but less private.

===Who We Are===

{| align=center border=1
|-
!First name
!Last name
!UserID
!Email
!In the photo
!Comments
{{Photo Entry|last=Bar-Natan|first=Dror|userid=Drorbn|email=drorbn@ math.toronto.edu|location=facing everybody, as the photographer|comments=Take this entry as a model and leave it first. Otherwise alphabetize by last name. Feel free to leave some fields blank}}
{{Photo Entry|last=Bailey|first=Michael|userid=Michael|email=bailey@ math.toronto.edu|location=the guy looking all mysterious like it's a perfume commercial or something|comments=}}
{{Photo Entry|last=Dancso|first=Zsuzsi|userid=Zsuzsi|email=zsuzsi@ math.toronto.edu|location=first row, second from the right|comments=}}
{{Photo Entry|last=Hammerlindl|first=Andy|userid=Andy|email=hammera@ telusplanet.net|location=third row, third from right|comments=}}
{{Photo Entry|last=Ivrii|first=Oleg|userid=Oivrii|email=oleg@ math.toronto.edu|location=last row, middle of the sitting |comments=}}
{{Photo Entry|last=de Jong|first=Michael|userid=michael|email=michael.dejong@ utoronto.ca|location=standing in the back, on the left|comments=}}
{{Photo Entry|last=Archibald|first=Jana|userid=Jana|email=jfa@ math.toronto.edu|location=Third row, First on right|comments=}}
{{Photo Entry|last=Shaw|first=Kristin|userid=Shawkm|email=shawkm@ math.toronto.edu|location=second row, second from the left|comments=}}
{{Photo Entry|last=Antolin Camarena|first=Omar|userid=Oantolin|email=oantolin@ math.toronto.edu|location=second row, furthest to the left (mostly obscured by people in front row)|comments=}}
{{Photo Entry|last=Roukema|first=Fionntan|userid=Roukema|email=froukema@ math.toronto.edu|location=First row, furthest to the right. Head roughly where the diagonals of the picture meet. Don't seem to be wearing socks of any great worth|comments=}}
{{Photo Entry|last=Sankaran|first=Siddarth|userid=Sankaran|email=siddarth.sankaran@ utoronto. ca |location= Front row centre.|comments=}}

|}

VasCalc - Progress Log

2006-09-16T01:25:25Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Friday September 15 2006====
Another bug in the <code>KontsevichIntegral</code> has been found! It appears that the program will fail if all the crossings are not in the middle of the diagram (as in the closure of a braid). This should hopefully be fixed soon...
====Saturday September 9 2006====
The <code>KontsevichIntegral</code> should now be able to handle any knot thrown at it - there's still an unresolved bug with links, which will hopefully be fixed shortly.
====Tuesday September 5 2006====
A preliminary <code>KontsevichIntegral</code> function has been added to the repository. There are still some details to be ironed out, most notably extending the multiplication to links. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for an example.
====Monday August 14 2006====
The framing independence relations have been added to the project (by the <code>ChordsMod4TFI</code> class, and in Mathematica using <code>CDrSpace[l,m,n]</code>). Using this, we've also been able to verify that the correction term <math>Z_{\infty}</math> matches a previous computation.
====Thursday July 27 2006====
We're now able to verify solutions to the pentagon and hexagon equations, in the process changing the interface around a bit. As usual, the [[VasCalc Documentation - ChordsMod4T|documentation]] contains details.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Documentation - User's Guide

2006-09-13T00:53:02Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty^{-1}</math> to a circle; we then reduce and display the result:
{{InOut|n=12|in=<nowiki>ConnectStrand[1, 1, Zinf^(-1)] // ReduceFI // CD</nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360
+ CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 +
(7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760</nowiki>}}
====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

Here is the Kontsevich integral, up to degree four, of the trefoil:
{{InOut|n=13|in=<nowiki>KontsevichIntegral[R,Phi,Knot[3,1]] // ReduceFI // CD </nowiki>
|out = <nowiki>1 + (23*CD[Circle[1, 2, 1, 2]])/24 -
CD[Circle[1, 2, 3, 1, 2, 3]]/2 + (119*CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]])/360 -
(119*CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]])/720 + (247*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}
Below is another embedding of the trefoil, and the Kontsevich integral computed on this diagram is the same as that of the first:
[[Image:Trefoil.jpg|left|thumb|80px|The trefoil]]
{{In|n=14|in=<nowiki>trefoil = MorseLink[Cup[1, 2], Cup[2, 3], X[1, Under, Down, Down],
X[3, Under, Up, Up], X[2, Over, Down, Up], Cap[4, 3], Cap[2, 1]];</nowiki>}}
{{InOut|n=16|in=<nowiki>KontsevichIntegral[R,Phi,trefoil] // ReduceFI // CD</nowiki>
|out = <nowiki>1 + (23*CD[Circle[1, 2, 1, 2]])/24 -
CD[Circle[1, 2, 3, 1, 2, 3]]/2 + (119*CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]])/360 -
(119*CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]])/720 + (247*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

 
==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

File:Trefoil.jpg

2006-09-13T00:37:59Z

Sankaran: presentation of trefoil knot

presentation of trefoil knot

VasCalc Documentation - User's Guide

2006-09-13T00:37:31Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[0,1,CD[(Zinf)^(-1)] /. Line -> Circle]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

Here is the Kontsevich integral, up to degree four, of the trefoil:
{{InOut|n=14|in=<nowiki>KontsevichIntegral[R,Phi,Knot[3,1]] // ReduceFI // CD </nowiki>
|out = <nowiki>1 + (23*CD[Circle[1, 2, 1, 2]])/24 -
CD[Circle[1, 2, 3, 1, 2, 3]]/2 + (119*CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]])/360 -
(119*CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]])/720 + (247*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}
Below is another embedding of the trefoil, and the Kontsevich integral computed on this diagram is the same as that of the first:
{{In|n=15|in=<nowiki>trefoil = MorseLink[Cup[1, 2], Cup[2, 3], X[1, Under, Down, Down],
X[3, Under, Up, Up], X[2, Over, Down, Up], Cap[4, 3], Cap[2, 1]];</nowiki>}}
{{InOut|n=16|in=<nowiki>KontsevichIntegral[R,Phi,trefoil] // ReduceFI // CD</nowiki>
|out = <nowiki>1 + (23*CD[Circle[1, 2, 1, 2]])/24 -
CD[Circle[1, 2, 3, 1, 2, 3]]/2 + (119*CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]])/360 -
(119*CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]])/720 + (247*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-09-09T19:30:22Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[0,1,CD[(Zinf)^(-1)] /. Line -> Circle]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Over, Up, Down],
X[2,Under, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc - Progress Log

2006-09-09T19:22:34Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Saturday September 9 2006====
The <code>KontsevichIntegral</code> should now be able to handle any knot thrown at it - there's still an unresolved bug with links, which will hopefully be fixed shortly.
====Tuesday September 5 2006====
A preliminary <code>KontsevichIntegral</code> function has been added to the repository. There are still some details to be ironed out, most notably extending the multiplication to links. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for an example.
====Monday August 14 2006====
The framing independence relations have been added to the project (by the <code>ChordsMod4TFI</code> class, and in Mathematica using <code>CDrSpace[l,m,n]</code>). Using this, we've also been able to verify that the correction term <math>Z_{\infty}</math> matches a previous computation.
====Thursday July 27 2006====
We're now able to verify solutions to the pentagon and hexagon equations, in the process changing the interface around a bit. As usual, the [[VasCalc Documentation - ChordsMod4T|documentation]] contains details.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Documentation - User's Guide

2006-09-09T19:16:19Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[0,1,CD[(Zinf)^(-1)] /. Line -> Circle]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Under, Up, Down],
X[2,Over, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-09-06T14:57:57Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[0,1,CD[(Zinf)^(-1)] /. Line -> Circle]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

'''Note (9/5/2006):'''' There are a few bugs in the program right now: first, one must have at least one crossing, and second, one cannot have a crossing when there exactly two strands. The latter is not a huge problem because of Reidemeister 1, but be forewarned. This will be fixed as soon as we get the program to accept links as well as knots. 

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Under, Up, Down],
X[2,Over, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-09-06T14:56:23Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[Id[3],0,
1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[{2,1},0,
1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[{1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[0,1,CD[(Zinf)^(-1)] /. Line -> Circle]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

'''Note (9/5/2006):'''' There are a few bugs in the program right now: first, one must have at least one crossing, and second, one cannot have a crossing when there exactly two strands. The latter is not a huge problem because of Reidemeister 1, but be forewarned. This will be fixed as soon as we get the program to accept links as well as knots. 

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Under, Up, Down],
X[2,Over, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-09-06T01:31:43Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

'''Note (9/5/2006):'''' There are a few bugs in the program right now: first, one must have at least one crossing, and second, one cannot have a crossing when there exactly two strands. The latter is not a huge problem because of Reidemeister 1, but be forewarned. This will be fixed as soon as we get the program to accept links as well as knots. 

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Under, Up, Down],
X[2,Over, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-09-06T01:25:04Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

'''Note (9/5/2006):'''' There are a few bugs in the program right now: first, one must have at least one crossing, and second, one cannot have a crossing when there exactly two strands. The latter is not a huge problem because of Reidemeister 1, but be forewarned. This will be fixed as soon as we get the program to accept links as well as knots. 

First, let's make sure we get the same answer as the previous section with this presentation of the unknot:
[[Image:Unknot.jpg|thumb|60px|left|The unknot]]
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Over, Up, Down],
X[2,Under, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

File:Unknot.jpg

2006-09-06T01:19:24Z

Sankaran: A presentation of the unknot

A presentation of the unknot

VasCalc Documentation - User's Guide

2006-09-06T01:10:58Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

In order to use the <code>KontsevichIntegral</code>, you must also install the ''KnotTheory`'' package, which is available from [http://katlas.math.toronto.edu/wiki/The_Mathematica_Package_KnotTheory%60 The Knot Atlas].

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
If you wish to compute the <code>KontsevichIntegral</code> (and really, why else would you be here?), start by loading in the ''KnotTheory`'' package in a Mathematica session:
{{InOut|n=0|in=<nowiki><<KnotTheory`</nowiki>|
out=<nowiki>Loading KnotTheory` version of May 31, 2006, 14:15:20.091.
Read more at http://katlas.math.toronto.edu/wiki/KnotTheory.</nowiki>}}

Also, load in the VasCalc definitions:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====The Unknot====
To compute <math>Z(K)</math> for any knot, including the unknot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[2,1, ConnectStrand[3,2, ReverseStrand[2,Phi] ] ]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

====The Kontsevich integral for unframed knots====

We can find the Kontsevich integral of any knot <code>K</code>, through the command <code>KontsevichIntegral[R, Phi, K]</code>, where <code>R</code> and <code>Phi</code> are <code>ASeries</code> objects as above, and <code>K</code> is a [http://katlas.math.toronto.edu/wiki/MorseLink_Presentations Morse link] presentation of a knot (or alternatively any presentation that ''KnotTheory`'' knows how to convert to a Morse link presentation). The output, for a knot, is an <code>ASeries</code> object on one circle, whose degree is determined by the degrees of <code>R</code> and <code>Phi</code>.

In these examples, we shall continue to use the pair <math>(R, \Phi) </math> defined in the previous section.

'''Note (9/5/2006):'''' There are a few bugs in the program right now: first, one must have at least one crossing, and second, one cannot have a crossing when there exactly two strands. The latter is not a huge problem because of Reidemeister 1, but be forewarned. This will be fixed as soon as we get the program to accept links as well as knots. 

First, let's try this presentation of the unknot:
{{In|n=14|in=<nowiki>unknot = MorseLink[Cup[1, 2], Cup[3, 4], X[2, Over, Up, Down], X[2,Under, Down, Up],Cap[2, 3], Cap[2, 1]];</nowiki>}}
We'll compute the Kontsevich integral, reduce it, and print it out:
{{InOut|n=15|in=<nowiki>KontsevichIntegral[R, Phi, unknot] // ReduceFI // CD </nowiki>
|out = <nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki> }}
Thankfully, this agrees with the previous section.

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc - Progress Log

2006-09-06T00:25:40Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Tuesday September 5 2006====
A preliminary <code>KontsevichIntegral</code> function has been added to the repository. There are still some details to be ironed out, most notably extending the multiplication to links. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for an example.
====Monday August 14 2006====
The framing independence relations have been added to the project (by the <code>ChordsMod4TFI</code> class, and in Mathematica using <code>CDrSpace[l,m,n]</code>). Using this, we've also been able to verify that the correction term <math>Z_{\infty}</math> matches a previous computation.
====Thursday July 27 2006====
We're now able to verify solutions to the pentagon and hexagon equations, in the process changing the interface around a bit. As usual, the [[VasCalc Documentation - ChordsMod4T|documentation]] contains details.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Documentation - User's Guide

2006-08-19T21:51:51Z

Sankaran: moved "Special ASeries" content to body

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

'''Warning (08/19/06):''' The documentation below may be slightly out of date, as we are in the process of changing the <code>ASeries</code> notation. This should be resolved within a few days - please bear with us.
==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-19T21:50:00Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

'''Warning (08/19/06):''' The documentation below may be slightly out of date, as we are in the process of changing the <code>ASeries</code> notation. This should be resolved within a few days - please bear with us.
==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Special Form of ASeries====

When calculating the invariant of a knot or a braid, we multiply the invariant of
the different "events" in the knot's presentation. In the case where this event
is a crossing, one must keep in mind that two strands have been permuted. For
this reason one must apply <code>PermuteStrand[]</code> in order to get the
correct answer. This causes the resulting expressions to be rather inelegant.
For this reason we have devised a new form of <code>ASeries[]</code> that keeps
track of the permutation of the strands so one does not need to manually permute
them when multiplying.

This format only applies when there are no circles in our ASeries, as in the
case of knots and braids. One can then define an ASeries using the format:
<code>ASeries[Permutation_list, CV_list]</code>. Here, <code>Permutation</code> is a list
of integers from <math>1</math> to </math>n</math>, where <math>n</math> is
the number of lines in the diagram. <code>CV</code> is a list containing Chord vectors
of increasing degree.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects - note that we wish <math>R</math> to represent a transposition, while <math>\Phi</math> is a trivial permutation:
{{InOut|n=3|in= <nowiki>Phi = ASeries[{1, 2, 3}, 0,
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] -
(1/24)*CD[Line[2], Line[1], Line[1, 2]], 3]
]</nowiki>|
out = <nowiki>ASeries[{1, 2, 3}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[{2, 1}, 0,
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2],Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]]
]</nowiki>|
out=<nowiki>ASeries[{2, 1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> AddStrand[0, Phi].DoubleStrand[2, Phi].AddStrand[3, Phi] -
DoubleStrand[1, Phi].DoubleStrand[3, Phi] </nowiki> | out= <nowiki>ASeries[{1,2,3,4}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>DoubleStrand[1, R] - Phi.AddStrand[0, R].(Phi)^(-1).AddStrand[2, R].Phi</nowiki>|out=<nowiki>ASeries[{2,3,1}, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-19T21:23:04Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

'''Warning (08/19/06):''' The documentation below may be slightly out of date, as we are in the process of changing the <code>ASeries</code> notation. This should be resolved within a few days - please bear with us.
==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[n, ASeries]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[n, ASeries]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[n, ASeries]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[i, j, ASeries]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Special Form of ASeries====

When calculating the invariant of a knot or a braid, we multiply the invariant of
the different "events" in the knot's presentation. In the case where this event
is a crossing, one must keep in mind that two strands have been permuted. For
this reason one must apply <code>PermuteStrand[]</code> in order to get the
correct answer. This causes the resulting expressions to be rather inelegant.
For this reason we have devised a new form of <code>ASeries[]</code> that keeps
track of the permutation of the strands so one does not need to manually permute
them when multiplying.

This format only applies when there are no circles in our ASeries, as in the
case of knots and braids. One can then define an ASeries using the format:
<code>ASeries[Permutation_list, CV_list]</code>. Here, <code>Permutation</code> is a list
of integers from <math>1</math> to </math>n</math>, where <math>n</math> is
the number of lines in the diagram. <code>CV</code> is a list containing Chord vectors
of increasing degree.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-19T20:11:52Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

'''Warning (08/19/06):''' The documentation below may be slightly out of date, as we are in the process of changing the <code>ASeries</code> notation. This should be resolved within a few days - please bear with us.
==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Special Form of ASeries====

When calculating the invariant of a knot or a braid, we multiply the invariant of
the different "events" in the knot's presentation. In the case where this event
is a crossing, one must keep in mind that two strands have been permuted. For
this reason one must apply <code>PermuteStrand[]</code> in order to get the
correct answer. This causes the resulting expressions to be rather inelegant.
For this reason we have devised a new form of <code>ASeries[]</code> that keeps
track of the permutation of the strands so one does not need to manually permute
them when multiplying.

This format only applies when there are no circles in our ASeries, as in the
case of knots and braids. One can then define an ASeries using the format:
<code>ASeries[Permutation_list, CV_list]</code>. Here, <code>Permutation</code> is a list
of integers from <math>1</math> to </math>n</math>, where <math>n</math> is
the number of lines in the diagram. <code>CV</code> is a list containing Chord vectors
of increasing degree.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-17T18:04:56Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[Permutation, m, CDcombo]</code>, where
*<code>Permutation</code> is a list of integers from 1 to <code>l</code> (the number of strands) which encode the permutation of those strands that the <code>ASeries</code> is intended to represent (Note - <code>Id[n]</code> can be used as a shortcut for the identity permutation on <code>n</code> strands). For example, if one wishes a combination of chord diagrams to represent the braiding of the first two strands in a skeleton of five strands, one would use the permutation <code>{2,1,3,4,5}</code>,
*<code>m</code> is the number of circles, and
*<code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords.

It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. To force a maximum order, use the command <code>ASeries[Permutation, m, CDCombo, MaxDegree]</code>, where <code>MaxDegree</code> is a non-negative integer.

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively - however only diagrams representing the same permutation can be added. Multiplication naturally composes the permutations. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Special Form of ASeries====

When calculating the invariant of a knot or a braid, we multiply the invariant of
the different "events" in the knot's presentation. In the case where this event
is a crossing, one must keep in mind that two strands have been permuted. For
this reason one must apply <code>PermuteStrand[]</code> in order to get the
correct answer. This causes the resulting expressions to be rather inelegant.
For this reason we have devised a new form of <code>ASeries[]</code> that keeps
track of the permutation of the strands so one does not need to manually permute
them when multiplying.

This format only applies when there are no circles in our ASeries, as in the
case of knots and braids. One can then define an ASeries using the format:
<code>ASeries[Permutation_list, CV_list]</code>. Here, <code>Permutation</code> is a list
of integers from <math>1</math> to </math>n</math>, where <math>n</math> is
the number of lines in the diagram. <code>CV</code> is a list containing Chord vectors
of increasing degree.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-16T01:20:15Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[CDcombo, l, m]</code>, where <code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords. It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. (Soon to come: option to explicitly specify order).

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*<nowiki>[1]</nowiki> D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-16T01:17:28Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[CDcombo, l, m]</code>, where <code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords. It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. (Soon to come: option to explicitly specify order).

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". In addition, framing independence forces us to introduce the FI relation - hence all the formulae in this section take place in the "further reduced" space of chord diagrams. We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

The definition of <math>Z_\infty</math> involves going up the third strand, down the second, and up the first strand of <math>\Phi</math>:
{{InOut|n=11|in=<nowiki>Zinf = ConnectStrand[ConnectStrand[ReverseStrand[Phi, 2], 3, 2], 2, 1]</nowiki>
|out=<nowiki>ASeries[1, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}

The invariant of the unknot <math>Z(O)</math> is given by closing <math>Z_\infty</math> to a circle (the first line below), and taking the inverse:
{{InOut|n=12|in=<nowiki>ZinfInverseCircle = ASeries[CD[(Zinf)^(-1)] /. Line -> Circle, 0 , 1]</nowiki>|
out = <nowiki>ASeries[0, 1, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=13|in=<nowiki>CD[ReduceFI[ZinfInverseCircle]]</nowiki>|
out=<nowiki>1 - CD[Circle[1, 2, 1, 2]]/24 - CD[Circle[1, 2, 3, 1, 4, 2, 3, 4]]/360 +
CD[Circle[1, 2, 3, 1, 4, 3, 2, 4]]/720 + (7*CD[Circle[1, 2, 3, 4, 1, 2, 3, 4]])/5760 </nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-16T01:01:19Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[CDcombo, l, m]</code>, where <code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords. It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. (Soon to come: option to explicitly specify order).

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>}}

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-16T01:00:47Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

==Overview==
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

==Requirements==
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

==Installation==
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.

==Usage==
====Initialization====
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}
These steps must be followed at the start of each Mathematica session you wish to use this package.

====Representing Chord Diagrams====
Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.
This package also allows for formal linear combinations of <code>CD</code> objects.

====Computing chord diagram spaces modulo 4T and FI relations====

[[Image:The_4T_Relation.png|300px|right|thumb|The 4T relation: The dotted lines indicated regions that are identical in all diagrams.]]
The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

One can also obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

In addition, one can work with chord diagram spaces modulo the 4T and framing independence (FI) relations, using the command <code> CDrSpace[l,m,n,opts] </code> - the "r" stands for "further reduced". The above commands work in a similar fashion for these spaces.
====Using <code>ASeries</code> objects====
Because operations on chord diagrams (such as multiplication and reduction) can often be resource-intensive, it is desirable to work with representations in Java as much as possible. The <code>ASeries</code> object is meant to facilitate this. To create one, use the command <code>ASeries[CDcombo, l, m]</code>, where <code>CDcombo</code> is a linear combination of chord diagrams (represented by <code>CD</code>'s, and possibly a constant term), all of which are on a fixed skeleton of <code>l</code> lines and <code>m</code> circles, and may have a different number of chords. It is important to note that an <code>ASeries</code> carries with it the notion of an order, defined implicitly by the maximum number of chords to appear in a diagram in <code>CDcombo</code>; the result of any and all computations are only given up to the lowest order appearing therein. (Soon to come: option to explicitly specify order).

There are several operations one can perform on an <code>ASeries</code> object. Addition and multiplication is achieved using the <code>+</code> and <code>.</code> operators respectively. Also, <code>ASeries</code> objects can be inverted (up to the highest order), provided they are of the form <code>(1 + higher order terms) </code>.

Additionally, the following unary operations are available:
*<code>AddStrand[ASeries, n]</code> adds an empty strand to all the diagrams in the given <code>ASeries</code> after the <code>n</code>'th position.
*<code>DoubleStrand[ASeries, n]</code> doubles the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ReverseStrand[ASeries, n]</code> reverses the <code>n</code>'th strand in all the diagrams in the given <code>ASeries</code>.
*<code>ConnectStrand[ASeries, i, j]</code> is the linear extension of the operation that for each diagram, appends the <code>j</code>'th strand to the end of the <code>i</code>'th one.
*<code>PermuteStrand[ASeries, perm]</code> applies the permutation <code>perm</code> to the strands of the chord diagrams in the given <code>ASeries</code>. The permutation is to be represented as a list of cycles.
*<code>Reduce[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation. This operation may take some time if the relevant chord diagram spaces need to be computed.
*<code>ReduceFI[ASeries]</code> returns another <code>ASeries</code> equivalent to the first modulo the 4T relation, and the FI relations. As before, this operation may take some time if the relevant chord diagram spaces need to be computed.

All these operations will be put to use in the next section.

Finally, to convert an <code>ASeries</code> back to a human-readable form, use the command: <code>CD[ AS ]</code>, where <code>AS</code> is the object to be converted.

====Checking the pentagon and hexagon relations====

For paranthesized braids, the pentagon and hexagon equations are given by
{| align=center width=100%
|- align=center
|[[Image:The Pentagon For Parenthesized Braids.jpg|350px]]
|[[Image:The Hexagons For Parenthesized Braids.jpg|500px]]
|- align=center
|colspan=2|'''The Pentagon and the Hexagons for Parenthesized Braids'''
|}.

Algebraically, these relations can be written as

{{Equation|Pentagon|<math>\Phi^{123}\cdot(1\otimes\Delta\otimes 1)(\Phi)\cdot\Phi^{234}=(\Delta\otimes 1\otimes 1)(\Phi)\cdot(1\otimes 1\otimes\Delta)(\Phi)</math>     in     <math>A_4</math>,}}

{{Equation|Hexagons|<math>(\Delta\otimes 1)(R^{\pm 1}) = \Phi^{123}\cdot (R^{\pm 1})^{23}\cdot(\Phi^{-1})^{132}\cdot(R^{\pm 1})^{13}\cdot\Phi^{312}</math>     in     <math>A_3</math>.}}

where <math>A_n</math> is the algebra of chord diagrams on <math>n</math> strands modulo the 4-T relations.

Let us check that a proposed pair <math>\{R, \Phi\}</math> satisfy these equations, up to the third order. After running through the initialization above, we introduce our candidates as <code>ASeries</code> objects:
{{InOut|n=3|in= <nowiki>Phi = ASeries[
1 + (1/24)*CD[Line[1], Line[2], Line[1, 2]] - (1/24)*CD[Line[2], Line[1], Line[1, 2]],
3,0]</nowiki>|
out = <nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»}]</nowiki>}}
{{InOut|n=4|in= <nowiki>R = ASeries[
1 + (1/2)CD[Line[1], Line[1]] + (1/8)CD[Line[1, 2], Line[1, 2]] +
(1/48)CD[Line[1, 2, 3], Line[1, 2, 3]],
2,0]</nowiki>|out=<nowiki>ASeries[2, 0,«JavaObject[vectorSpace.Coefficient]», «JavaObject[ChordVector]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}] </nowiki>}}

First, we'll check the pentagon equation. Writing the difference of the two sides for <math>\Phi</math>,
{{InOut|n=5|in=<nowiki> (AddStrand[Phi,0].DoubleStrand[Phi,2].AddStrand[Phi,3]) - (DoubleStrand[Phi,1].DoubleStrand[Phi,3])</nowiki> | out= <nowiki>ASeries[4, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}

Now we reduce the result modulo the 4T relations, and convert back to <code>CD</code> notation:
{{InOut|n=6|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}
Thus our candidate <math>\Phi</math> solves the pentagon equation.

Let's also test one of the hexagon equations:
{{InOut|n=7|in = <nowiki>(DoubleStrand[R, 1]) -
Phi.AddStrand[R, 0].PermuteStrand[ Phi^(-1) , {{2, 3}}].AddStrand[R,
1].PermuteStrand[Phi, {{1, 3, 2}}]</nowiki>|out=<nowiki>ASeries[3, 0, {«JavaObject[vectorSpace.Coefficient]»,
«JavaObject[ChordVector]», «JavaObject[ChordVector]»}]</nowiki>}}
Reducing the result, we see that our choices of <math>R</math> and <math>\Phi</math> yield a solution to the first hexagon equation.
{{InOut|n=8|in=<nowiki>CD[Reduce[%]]</nowiki>|out=0}}

The second hexagon equation can be verified in a similar fashion, and the result is the same.

====Braid Invariants====

To come: definition of Z[B[n]], demonstration of Reidemeister moves. For now, [[VasCalc Documentation - An example| reidemeister.nb]].

====(Unframed) Knot Invariants====
To compute <math>Z(K)</math> for a knot, we need to extend the definition of <math>Z</math> to include "caps" and "cups". We proceed using the <math>Z_{\infty}</math> correction term in [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf]. To begin, let us choose a pair <math>(R, \Phi)</math> which solve the pentagon and hexagon equations to fourth degree:

{{In|n=9|in=<nowiki>Phi = ASeries[1 + CD[Line[1], Line[2], Line[1, 2]]/24 -
(7*CD[Line[1], Line[2, 3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[2], Line[1], Line[1, 2]]/24 +
(7*CD[Line[2], Line[1, 3, 4], Line[1, 2, 3, 4]])/1920 -
(7*CD[Line[3], Line[1, 2, 4], Line[1, 2, 3, 4]])/1920 +
(7*CD[Line[4], Line[1, 2, 3], Line[1, 2, 3, 4]])/5760 +
(7*CD[Line[1, 2], Line[3, 4], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 3], Line[2, 4], Line[1, 2, 3, 4]]/640 -
CD[Line[1, 4], Line[2, 3], Line[1, 2, 3, 4]]/1152 -
CD[Line[2, 3], Line[1, 4], Line[1, 2, 3, 4]]/1152 +
(19*CD[Line[2, 4], Line[1, 3], Line[1, 2, 3, 4]])/5760 -
(7*CD[Line[3, 4], Line[1, 2], Line[1, 2, 3, 4]])/5760 -
CD[Line[1, 2, 3], Line[4], Line[1, 2, 3, 4]]/1440 +
CD[Line[1, 2, 4], Line[3], Line[1, 2, 3, 4]]/480 -
CD[Line[1, 3, 4], Line[2], Line[1, 2, 3, 4]]/480 +
CD[Line[2, 3, 4], Line[1], Line[1, 2, 3, 4]]/1440,
3,0]; </nowiki>

{{In|n=10|in=<nowiki>R = ASeries[1 + CD[Line[1], Line[1]]/2 + CD[Line[1, 2], Line[1, 2]]/8 +
CD[Line[1, 2, 3], Line[1, 2, 3]]/48 +
CD[Line[1, 2, 3, 4], Line[1, 2, 3, 4]]/384,
2, 0];</nowiki>}}

==Performance Issues==

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.
==References==
*D. Bar-Natan, [http://www.math.toronto.edu/~drorbn/papers/nat/nat.pdf Non-Associative Tangles]. Geometric Topology (proceedings of the Georgia International Topology Conference, W. H. Kazez ed.), 139-183, Amer. Math. Soc. and International Press, Providence, 1997.

VasCalc Documentation - User's Guide

2006-08-16T00:18:57Z

Sankaran:

VasCalc Documentation - User's Guide

2006-08-14T23:35:26Z

Sankaran:

VasCalc - Documentation

2006-08-14T23:20:35Z

Sankaran:

This page will contain the documentation for the various parts of [[VasCalc - A Vassiliev Invariants Calculator|VasCalc]], and will be updated as work gets completed. Follow the links for documentation on each component of the program:

*[[VasCalc Documentation - User's Guide| VasCalc User's Guide]] - instructions and examples on using the VasCalc Vassiliev invariants calculator.

* [[VasCalc Documentation - vectorSpace|vectorSpace]] - a small Java package to deal with finite-dimensional vector spaces.

*[[VasCalc Documentation - An example| Reidemeister]] - a small example showing how to use VasCalc to check one of the Reidemeister moves

VasCalc Documentation - ChordsMod4T

2006-08-14T23:18:22Z

Sankaran: VasCalc Documentation - ChordsMod4T moved to VasCalc Documentation - User's Guide: This page will document all of the VasCalc project.

#redirect [[VasCalc Documentation - User's Guide]]

VasCalc Documentation - User's Guide

2006-08-14T23:18:22Z

Sankaran: VasCalc Documentation - ChordsMod4T moved to VasCalc Documentation - User's Guide

VasCalc - Progress Log

2006-08-14T23:15:03Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Monday August 14 2006====
The framing independence relations have been added to the project (by the <code>ChordsMod4TFI</code> class, and in Mathematica using <code>CDrSpace[l,m,n]</code>). Using this, we've also been able to verify that the correction term <math>Z_{\infty}</math> matches a previous computation.
====Thursday July 27 2006====
We're now able to verify solutions to the pentagon and hexagon equations, in the process changing the interface around a bit. As usual, the [[VasCalc Documentation - ChordsMod4T|documentation]] contains details.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Documentation - User's Guide

2006-08-14T19:21:35Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T20:19:10Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T20:16:14Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T20:10:31Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T20:09:29Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T19:10:11Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-29T19:09:31Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-27T23:43:38Z

Sankaran:

VasCalc Documentation - User's Guide

2006-07-27T23:21:19Z

Sankaran:

VasCalc - Progress Log

2006-07-27T23:07:28Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Thursday July 27 2006====
We're now able to verify solutions to the pentagon and hexagon equations, in the process changing the interface around a bit. As usual, the [[VasCalc Documentation - ChordsMod4T|documentation]] contains details.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Documentation - User's Guide

2006-07-17T22:52:51Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

===Overview===
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

===Requirements===
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

===Installation===
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.
===Usage===
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}

The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

Note: Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.

One can obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[ CDSpace[1,1,3] ]</nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

The command <code>ReduceCD[ Diagrams]</code> will take a linear combination of chord diagrams, and return another linear combination that is equivalent to the first up to the relations defined. The relevant spaces will be computed automatically. For example:
{{In|n=5|in=<nowiki>cd = 4 CD[Line[1, 2, 2, 1, 3], Circle[3]] + CD[Line[1, 2, 2, 3, 3, 1], Circle[]];</nowiki> }}
{{InOut|n=6|in=<nowiki>ReduceCD[cd]</nowiki>|out=<nowiki>4 CD[Line[1, 2, 3, 3, 2], Circle[1]] + CD[Line[1, 2, 3, 3, 2, 1], Circle[]]</nowiki>}}

===Performance Issues===

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.

VasCalc Documentation - User's Guide

2006-07-17T22:44:00Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

===Overview===
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

===Requirements===
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

===Installation===
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

You must also ensure that there is a directory named "CM4TData" under the installation directory, creating it if neccessary. This is for save/load functionality to work properly.
===Usage===
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}

The object <code>CDSpace[l,m,n]</code> represents the rational vector space generated by chord diagrams with <code>n</code> chords on a skeleton with <code>l</code> lines and <code>m</code> circles, modulo the 4-T relation. The first time a space is encountered in a session, a check is made to see if there is data for the required space on disc (under the path_to_install_folder/CM4TData directory). If no such entry exists, the space is computed, and by default the results are saved on disc for future use - this computation may be substantial, depending on the values of the parameters. One can prevent the saving of data by using the command <code>CDSpace[l,m,n, WriteToDisc -> False] </code>.

One can obtain the dimension of a chord diagram space, as follows:

{{InOut|n=3|in = <nowiki>GetDimension[CDSpace[1,1,3]]</nowiki>|out=19}}

Note: Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.

One can obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=4| in=<nowiki>GetCDBasis[CDSpace[1,1,3] </nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

The command <code>ReduceCD[ Diagrams]</code> will take a linear combination of chord diagrams, and return another linear combination that is equivalent to the first up to the relations defined. The relevant spaces will be computed automatically. For example:
{{In|n=5|in=<nowiki>cd = 4 CD[Line[1, 2, 2, 1, 3], Circle[3]] + CD[Line[1, 2, 2, 3, 3, 1], Circle[]];</nowiki> }}
{{InOut|n=6|in=<nowiki>ReduceCD[cd]</nowiki>|out=<nowiki>4 CD[Line[1, 2, 3, 3, 2], Circle[1]] + CD[Line[1, 2, 3, 3, 2, 1], Circle[]]</nowiki>}}

===Performance Issues===

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.

VasCalc - Progress Log

2006-07-17T22:24:23Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.
====Monday July 17 2006====
The ChordsMod4T interface has been cleaned up a little, and save/load functionality has been added - see the [[VasCalc Documentation - ChordsMod4T|documentation]]. Progress is underway on implementing some operations on chord diagram spaces.
====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Results - ChordMod4T

2006-07-10T16:48:00Z

Sankaran:

This page documents some computational results obtained by using the ChordsMod4T software component of the [[VasCalc]] project. We denote by <math>{\mathcal A}(l,m,n)</math> the formal (rational) vector space generated by all chord diagrams with <math>n</math> chords on a skeleton of <math>l</math> lines and <math>m</math> circles, modulo the <math>4T</math> relations. The algorithm is straightforward: first all such diagrams are constructed, then relations are introduced iteratively over all possible terms in a <math>4T</math> relation. See the [[VasCalc Documentation - ChordsMod4T| documentation]] for further information about the program and how these results were generated.

===Some Dimensions of <math>{\mathcal A}(l,m,n)</math>===

The tables below give the dimensions of <math>{\mathcal A}(l,m,n)</math> for various values of <math>l</math>, <math>m</math> and <math>n</math>. Each table corresponds to a fixed value of <math>n</math> - that is, the number of chords.

'''This is work in progress - these numbers are not reliable yet!!!'''

{| border="1"
|+ Dimensions of chord diagram spaces with 2 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="10"|Number of Circles
|- align=right
||0||1||2||3||4||5||6||7||8||9
|- align=right
|0||0|| 2||8||24||59||125||237||413||674||1044
|- align=right
|1||2||8||24||59||125||237||413||674||1044||1550
|- align=right
|2||9||25||60||126||238||414||675||1045||1551||2223
|- align=right
|3||28||63||129||241||417||678||1048||1554||2226||3097
|- align=right
|4||69||135||247||423||684||1054||1560||2232||3103||4209
|- align=right
|5||145||257||433||694||1064||1570||2242||3113||4219||5599
|- align=right
|6||272||448||709||1079||1585||2257||3128||4234||5614||7310
|- align=right
|7||469||730||1100||1606||2278||3149||4255||5635||7331||9388
|- align=right
|8||758||1128||1634||2306||3177||4283||5663||7359||9416||11882
|- align=right
|9||1164||1670||2342||3213||4319||5699||7395||9452||11918||14844
|}

{| border="1"
|+ Dimensions of chord diagram spaces with 3 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="7"|Number of Circles
|- align=right

|0||1||2||3||4||5||6
|- align=right
|0||0||3||19||80||270||770||1918
|- align=right
|1||3||19||80||270||770||1918||4284
|- align=right
|2||23||88||283||789||1944||4318||8803
|- align=right
|3||111||321||845||2021||4419||8931||16876
|- align=right
|4||394||954||2172||4618||9184||17189
|- align=right
|5||1130||2418||4944||9600||17705||31125
|}

{| border="1"
|+ Dimensions of chord diagram spaces with 4 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="6"|Number of Circles
|- align=right

|0||1||2||3||4
|- align=right
|0||0|| 6||44||241||1063
|- align=right
|1||6||44||241||1063||3930
|- align=right
|2||60||283||1160||4126

|}

VasCalc Results - ChordMod4T

2006-07-10T16:47:32Z

Sankaran:

This page documents some computational results obtained by using the ChordsMod4T software component of the [[VasCalc]] project. We denote by <math>{\mathcal A}(l,m,n)</math> the formal (rational) vector space generated by all chord diagrams with <math>n</math> chords on a skeleton of <math>l</math> lines and <math>m</math> circles, modulo the <math>4T</math> relations. The algorithm is straightforward: first all such diagrams are constructed, then relations are introduced iteratively over all possible terms in a <math>4T</math> relation. See the [[VasCalc Documentation - ChordsMod4T| documentation]] for further information about the program and how these results were generated.

===Some Dimensions of <math>{\mathcal A}(l,m,n)</math>===

The tables below give the dimensions of <math>{\mathcal A}(l,m,n)</math> for various values of <math>l</math>, <math>m</math> and <math>n</math>. Each table corresponds to a fixed value of <math>n</math> - that is, the number of chords.

'''This is work in progress - these numbers are not reliable yet!!!'''

{| border="1"
|+ Dimensions of chord diagram spaces with 2 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="10"|Number of Circles
|- align=right
||0||1||2||3||4||5||6||7||8||9
|- align=right
|0||0|| 2||8||24||59||125||237||413||674||1044
|- align=right
|1||2||8||24||59||125||237||413||674||1044||1550
|- align=right
|2||9||25||60||126||238||414||675||1045||1551||2223
|- align=right
|3||28||63||129||241||417||678||1048||1554||2226||3097
|- align=right
|4||69||135||247||423||684||1054||1560||2232||3103||4209
|- align=right
|5||145||257||433||694||1064||1570||2242||3113||4219||5599
|- align=right
|6||272||448||709||1079||1585||2257||3128||4234||5614||7310
|- align=right
|7||469||730||1100||1606||2278||3149||4255||5635||7331||9388
|- align=right
|8||758||1128||1634||2306||3177||4283||5663||7359||9416||11882
|- align=right
|9||1164||1670||2342||3213||4319||5699||7395||9452||11918||14844
|}

{| border="1"
|+ Dimensions of chord diagram spaces with 3 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="7"|Number of Circles
|- align=right

|0||1||2||3||4||5||6
|- align=right
|0||0||3||19||80||270||770||1918
|- align=right
|1||3||19||80||270||770||1918||4284
|- align=right
|2||23||88||283||789||1944||4318||8803
|- align=right
|3||111||321||845||2021||4419||8931||16876
|- align=right
|4||394||954||2172||4618||9184||17189
|- align=right
|5||1130||2418||4944||9600||17705||31125
|}

{| border="1"
|+ Dimensions of chord diagram spaces with 4 chords
!rowspan="2" width="100px"|Number of Lines
!colspan="6"|Number of Circles
|- align=right

|0||1||2||3||4||5
|- align=right
|0||0|| 6||44||241||1063
|- align=right
|1||6||44||241||1063||3930
|- align=right
|2||60||283||1160||4126

VasCalc Documentation - User's Guide

2006-07-09T17:12:40Z

Sankaran:

This page documents the ChordsMod4T component of the [[VasCalc]] project. This page is also under construction.

===Overview===
This package provides a Mathematica interface to work with the space generated by chord diagrams on a fixed skeleton of lines and circles, modulo the 4-T relation. See Dror Bar-Natan's [[Survey of Finite Type Invariants]] for further details.

===Requirements===
The software requirements of this package are Mathematica 4.1 and Java 1.4 (or greater, in both cases). However, note that default installations of Mathematica 4.1 and up include a Java runtime binary, and require no further configuration for this package to work.

While there are no specific hardware requirements, the computations involved are rather resource-intensive. Users of low-end machines will see a smaller range of parameters for which the computation is practicable. We'll have an expected performance profile once work on this package is done.

===Installation===
If you have an up-to-date copy of the [http://katlas.math.toronto.edu/svn/VasCalc/ repository], skip ahead. If not, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz] and extract it to a directory of your choice.

===Usage===
In a Mathematica session, load the definitions by typing:

{{In|n=1|in=<nowiki> <</path_to_install_folder/CDinterface.m </nowiki>}}
where "path_to_install_folder" is either the "trunk" folder of the repository, or the folder in which the above archive, if downloaded, was unpacked.

You must also issue the following command, to inform Mathematica of the location of the required Java objects:

{{In|n=2|in=<nowiki> SetVasCalcPath["/path_to_install_folder"]; </nowiki>}}

Use the command CreateCDSpace[ lines, circles, chords], to generate the space of chord diagrams with the given parameters, modulo the 4T relations. For example, we construct the space of diagrams with 3 chords on a skeleton of 1 line and 1 circle:

{{In|n=3|in=<nowiki> A = CreateCDSpace[1,1,3]; </nowiki>}}

One can then find the dimension of the resultant space:

{{InOut|n=4|in = <nowiki>GetDimension[A]</nowiki>|out=19}}

Note: Our convention for representing a chord diagram in Mathematica is through a <code>CD</code> object containing <code>Line</code> and <code>Circle</code> expressions as per the skeleton. To construct such a representation,
* Number the chords on the diagram.
* For each line on the skeleton, put within the brackets of its <code>Line</code> expression the numbers of the chords that have their endpoints on that line, starting from the bottom and working up. For each circle, do the same, but one can choose an arbitrary starting point and count around. If there are no chords on a given line or circle, leave the brackets empty, as in <code>Line[]</code>.
Naturally, there are many representations for a given diagram.

One can obtain a basis for a chord diagram space (modulo 4T), expressed as a list of chord diagrams:
{{InOut|n=5| in=<nowiki>GetCDBasis[A] </nowiki>|
out=<nowiki>{CD[Line[1, 1], Circle[2, 2, 3, 3]], CD[Line[1, 1], Circle[2, 3, 2, 3]],
CD[Line[1], Circle[1, 2, 3, 2, 3]], CD[Line[1], Circle[1, 2, 3, 3, 2]],
CD[Line[], Circle[1, 1, 2, 3, 3, 2]], CD[Line[1, 2, 1, 2], Circle[3, 3]],
CD[Line[], Circle[1, 2, 1, 3, 2, 3]], CD[Line[1, 2], Circle[1, 3, 3, 2]],
CD[Line[1, 2, 2, 1], Circle[3, 3]], CD[Line[1, 2, 2], Circle[1, 3, 3]],
CD[Line[], Circle[1, 2, 3, 1, 2, 3]], CD[Line[1, 2, 3], Circle[1, 3, 2]],
CD[Line[1, 2, 3, 2, 1, 3], Circle[]], CD[Line[1, 2, 3, 2], Circle[1, 3]],
CD[Line[1, 2, 3, 3], Circle[1, 2]], CD[Line[1, 2, 3, 2, 3, 1], Circle[]],
CD[Line[1, 2, 3, 2, 3], Circle[1]], CD[Line[1, 2, 3, 3, 2, 1], Circle[]],
CD[Line[1, 2, 3, 3, 2], Circle[1]]} </nowiki> }}

The command <code>ReduceCD[ Diagrams, CDSpace]</code> will take a linear combination of chord diagrams, and return another linear combination that is equivalent to the first up to the relations defined. One also needs to pass on the chord diagram space in which the action takes place. For example:
{{In|n=6|in=<nowiki>cd = 4 CD[Line[1, 2, 2, 1, 3], Circle[3]] + CD[Line[1, 2, 2, 3, 3, 1], Circle[]];</nowiki> }}
{{InOut|n=7|in=<nowiki>ReduceCD[cd,A]</nowiki>|out=<nowiki>4 CD[Line[1, 2, 3, 3, 2], Circle[1]] + CD[Line[1, 2, 3, 3, 2, 1], Circle[]]</nowiki>}}

===Performance Issues===

We are currently working to improve the performance of this program. For larger computations, it would likely help to increase the maximum heap size available to Java. To do this, type the following into Mathematica before loading the CDinterface.m definitions (step 1 above):

{{In|n=1|in=<nowiki>Needs["JLink`"];</nowiki>}}
{{In|n=2|in=<nowiki>InstallJava[CommandLine -> "/path_to_java_runtime/java -Xmx128M"]</nowiki>}}

This allows Java to use up to 128 megabytes of memory; you may change the number "128" in the parameter "-Xmx128M" to suit your needs. Note that the first line needs to be entered exactly as shown - the funny apostrophe is located next to the "1" key on many keyboards.

VasCalc - Progress Log

2006-07-09T16:29:55Z

Sankaran:

This is the [[VasCalc - A Vassiliev Invariants Calculator|VasCalc Project]] Progress Log.

====Sunday July 9 2006====
An updated package for the ChordsMod4T program has been posted: [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordsMod4T.tar.gz ChordsMod4T.tar.gz]. Now you can work directly with linear combinations of CDs, and reduce them. See the [[VasCalc Documentation - ChordsMod4T|documentation]] for more details.
====Friday July 7 2006====
So the little bug in ChordsMod4T appears to be resolved. The [[VasCalc - Results| results]] pages no longer directly disprove the consistency of mathematics. Also the program is a fair bit faster than the previous incarnation, but coefficient arithmetic is still by far the biggest resource thief.

====Friday June 23 2006====
Success! Our program is now complete - we can generate the relations, and compute the quotient . What remains is the interface to Mathematica, which should be easy, and optimizing the program, which may be a little harder. A little example will be up soon.

====Tuesday June 20 2006====
Now we are able to generate all chord diagrams on a given number of lines and circles, as well as all the diagrams with a T added! Almost done is the piece that puts the two together - the ChordsMod4T class, which mods out the first space with the relations generated by the second. There are still many things to be done with this part of the program before we're truly finished: I've listed these on the [[VasCalc - To Do List]] page. Fun fact: there are 902 chord diagrams on one circle with 6 chords, 9749 diagrams with 7 chords, and 127072 diagrams with 8 chords. Evidently, we'll have to make some improvements to the program - generating one circle with 9 chords runs out of memory.
====Saturday June 17 2006====
The [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram class] is now up and running. As explained in the [[VasCalc Documentation - ChordDiagram| documentation]], this class is used to store information about individual chord diagrams. Because of the way we've set up labelling the diagrams, the task of generating all diagrams becomes very easy - this part of the program is almost done as well.
====Tuesday May 30 2006====
A new file [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ChordDiagram.java ChordDiagram.java] was committed to the repository. This is a class that holds information describing one chord diagram and contains methods that will help in constructing chord diagrams systematically. It is not yet complete, though not far from it.
====Monday May 29 2006====
I've updated the vectorSpace package, and added a Mathematica interface, as well an almost complete [[VasCalc Documentation - vectorSpace|document]] on the wiki. Can someone check that the instructions for installation work?
Also, does the simulated Mathematica session work on this wiki?
====Wednesday May 24 2006====
A new package [http://katlas.math.toronto.edu/svn/VasCalc/trunk/vectorSpace vectorSpace] has been committed to the repository, to handle quotients of finite-dimensional vector spaces. See the [[VasCalc - Documentation|documentation]] for usage details.
====Saturday May 20 2006====
Our first task is to write a program to construct and manipulate the (formal) quotient vector space A(m,n,l), consisting of diagrams with m chords between n lines and l circles, modulo the four-T relations. Here's a rough sketch of the structure of this program:

[[Image:Dmod4T.jpg|thumb|120px|left]]
 
Java things are in orange, Mathematica things are in blue. Red arrows are helper functions that need to be written, and black arrows denote "natural class heirarchy".
 

====Monday May 15 2006====
Another slightly different HelloWorld test has been added to the [http://katlas.math.toronto.edu/svn/VasCalc/trunk/ SVN repository]. This time, one can use the default Java runtime bundled with Mathematica/Windows (so the user does not need to know anything about where Java lives on their system) by telling the Java compiler to produce code for Java 1.4. This is accomplished by issuing the command:
:<code>javac -source 1.4 -target 1.4 file_to_be_compiled.java </code>

I suppose this prevents us from using the new features of Java 1.5, but I don't know what they are.

As for the test program, download [http://katlas.math.toronto.edu/svn/VasCalc/trunk/javatest.m javatest.m] and [http://katlas.math.toronto.edu/svn/VasCalc/trunk/test1.class test1.class], and issue the following commands in Mathematica (replacing the '/path_to_files' with the location you downloaded the files to, and don't forget the quotes in the second line):

:<code> << /path_to_files/javatest.m </code>

:<code> HelloWorld[VasCalcPath -> "/path_to_files"] </code>

and read your mystery message!

==== Sunday May 14 2006====
J/Link passed the Hello World test. The java class and Mathematica
notebook were commited to the repository trunk. Note the Mathematica file
must be edited in order to specify the path to java and the class.
In order to get it to work I had to tweak a few things:
* The JRE bin directory had to be added to the PATH. The JDK path is not enough because J/Link looks for files like jawt.dll and awt.dll that don't come with JDK.
* HelloWorld.class had to be in one of the dirs in CLASSPATH, because J/Link loads classes only through their full class name.
* In Mathematica, when running InstallJava[], it was necessary to specify the path name for a newer version of java.exe. By default it runs the Windows java, which didn't run what was compiled with a new JDK.

Ideally, one would like to write a Mathematica notebook without
any hardcoded paths that others can use with no changes. Is this
possible?

==== Thursday May 11 20006====
* First day meeting's blackboard: [[Image:060511-1.jpg|thumb|160px|left]]

VasCalc Results - ChordMod4T

2006-07-07T21:40:35Z

Sankaran: