A Knot is a simple closed curve in three-dimensional space, where ``simple'' means the curve does not intersect itself and ``closed'' means it ends where it starts, i.e. it forms a closed loop without loose ends. We may think of a knot in this sense as the result of taking a curve segment, tying a knot in it, and then joining the ends together so the knot cannot come undone. We usually describe knots by drawing pictures called knot diagrams. A knot diagram is a projection or shadow of a knot on the plane, with the restriction that each point on the diagram is the shadow of no more than two points on the knot. Each double point, i.e. each point which is the shadow of two points on the knot, is called a crossing, and we draw crossings on the knot diagram with breaks to show which strand crosses over and which strand crosses under.

A choice of a direction to travel around a knot is called an orientation of the knot, and a knot together with a specific choice of orientation is called (not surprisingly) an oriented knot.

When we consider oriented knots, we find that there are two types of crossings, corresponding to right-handed twists and left-handed twists. We will call one type of crossing   positive (a right-handed twist) and the other type negative (a left-handed twist), and the signs + and - will be attached to positive and negative crossings respectively.

As any scout or sailor knows, there are many different kinds of knots. In knot theory, we would like to be able to tell when two knots are the same and when two knots are different. In particular, we would like to know what are all of the possible types of knots.

Moving a knot around in space does not change what kind of knot it is -- in order to get a different knot, we have to cut the strand, tie a different knot in it, and rejoin the ends. In general, it is difficult to tell just by looking at two knot diagrams whether they represent different knots or the same knot. The intuitive idea of ``moving a knot around in space'' corresponds to the mathematical idea of ambient isotopy; we are free to stretch, bend, and otherwise deform the knot and as long as we don't tear it or intersect it with itself, we don't change what type of knot it is. When one knot can be obtained from the other by an ambient isotopy, the two knots are called ambient isotopic. In other words, to say that two knots are the same type is simply to say that they are ambient isotopic.

In terms of knot diagrams, ambient isotopies translate to sequences of plane isotopies and Reidemeister moves. A plane isotopy allows us to move a curve around in the plane, stretching or bending it however we want so long as we don't intersect it with another curve or move it out of the plane. If we want to move a piece of the knot from one position in the plane to another, there are four kinds of situations that can occur, based on the kinds of things can be in the way:

1. nothing (plane isotopy)
2. the arc we want to move (move I)
3. a different arc (move II)
4. a crossing (move III)

In the first situation, where nothing is in the way, we simply do a plane isotopy to move the arc to where we want it. In the other three situations, we apply the following Reidemeister moves:

In these pictures, we mean that if we have two knot diagrams which are identical outside of the pictured area and the only change from one to the other occurs as pictured, then the two diagrams represent the same knot. A sequence of plane isotopies and Reidemeister moves will be called an isotopy, and two knot diagrams connected by an isotopy will be called isotopic.

There is a theorem which says that two knot diagrams arising from ambient isotopic knots are related by a series of plane isotopies and Reidemeister moves, and conversely plane isotopies and Reidemeister moves can be "lifted" to obtain ambient isotopies in knots. So, if we can produce a series of these moves that change one knot diagram into another, then we will have shown that the two diagrams represent the same knot. Not being able to produce such a sequence, however, doesn't tell us anything -- we may not have been clever enough to find the right sequence, or the sequence of moves (if one exists) may be very complicated, involving thousands or even millions of moves.

So, to prove that two knots are not the same, we have to be more clever. The usual technique that knot theorists use is to devise knot invariants, which are numerical or algebraic quantities associated to particular knot diagrams in such a way that doing Reidemeister moves on the diagram does not change the numerical quantity. If a numerical quantity calculated from a knot diagram stays the same under Reidemeister moves (and plane isotopies), then any two diagrams of the same knot will give us the same value for that invariant; in particular, if two knot diagrams give us different values for some particular invariant, then they can't represent the same knot. This gives us a way to prove that the two diagrams in question represent different knots.

However, if two knot diagrams give the same value for an invariant, it does not generally mean that the two knot diagrams represent the same knot; we have to either check other invariants to see if another invariant might distinguish the knot diagrams or find a sequence of isotopies before we can determine whether the two diagrams represent the same knot.

Looking for sequences of isotopies and calculating invariants can both be time-consuming tasks and, as in all complex calculations, doing them by hand can introduce human errors quite easily. Thus it makes sense to look for a way to get computers to do these jobs for us.

There is an obvious problem, however: the way we usually describe knots is by drawing pictures, our knot diagrams mentioned above, and while these are human-friendly in that they give us a clear visual impression of the knot in question, knot diagrams are not very computer-friendly. Thus if we are going to use computers to do calculations on knots, we need to find a more computer-friendly way of describing knots.

