Improved drawing functions

Some small incremental updates since October. The biggest changes are in the drawing functions---see the documentation for examples.

• Rewrote the tree-pair drawing functions from scratch. Can now render an automorphism in any G_{n, r}---previously only G_{2,1} worked.
• Can also plot an automorphism as a function from the interval to itself.
• Fixed a bug in Word.as_interval --- was completely broken for words that didn't start with x1
• Fixed a bug where the periodic conjugacy test could incorrectly conclude that two auts were not conjugate

Fixes, tests and documentation

Since February I spent time learning about revealing pairs via the paper of Salazar-Díaz. Consequently, some experimental functions were added to the package---in particular methods to see when a tree pair is revealing, and a method which calls pdflatex to render the automorphism as a tree pair.

The remainder of the work was on tests, fixes and documentation. The implementation of the conjugacy test was consistent with Hossain's ConjugacyF when working in the group F. I added a Jupyter notebook to give a nice illustration of how we can use the package.

Power conjugacy implemented

Alongside the finishing of the paper came the finishing of the power conjugacy implementation. After some minor adjustments to the theory and some bug fixing, the result was a working implementation. I make no promises that it works quickly, however!

I spent a lot of time tidying up the documentation for this release too, so that it was a companion of sorts to the paper.

Completing the refactor

In early January, it became clear that the class heirachy

Homomorphism -> Automorphism
Automorphism -> PeriodicFactor
Automorphism -> InfiniteFactor

was making it difficult to implement the Power Conjugacy problem. (The symbol '->' stands for 'is a superclass of'.) The solution was a different heirachy

Homomorphism -> Automorphism
Automorphism -> MixedAut
Automorphism  ->PeriodicAut
Automorphism -> InfiniteAut

where the type of an automorphism was determined at creation time by computing the quasinormal basis. This refactoring was a pain but was worth it.

Minor fixes and improvements

Quasinormal bases are computed faster by making better use of what we learn about various components. This deals with huge periodic automorphisms which took over a minute to compute the QNB for.

Some extra examples and tests were added thanks to @nbarkercmep.

Conjugacy Tests

An awful lot of work went into this release. Automorphisms can be broken down into free factors, and the periodic and infinite conjugacy tests are implemented. To deal with the relabelling needed for this, a lot of code was factored out of the Automorphism class and put into a new parent class, Homomorphism.

Debugging the infinite conjugacy tests lead to the discovery of pond orbits; the orbit sharing test had to be updated to deal with this. (This lead to the /theory folder too, for formal lemmas and so on.)

A system for reading and writing automorphisms from files was created, leading to an expansion of the number of examples available. Functions for randomly generating examples are also available.

Finally a lot of thought was put into improving the speed of the QNB-finding method. The bulk of the problem was not using all of the information that the core-component method finds.

Orbit sharing test

This commit was the point at which the orbit-sharing test was mostly implemented. (This was before we knew ponds existed.) The next step from this point was to implement Higman's conjugacy tests.

Moving away from trees towards words

The first version that could really claim to represent an automorphism in memory. Lots of work went into the basics here: a class to represent words, generating sets; computing images of words under automorphisms. A lot of section 4 was implemented here: finding the QNB, computing the orbit/component types.At the time my understanding of Higman's work wasn't perfect, so there are some (mathematical!) bugs here. I also setup Sphinx documentation and doctests.

Baby Steps: working in V

This was the work I started over the summer. It was quite limited in scope: I could represent, draw, multiply and invert automorphisms (though at the time I was thinking of them as TreePairs). Ultimately a lot of this was abandoned, but it was useful to get myself re-familiarised with Python and to have some experience of working with $V=G_{2,1}$.