# Options

## Help

`-h`

,`––help`

Running `./khtpp --help`

displays this help file and exits the program.

## Coefficients

`-c<i>`

,`--coeff<i>`

`i=2,3,5,7,11`

: Compute over the finite field where`i`

. Support for other primes may be easily added, by setting default_coeff equal to the desired prime in the source file headers/constants.h and recompiling the program.`i=0`

: Compute over the field of rational integers .

`-a`

,`––allcoeff`

Computes over all available fields of coefficients.

Support for other fields of coefficients may be easily added, since the implementation is based on templates. For details, see headers/

## Doubling all tangle strands

`-d`

,`––double`

This doubles all tangle strands before computing any invariants. For 1-1-knots, the framing of the resulting cap-trivial tangle is chosen such that the linking number between the two strands is 0. For example, for the trefoil

running

./kht++ -d examples/knots/3_1.kht

computes the invariants of the tangle

## Optimizing tangles by adding twists

`-o`

,`––optimize`

Attempts to minimize the number of generators in the reduced cobordism complex by adding twists to the tangle ends. For example, running

./kht++ -o examples/pretzeltangles/PT2m3.kht

computes the invariants of the tangle

although the input tangle is

The bottom two crossings were added automatically, because the invariant of the first tangle is

⬮<—D——⬮<~⬯<—⬯~>⬮—>⬮~>⬮—>⬮~>⬯

wheras the invariant of the tangle with the extra crossings consist of two objects fewer:

⬯<—D——⬯~>⬮—>⬮~>⬮—>⬮~>⬯

## Appending tangle strings

`-p <tanglestring>`

,`--append <tanglestring>`

Appends a tangle string after applying any other options that modify a given tangle. When this option is used multiple times, the tangle strings are appended separately.

For example, to compute the invariant of a Conway tangle obtained by cutting open a Whitehead double of some knot, I only need to run the program on a (1,1)-tangle representation of this knot, combining the doubling option -d with the option `-p l1.y0.y2.u1`

.

## Prepending tangle strings

`-P <tanglestring>,<new top orientation>`

,`--prepend <tanglestring>,<new top orientation>`

Prepends a tangle string after applying any other options that modify a given tangle. `<new top orientation>`

is a comma separated list of `0`

and `1`

. The option -P can only be used at most once.

For example, in conjunction with the options -d and -p, the option -P can be used to effectively compute Rasmussen invariants of twisted satellite knots, such as the following ten cables of the trefoil knot:

./kht++ examples/tests/3_1.kht -d -Pr1,1 -px0.u1 -px0.x0.x0.u1 \ -px0.x0.x0.x0.x0.u1 -px0.x0.x0.x0.x0.x0.x0.u1 -px0.x0.x0.x0.x0.x0.x0.x0.x0.u1 \ -py0.u1 -py0.y0.y0.u1 -py0.y0.y0.y0.y0.u1 -py0.y0.y0.y0.y0.y0.y0.y0.y0.u1 \ -py0.y0.y0.y0.y0.y0.y0.u1

## Quotients of strongly invertible knots

`-q`

,`––quotient`

(see also Defining strongly invertible 2-bridge knots)

This option was developed and extensively used for the paper [6]. It computes the invariants of the quotient tangle of a strongly invertible knot specified by a symmetric diagram. The quotient tangle is framed such that the closure with the rational tangle of slope 0 is the unknot and the rational closure of slope corresponds to surgery along the longitude for the knot. Unfortunately, this means that to make these tangles follow the (arguable better) conventions used in [10], [11], and [12], one needs to rotate the tangles by 90 degrees.

For example, the quotient of the strongly invertible knot given by the diagram

is equal to

It is generally a good idea to combine computations for quotient tangles with the option -s.

## Defining strongly invertible 2-bridge knots

`-r <name>:<p>/<q>`

,`--rational <name>:<p>/<q>`

(see also Quotients of strongly invertible knots)

Computes all symmetric diagrams of the 2-bridge knot corresponding to the fraction `<p>/<q>`

and saves them in one or more files `<name>.kht`

or `<name>-{1,2}.kht`

in the directory `examples/strong_inversions/2-bridge-knots`

