Publishing Software Carpentry lesson on GAP

Following the 2nd CoDiMa training school, I have published the Software Carpentry lesson on GAP via Zenodo: see 10.5281/zenodo.167362. The lesson is based on the problem of determining an average order of an element of a finite group, and finding examples of groups for which the average order of their elements is an integer. First I have heard about this problem when Steve Linton used it in a talk in order to quickly demonstrate some GAP features to a general scientific audience. I have tried to expand on it in my talk in Newcastle in May 2015 (see the blog post here), and decided to proceed with it.

Indeed, the problem of determining an average order of the element of the group is simple enough to not to distract learners too much from the intended learning outcomes of the lesson. An undergraduate algebra course is sufficient for its understanding. Moreover, those not familiar with the group theory still should be able to follow the lesson just by grasping the idea that there is a mathematical structure called group, and we need to find an average value of a certain numerical parameter associated with each element of it. On the other hand, those with sufficient theoretical background will hopefully enjoy seeing how the initial naive implementation is being refined several times during the lesson, and how theoretical insights are giving much more significant advances than minor code optimisations or just getting more cores.

The lesson starts with formulating the problem of finding examples of groups such that the average order of their element is an integer. It first explains how to work with the GAP command prompt, demonstrates some basic language constructions and explains how to find necessary information in the GAP help system. At this point using the command line we establish a rough prototype of the code to compute an average order of a group, and tried several examples, none of them yielding an integer. (more…)

Computational Mathematics with Jupyter at ICMS

I am currently involved in the preparation of the workshop “Computational Mathematics with Jupyter”. It is organised jointly by the CoDiMa CCP and Horizon 2020 OpenDreamKit projects, and will take place at the International Centre for Mathematical Sciences in Edinburgh on 16-20 January 2017. Please see the workshop website here for further details, and come if you’re interested in contributing to Jupyter or using it in research and/or teaching!

CoDiMa training school at ICMS

A month ago I organised the Second CoDiMa Training School in Computational Discrete Mathematics which we run at the International Centre for Mathematical Sciences in Edinburgh on October 17th-21st, 2016. The school webpage contains links to the presentations and supplementary materials for all school’s programme. You can now find all #codima2016 tweets on Storify.

Group Numbers Reproducibility Project

In January 2016, I’ve asked on the Mathematics Q&A site the question called “Most wanted reproducible results in computational algebra“. I hope that making a list of suggested experiments to reproduce will be useful to those interested in checking them twice ;-). For example, one could submit their findings to a journal like ReScience which “targets computational research and encourages the explicit replication of already published research, promoting new and open-source implementations in order to ensure that the original research is reproducible”. If you have any suggestions, please consider posting them as answers to that question. Today I’ve also added my own answer, which I am reproducing below.

I believe that enumeration of finite groups of a given order is definitely among most wanted reproducible experiments. Here “enumeration” means providing complete and non-redundant list of groups, “complete” means that no groups are missing in this list, and “non-redundant” means that groups from this list are non-isomorphic pairwise. Guaranteeing these properties is crucial for results that rely on checking all groups of a given order, or that refer to a particular group by its “catalogue number”. (more…)

Why do we need OpenMath?

How do you denote the dihedral group of order n?

This is not a question of “vim or emacs” or “tabs or spaces” sort, but still there are two notations in use. Some sources use Dn to denote a dihedral group of order n, and some others – a dihedral group of order 2n. Both notations are also reflected in mathematical software.

For example, in GAP DihedralGroup(n) returns a group of order n:

gap

and in SageMath – a group of order 2n:

sagemath

Let us look at other systems: (more…)

GAP on GitHub: one year on

This post is based on my earlier comment on the pull request number one submitted to the GAP repository on GutHub a little bit more than a year ago.

Of course, GAP is not new to the version control. The first revision in the CVS repository for GAP 4 is dated July 3rd 1996. Then 16 years later, in summer 2012 the repository had been converted to Mercurial (thanks to Max Horn!) after the release of GAP 4.5. In February 2015 the Mercurial repository had been converted to Git (thanks to Chris Jefferson!), and we started to host it on GitHub at https://github.com/gap-system/gap.

Below there are some highlights of what happened during the first year after that:

  • On 26th February 2016 there were In total 640 pull requests and issues in this repository, namely:
    • 120 open + 133 closed issues
    • 32 open + 356 closed pull requests
    • That’s more than one new pull request a day!
  • While the ratio for open/closed issues is nearly 50:50, “if things are done, they are done”: pull requests are normally reviewed and getting merged, so the ratio open/closed for pull requests is about 1:10.
  • We had several very productive GAP Days in Aachen, Trondheim and St Andrews.
  • We have a gap-system virtual organisation on GitHub which also hosts repositories for other development tools, GAP Website, etc.
  • We have an expanding virtual organisation for gap-packages.
  • There is even more activity with GAP packages, since some of them are openly developed elsewhere (we are trying to keep an up-to-date list at this page).
  • There is an active open GAP development mailing list.
  • There is also a growing Wiki with documentation for developers.
  • In 2015, we made two minor releases based on the stable-4.7 branch of the GitHub repository (4.7.8 and 4.7.9).
  • We put a lot of efforts in making GAP more robust and test it better, in particular, we now run nightly check of the code coverage and publish code coverage reports.
  • And we have just announced the first major release of GAP 4.8.2, which is the first major release of GAP that has been made from this repository! The overview of changes between GAP 4.7 and GAP 4.8 highlights most significant ones, including support for partially variadic functions, better tools for testing, debugging and profiling, function calls with timeouts, 12 new packages redistributed with GAP, and other changes.