One way to do this is to use Gauss codes. We create a Gauss code from a knot diagram by first labelling each crossing with a number. (Let's assume there is only a finite number of crossings; knots with infinitely many crossings are called wild knots and can be problematic, so we'll restrict our attention to tame knots, i.e. knots with only a finite number of crossings). We then choose a starting point anywhere we like on the knot and follow the chosen direction around the knot and write down the order in which we encounter each crossing along with whether we cross over it or under it and what its local orientation is (+ or -), keeping on until we arrive back at our starting point. Thus a Gauss code is a sequence of crossing labels listed with an ``O'' or a ``U'' and a ``+'' or a ``-''. Since we encounter each crossing exactly twice, once going over and once going under, each label will occur exactly twice in our Gauss code, once with an ``O'' and once with a ``U''. The sign of a given crossing is the same for both occurrences of its label in the Gauss code.

Example: This is the trefoil knot (also commonly called the overhand knot), which most of us use in tying our shoes. It has the Gauss code O1-U2-O3-U1-O2-U3-, as you can see by starting at the indicated point and following the knot along, writing down the crossings in the order you encounter them and whether you cross over or under and whether the crossing is positive or negative, until you return to the starting point. Note that all three crossings here are negative.

Great! Now we have a way of specifying knot diagrams that uses only ordinary keyboard characters and can fit on as little as a single line. In order for Gauss codes to be useful to us a way of describing knots, we have to check that we can recover the ordinary knot diagram from the Gauss code. Of course, the exact code we get depends on our choice of starting point, but it is easy to see that choosing a different starting point will simply move some labels from the end to the beginning of the code.

A much more serious concern arises when we consider taking a arbitrary Gauss code and trying to construct a knot diagram from it: as it turns out, there are some Gauss codes that don't give us knot diagrams at all! Try to draw a knot diagram with the Gauss code O1+U2+U1+O2+, for example; you'll find that you have to introduce an extra crossing to join the end back up to the starting point.

This is bad because in a Gauss code we are supposed to have already listed all of the crossings; we can't add additional crossings without changing the Gauss code.

## Virtual Knots

Gauss codes are more computer-friendly than knot diagrams for specifying knots, but some Gauss codes do not correspond to ordinary knots. Nonetheless, Gauss codes are potentially very useful in doing calculations, so we don't want to abandon them; as it turns out, we don't have to. The Gauss code O1+U2+U1+O2+ may not represent a real knot, i.e. a simple closed curve in three-dimensional space, but it does represent something called a ``virtual knot.''

This situation is very much like when we first consider the question ``what is the square root of negative one?'' Our initial idea of what a ``number'' is based on the idea of cardinality, like the number of bananas in a bunch; but when we start thinking of numbers as solutions to algebraic equations rather than as cardinalities, we find that there are some algebraic equations which none of the numbers we're familiar with satisfy, like   x^2 = -1 (or even   x+1=0).

In order to solve these equations, we define a new concept of ``number'' that extends our old idea, so our previous idea of what a ``number'' is is a special case of our new, more general idea. We can do this as long as our new definition is consistent with our old one. In the number case, defining a new number  i  by the equation   i^2 = -1 allows us to solve all of our algebraic equations. We would like to extend our idea of ``knots'' in a similar way so that every Gauss code represents a ``knot'' of some type.

The way we do this is to start by considering the Reidemeister moves in terms of Gauss codes. More precisely, we'll write our Gauss codes in a slightly more human-friendly (i.e. geometric) form, using what we call Gauss diagrams. We take a circle and write our Gauss code counterclockwise around the circle, connecting the two occurrences of each label with an arrow pointing toward the undercrossing (the one with the ``U'') and decorating each arrow with a ``+'' or ``-'' for local orientation.

In terms of Gauss diagrams, the Reidemeister moves now look like:

Once again, these pictures mean that the two Gauss diagrams are identical outside the areas pictured. The epsilon stands for either sign +1 or -1 (or just + or -). So, for example, move I means that we can introduce an arrow with either sign anywhere on the diagram provided that no arrowhead or tail lies between the head and tail of the one we are introducing, and also that if there is an arrow with no arrowheads or tails between its head and tail, we can delete it.

We now define virtual knots to be equivalence classes of Gauss diagrams (or Gauss codes, whichever form you prefer) under the three above moves. In other words, two Gauss diagrams represent the same virtual knot if there is a sequence of the three above moves that changes one diagram into the other. Such a sequence will be called a virtual isotopy. A Gauss diagram which represents an ordinary knot diagram is called classical or realizable, and a Gauss diagram which does not represent a real knot (i.e. one for which we have to introduce additional crossings to make the diagram work) is called non-classical or non-realizable.