; see Strongly invertible knots, Sakuma, and [9] for details.

## Simplifying tangle input data

`-s`

,`––simplify`

Attempts to simplify the diagram before computing any invariants by doing some isotopies and Reidemeister moves. This can be useful for reducing the computation time.

## Tangle sums/tensor products of multicurves

`--sum <s1>:<s2>`

,`--sumnc <s1>:<s2>`

The first variant `--sum <s1>:<s2>`

computes the tensor product of two multicurves. This corresponds to taking the tangle sum of two Conway tangles (ie stacking the first tangle on top of the other). `<s1>`

and `<s2>`

specify the full relative paths of the text files containing the curves for the first and second tangle, respectively. Such files are stored by the program in separate folders next to the standard .kht-files.

For example, after running `./kht++ examples/pretzeltangles/PT2m3.kht`

, the folder `examples/pretzeltangles/PT2m3/`

contains a file `cxBNr-c2`

, which (apart from metadata) consists of the following line:

1) h^-2 q^-7 δ^-3/2 ⬮<—D——⬮<~⬯<—⬯~>⬮—>⬮~>⬮—>⬮~>⬯

After running `./kht++ -d examples/tests/3_1.kht`

, the folder `examples/tests/3_1/`

contains a file `cxBNr-c2-d`

:

1) h^6 q^12 δ^ 0 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 2) h^0 q^ 1 δ^1/2 ⬮——D—>⬮~>⬮—>⬮~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯

So running

./kht++ --sum examples/pretzeltangles/PT2m3/cxBNr-c2:examples/tests/3_1/cxBNr-c2-d

computes the tensor product of this curve with itself and produces the following output:

Reading in chain from file 'examples/pretzeltangles/PT2m3/cxBNr-c2'... ...understood:h^-2 q^-7 δ^-3/2 ⬮<—D——⬮<~⬯<—⬯~>⬮—>⬮~>⬮—>⬮~>⬯ Reading in chain from file 'examples/tests/3_1/cxBNr-c2-d'... ...understood:h^6 q^12 δ^0 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— ...understood:h^0 q^1 δ^1/2 ⬮——D—>⬮~>⬮—>⬮~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯ First summand: 1) h^-2 q^-7 δ^-3/2 ⬮<—D——⬮<~⬯<—⬯~>⬮—>⬮~>⬮—>⬮~>⬯ Second summand: 1) h^6 q^12 δ^ 0 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 2) h^0 q^ 1 δ^1/2 ⬮——D—>⬮~>⬮—>⬮~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯ Computing the tangle sum. The resulting complex has 441 generators. Now cancelling. Cleaned-up complex in 30 iterations and 0.278s. Tangle sum: 1) h^ 6 q^ 8 δ^ -2 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 2) h^ 1 q^ 0 δ^ -1 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 3) h^ 2 q^ 2 δ^ -1 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 4) h^ 3 q^ 4 δ^ -1 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 5) h^-1 q^-2 δ^ 0 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 6) h^-5 q^-8 δ^ 1 ⬯~~S~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯<— 7) h^-2 q^-5 δ^-1/2 ⬮——D—>⬮~>⬮—>⬮~>⬮—>⬮~>⬯—>⬯<~⬮<—⬮<~⬮<—⬮<~⬯

The second variant `--sumnc <s1>:<s2>`

does the same as the first, except that only the non-compact components of the multicurves are considered in the input. In the example above, this would have the effect of ignoring the first component of the second multicurve. If the input curves contain many compact curves, this makes the computation run much faster than `--sum <s1>:<s2>`

. This option is useful if one is only interested in the non-compact curve of a tangle sum.

Any pair of input files can be used in these options, as long as the multicurves are stored in the standard output format for multicurves (see Output).

## Tests

`-t`

,`––tests`

Runs some tests and exits the program. This option is only intended for the purpose of debugging.

## Version

`-v`

,`––version`

Returns the version of the program and exits the program.

## Recompile and open output in browser

`-w`

,`––web`

Prints the tangle input and (re)compiles the output for the specified file(s) using all previously computed data. No new computations of tangle invariants are made with this option. If the program `xdg-open`

(or `open`

) is installed, this option will also open the output file for the first specified tangle using the default program for .html-files.