Hi everyone. Here is a brief summary of what we have been doing for the first week of GSoC.

In last week we opened the PR #11140 for working on implementing the Finitely Presented Groups and Coset Enumeration. Implementing the Coset Enumeration first understanding how the routine mentioned in [1] interact with each other. Since The different routines being: define, scan, coincidence, merge, rep. Most of these methods have different versions as well, which can be made to be suitable for a particular class of groups.

Coset Table: We represented it using list of lists data structure, inner lists are of fixed length, twice the number of generators, the outer list can grow as much as needed. We started with writing code for the define, scan routines. There was one typo in [1] for scan routine, which I somehow intuitively passed initially while writing code from pseudo-code, but came across it when reading the pseudo-code again. (I didn’t expected the book to contain such a type in pseudo-code). Intially we started with -1 as an entry for undefined slots but since -1 may lead to problems as Python will accept it as an index with no error indications, allowing the bugs to pass silently. So we chose None as a better option to opt for.

We wanted to make sure, these implemeted methods work as expected, so I wrote extensive tests (currently in doctests), 4 of which have been taken from [1] while one from the original Todd Coxeter paper [2].

Just yesterday we decided to make Coset Table a class, since every Coset Table in itself has certain attributes which are changed along the execution of the Enumeration, which can be better represented by a class. It’s struture is be something like

class CosetTable(list):
    def __init__(self, fp_grp, subgroup):
        self.fp_group = fp_grp
        self.subgroup = subgroup
        self._A = list(chain.from_iterable((gen, gen**-1)
                  for gen in self.fp_group.generators))
        self.append([None]*len(self.A))

    @property
    def is_complete(self):
        for coset in self:
            for res in coset:
                if res is None:
                    return False
        return True

    # other methods

On the other side we are working on PR#11150, which deals with implementation of FreeAbelianGroup, it wouldn’t be tough to get along with this PR, since it is just similar to the previously implemented FreeGroup, with dict as its data structure.

For next week

  • Complete the Coset Table PR, i.e implement the different strategies of Felsch, HLT. I am pretty sure, this task would take more than 1 week, since there are whole lot of other strategies which if we decide to implement would take up a lot of time, even the Lookahead version of Todd Coxeter is there, which specifies a whole new data-structure for different compoents involved in Enumeration.

  • Later, implement different methods for FpGroup.

Anyway, I’m really enthusiastic about my project and hope that we’ll have some nice and reasonably fast algorithms in CGT by the end of the summer!

References

  1. Derek F. Holt, Bettina Eick, Bettina, Eamonn A. O’Brien, “Handbook of computational group theory”, Discrete Mathematics and its Applications (Boca Raton). Chapman & Hall/CRC, Boca Raton, FL, 2005. ISBN 1-5848-372-3 .

  2. A practical method for enumerating cosets of a finite abstract group by J. A. TODD (University of Manchester), and H.S.M. Coxeter (University of Cambridge)