This new definition is consistent with our old idea of what a ``knot'' is, since any sequence of ordinary Reidemeister moves on knot diagrams translates to a sequence of the above moves on Gauss diagrams. However, we can turn a realizable knot into a non-realizable one by using the above moves: an unknotted diagram (one with no crossings) can be changed into the non-realizable diagram U1+U2-O1+O2- by a type II move, for example. We might then be worried that two classically inequivalent classical knots may be equivalent as virtual knots, but this is not so. In fact we have:

Theorem [2]: Two virtually equivalent classical knots are classically equivalent. In other words, if two realizable Gauss diagrams are virtually isotopic, then they have realizations (i.e. they represent real knot diagrams) which are connected by a sequence of ordinary isotopies.

So, we have extended our notion of what a ``knot'' is to include virtual knots, abstract Gauss codes which do not correspond to ordinary knot diagrams. Gauss codes and diagrams are fine for computers, but we humans prefer ordinary knot diagrams since they show us clearly what the knots look like, so we would like to be able to draw knot diagrams for virtual knots. We can do so if we include a new type of crossing, called a virtual crossing. Virtual crossings are virtual because they aren't really there; they are the result of drawing non-planar diagrams in the plane. Virtual crossings do not have a sense of over or under, and they do not represent self-intersections either. Virtual crossings don't show up in Gauss codes or diagrams; they're just a trick we use to let us draw ``knot diagrams'' for virtual knots. So to draw a virtual knot diagram from a Gauss code, we draw the crossings and connect the strands in the order specified by the diagram, introducing virtual crossings whenever we have to.

A virtual crossing looks like this:

Any two virtual knot diagrams (knot diagrams including real and possibly virtual crossings) with the same real crossings (including orientations) occurring in the same order will have the same Gauss code, so they represent the same virtual knot. A Gauss code or diagram tells us how many real crossings (also called classical crossings) there are in our virtual knot, which order we encounter them in, and what their orientations are. In other words, a Gauss code determines how a small neighborhood of each real crossing looks and in which order the segments in those neighborhoods get connected. Apart from that, we are free to draw the arcs outside of those neighborhoods however we want, using virtual crossings whenever one arc encounters another (or itself). In particular, to change one virtual knot diagram into another equivalent virtual knot diagram, we need to be able to move an arc which contains only virtual crossings arbitrarily around in the diagram.

To accomplish this, we need analogues of the Reidemeister moves for virtual crossings. As before, let's consider what kinds of things can get in the way of moving an arc with only virtual crossings to another location:

1. nothing (plane isotopy again)
2. the arc itself (move VI)
3. another arc (move VII)
4. a virtual crossing (move VIII)
5. a real crossing (move V)

This leads us to the following virtual moves:

We will use the term ``virtual moves'' to include the ordinary Reidemeister moves as well as the four above moves; moves V-VIII will be called strictly virtual. Any two virtual knot diagrams connected by a sequence of virtual moves (a virtual isotopy) represent the same virtual knot.

Note that there is only one sort of potential move that we are not allowing: we cannot move a strand with two real crossings over or under a virtual crossing. These two moves are called The Forbidden Moves, which I'll number IV-t and IV-h. The reason they are for-bidden (excuse the pun :) is that using both we can change any knot into any other knot, virtual or classical! In terms of Gauss diagrams, the forbidden moves let us switch the order of any two neighboring arrowheads (IV-h) or arrowtails (IV-t), so that we can eventually end up with all the arrows trivializable by Type I moves. Allowing both forbidden moves would render the theory of virtual knots trivial, since every two virtual knot diagrams are equivalent by a sequence of virtual and forbidden moves. Fortunately, we need not worry: the forbidden move changes the Gauss code by reversing the order in which we encounter two crossings, so it doesn't qualify as a move on virtual knot diagrams which preserves the Gauss code and we have no reason to include either forbidden move in our list of virtual moves.

In fact, here is a demonstration of how to unknot the trefoil using the forbidden moves. We might have trouble keeping our shoes on if we could use these moves!

Many of the usual theorems from classical knot theory carry over to virtual knot theory with little or no modification; the Jones polynomial, the quandle, the fundamental group and others extend quite nicely. However, we often find unexpected results, such as the existence of two distinct quandles associated to each virtual knot and virtual knots which have trivial fundamental group or trivial Jones polynomial but are not equivalent to the unknot. Kauffman [1] has extended quantum link invariants, the quandle, the Jones polynomial, and other invariants of classical knots to virtual knots (in addition to discovering the whole field of virtual knots in the first place), and a paper by Polyak, Goussarov and Viro proposes a scheme for extending Vassiliev or finite type invariants to virtual knots. This whole field is really rather new (Kauffman announced it in 1996), and there is still a lot to be done.

References

1. L. H. Kauffman, Virtual knot theory. European J. Combin. 20 (1999) 663-690.
2. M. Goussarv, M. Polyak and O. Viro. Finite type invariants of classical and virtual knots. Topology 39 (2000) 1045-1068.