Congratulations and thanks to everyone who worked on making all of this possible!!!

In addition, this visualisation, produced with gource, shows files and directories that were modified in the master branch of the core GAP system during the 1st year on GitHub. The large cluster in the top right corner corresponds to the GAP library. The top left corner is occupied by the GAP kernel. The pink cluster in the bottom represents GAP regression tests, and the main GAP manuals are marked by green. There are already changes waiting for GAP 4.9!

gource_1styear

GAP with Docker

The GAP Docker container is now upgraded to the latest stable release of GAP 4.8.2, announced in February.

GAP 4.8.2 includes 130 GAP packages, and I am amazed how many of them are in the working order in the container – including all those requiring compilation, with non-trivial dependencies on external libraries and other third-party software. I have previously used the container for GAP 4.7.9 on an Ubuntu machine as a reference GAP installation, and this morning I was thrilled to upgrade it to GAP 4.8.2 using just two commands and waiting for no more than a couple of minutes!

I still haven’t seen GAP Docker container running on Windows – if anyone manages to do that, I would be very glad to know. This would be very beneficial for users of some packages working only in the UNIX environment.

 

 

20 journals with most GAP citations

The GAP Bibliography currently contains 2217 records. Among others, it contains 1961 journal publication (the rest are books, PhD theses, preprints, etc.). These journal publications represent 331 journal, but almost a half of them (1042 papers) are published in the following 20 journals:

  1. J. Algebra : 258
  2. Comm. Algebra: 137
  3. J. Symbolic Comput.: 88
  4. (*) Discrete Math.: 66
  5. (*) Experiment. Math.: 42
  6. J. Group Theory: 41
  7. Internat. J. Algebra Comput.: 41
  8. (*) European J. Combin.: 38
  9. (*?) LMS J. Comput. Math.: 37
  10. (*) J. Pure Appl. Algebra: 37
  11. J. Algebra Appl.: 36
  12. (*) Des. Codes Cryptogr.: 35
  13. Arch. Math. (Basel): 33
  14. Math. Comp.: 26
  15. (*) J. Combin. Theory Ser. A: 25
  16. Electron. J. Combin.: 25
  17. Israel J. Math.: 22
  18. J. Combin. Des.: 20
  19. J. Algebraic Combin.: 18
  20. Adv. Math.: 17

It’s interesting, however, which of these journals suggest publishing code together with the paper? I have marked with (*) journals where the guidelines for authors (click on the journal title to see them) at least mention an opportunity to submit supplementary material, though the wording used may be quite different. For example, Elsevier’s Discrete Math., European Journal of Combinatorics, J. Pure Appl. Algebra, J. Combin. Theory (Ser.A) and Advances in Mathematics all say “Supplementary files offer the author additional possibilities to publish supporting applications, high-resolution images, background datasets, sound clips and more”, so the code could go under “more”. Experimental Mathematics is more explicit in suggesting that “detailed code can be submitted as a computer supplement”.

There is no information available at the moment for the LMS Journal of Computation and Mathematics, which is currently closed for new submissions, awaiting for the LMS Special General Meeting tomorrow, but there were some in the past. You may see an example how they worked in the paper by Meinolf Geck linked from “In which journals should I publish my software” post by Neil Chue Hong of the Software Sustainability Institute.

Finally, Designs, Codes and Cryptography accepts “electronic multimedia files (animations, movies, audio, etc.) and other supplementary files to be published online along with an article or a book chapter”. In particular, it says that “specialized format such as .pdb (chemical), .wrl (VRML), .nb (Mathematica notebook), and .tex can also be supplied”.

I haven’t discovered suggestions to submit the code in other journals from the list above. I am happy to be corrected in case I’ve overlooked them, but in this case other authors could probably overlook them too…

Research Software Engineering and GAP

This week I was mainly wearing my Research Software Engineer (RSE) hat. RSE support for the GAP system has three related strands: development of the core GAP system; support of package authors and other GAP users; training future users and contributors to the system. They are all important for the thriving community of users and developers, and this week I’ve done something to advance each of them.

First, I’ve prepared a new release of GAP 4.7.9. (more…)

Software Carpentry lesson on GAP

I’ve recently developed the Software Carpentry lesson “Programming with GAP“. This lesson is intended for GAP beginners and has been beta-tested at the Software Carpentry Workshop that we run in Manchester as a part of the First CoDiMa training school in Computational Discrete Mathematics. The lesson itself is available here, and its repository is located here.

What next? I can teach my lesson myself, but is it written clearly enough to be taught by others? Is it possible for the reader to follow it for self-study? Is there any introductory material missing, or is there an interest in having more advanced lesson(s) on some (which?) aspects of the system? If you would like to contribute to its further development, issues and pull requests on GitHub are most welcome!