(1) Overview

Introduction

This introduction is divided into two parts: First, we are going to give some mathematical background before introducing the software itself.

Mathematical Background

Racks and Quandles were first described by John Conway and Gavin Wraith in 1959 in unpublished correspondence. In [2], David Joyce showed that racks are indeed a knot invariant. Subsequently, Fenn and Rourke introduced racks as proper knot invariants in [3]. It is instructive to consider racks as groups without their multiplicative elements. Formally, a rack is defined as a set of elements endowed with a binary operation which satisfies the following axioms (where the third axiom holds only for a quandle, not for a rack) for all a, b, c in the rack/quandle R:

  1. a, bR∃! cRs.t.ac = b
  2. ba(c)(bc)(c)=ac
  3. aa = a (only quandle)

Biracks and Biquandles are defined similarly, now with two operations, satisfying the following axioms:

  1. abcb = acbc
  2. abcb = acbc
  3. abcb = acbc
  4. aa = aa (only biquandle)

In addition, both operations satisfy the rack axiom 1.

Here, the up and down actions allow us to introduce a switch map via fa(x) = xa, fa(x) = xa as S(a, fa(b)) = S(b, fb(a)). The utility of this is clear when one observes that the axioms can be reformulated using the switch map:

  • S, fa and fa are all bijective.
  • Yang Baxter Equation: S1S2S1 = S2S1S2, where S1(a, b, c) = (S(a, b), c) and S2(a, b, c) = (a, S(b, c)).

This reformulation is more amenable to computational work.

The homology of the biquandle is defined as follows:

Let X be a birack. Then CnR(X) be the free abelian group generated by n-tuples (x1x2xn), xiX, that is, CnR(X)=ZXn.

We define a boundary homomorphism by:

(x1x2xn)=i=2n(1)i[(x1xi^xn)                                         x1xi  xi1xi(xi+1)xi(xn)xi]

and (CnR(X),  ) is called a chain complex of X.

Furthermore, we have a subchain complex CnD(X)    CnR(X), generated by degenerate n-tuples (x1x2xn), xiX with xi = xi+1 for some i. Together with the boundary homomorphism, (CnD(X),  ) is is called the degenerate chain complex of X.

Using both of those chain complexes, we can define the biquandle chain complex via the quotient chain complex, CnQ(X)=CnR(X)/CnD(X). This gives the following short exact sequence of chain complexes:

0CnD(X)CnR(X)CnQ(X)0.

We can then define the birack, biquandle and degenerate homology groups in the usual way. In addition, we have the following long exact sequence of homology groups:

HnD(X)HnR(X)HnQ(X)Hn1D(X)

The algorithm for the homology calculation is described in [1] for this specific software.

Software

The software, which is provided as an R package, can be accessed on github. It provides two primary functions. One of these calculates the homology of racks and biracks, whilst the other verifies if a rack or birack is induced by a given set with one or two actions.

Implementation and architecture

This software is implemented in R. It has been tested on MacOS X, CentOS/Ubuntu and Windows without any problems.

The algorithm for the homology calculation is described in the paper [1].

The program is divided into the following two main parts: The calculation of the boundary matrix and the subsequent calculation of the Homology. For a graphical description see the following Figure 1, which was created with the following code:

  • library(proftools)
  • Rprof(tmp <- tempfile(), line.profiling = T); homology(4,5,F);Rprof(append=F); pd <- readProfileData(tmp)
  • plotProfileCallGraph(pd,style=google.style,score=“total”,nodeSizeScore = “none”,layout=”dot”,rankDir = “LR”)
Figure 1 

Call graph for the calculation of the H4R(Z5).

The boundary matrices are computed using the functions boundary_matrix (for quandle and rack boundary matrices) and boundary_matrix_degenerate (for degenerate boundary matrices), respectively. The methodology of both functions is similar, differing only in the manner in which degenerate or non-degenerate entries are removed where required. In particular, after creating a right-sized matrix, they call boundary_names or boundary-names_degenerate to create the row and column names of the boundary matrix. After this, they loop through the column names to calculate their boundaries and construct the matrix (for details see [1]). These boundary matrices represent the boundary maps of the simplicial complex of the rack/birack.

After both boundary matrices have been calculated, they are returned to the homology and degenerate_homology functions, respectively. As is the case for the boundary matrices functions, these two functions only differ in the boundary functions called and in their respective output texts.

As an aside, those two functions should be the only ones that would have to be called by the user in order to calculate a homology.

Following on with the algorithm described in [1], those two functions calculate the image and kernel of the boundary map representations (the boundary matrices) before finding a representation of the homology group. For this, they call various functions, namely findX, which “finds X” (this is defined in [1]), row_space, which calculates a basis of the row space of a matrix, matrix_rank, which calculates the rank of a matrix and GaussianElimination, a function written by Prof John Fox (see [4] for a source) which does a Gaussian Elimination on a matrix and returns its reduced row echelon form.

Using the function smith, the smith natural form is obtained from the representation matrix of the homology. This is done via repeated calculation of the hermite normal form of the matrix and its transpose, using the hermiteNF function from the numbers package, [8]. In addition, this function checks if the diagonal of the matrix is in the correct form via the function check_more_push and, if required, will call push_down to do what the name implies.

Finally. The homology group is obtained using the diagonal of the smith normal form.

The second function of this package, the testing if a give operation or operations give rise to a quandle or biquandle is done via the function S_test. This function receives as input the order of the underlying set and then proceeds to test the two requirements for a quandle/biquandle as described before.

Quality control

The results of the program have been compared to known results and in addition, R CMD check has been used to quality check the code itself.

Additionally, a few tests have been provided in test/testthat.R.

(2) Availability

Operating system

Any OS that can install and run R (at least version 3.0.0).

Programming language

R 3.0.0+.

Additional system requirements

The more RAM, the higher the homology groups that can be calculated.

Presently, output is on screen, but can be changed to a file, if necessary.

Required input devices: keyboard only.

Dependencies

The program requires the R standard installation [5, 6], together with the packages MASS [7] and numbers [8].

Software location

Archive

Name: CRAN

Persistent identifier:https://cran.r-project.org/web/packages/quhomology/index.html

Licence: GNU GPL v3.0

Publisher: Ansgar Wenzel

Date published: 02/05/2016

Version: 1.1.0

Archive

Name: Zenodo

Persistent identifier:https://doi.org/10.5281/zenodo.229962

Licence: GNU GPL v3.0

Publisher: Ansgar Wenzel

Date published: 04/01/2017

Version: 1.1.0

Code Repository

Names: GitHub

Identifier:https://github.com/ansgarwenzel/quhomology

License: GNU GPL v3.0

Date published: 05/05/2016

Version: 1.1.0

Language

English

Support

Support is currently provided via Github issues.

(3) Reuse potential

This software can be used to calculate the homology groups of most racks and biracks. It is very easy to adapt for application to other eracks/biracks. Furthermore we believe that it can easily be extended to the calculation of Cohomology groups. Finally, the possibility of quickly identifying if a given action/set of actions gives rise to a rack/birack, is very useful.