I'm working in the area of modular representation theory of finite groups ($G$ is a finite group, $p$ is a prime number dividing $|G|$, $k$ is a finite field of characteristic $p>0$, $M$ and $N$ are $kG$-modules). I'm using GAP to do some computations and would like to ask the following question.


is there a CAS / C-program / ... that satisfies each of the following criteria simultaneously:

  • it is compatible with GAP

  • it is OpenSource

  • relatively fast computation of Hom$_{kG}(M,N)$ over "large" finite fields, such like $GF($3^20$)$, is possible


At the moment, I'm using both CSharedMeatAxe and GAP's (Smash)MeatAxe, but the former cannot deal with fields which are that large (e.g. $GF(3$^$20)$) and the latter is not fast enough (probably because it uses programs from the 90ies). Therefore, I would like to know, if there has been programmed anything new in that direction.

Thank you very much for the help.


1 Answer 1


(Disclaimer: I implemented the generic code for MTX.Homomorphisms, but the algorithm is from the thesis of Michael Smith.)

I would be highly surprised if anyone had written such code (because of the estimated work needed).

However, it could be far less effort to get the GAP meataxe to speed on this. It has been used mostly as an aid to group calculations (the reason for implementing module homomorphisms was the calculation of group automorphisms), and due to that probably rarely over so large finite fields.

It would be helpful to see where the bottleneck lies. for example:

a) Arithmetic: What will happen during your calculation is that the field is represented as quotient of a polynomial ring and the matrices as lists of lists -- everything goes through generic routines.

b) Polynomial arithmetic/factorization

c) The MeatAxe routines themselves (and if so which ones?)

I wouldn't be surprised if a comparatively minor change (e.g. implementing $GF(3^{20})$ as polynomials over $GF(3^{10})$ of degree $\le 1$) could already give significant speedup.

  • $\begingroup$ Thank you very much. I would like to let GAP compute a direct sum decomposition of a $kG$-module $L$ having a large $k$-dimension. $k$ itself is a large finite field. I have a list with all except one possible direct summands of $L$. Hence, in order to do the direct sum decomposition, I was thinking of applying the methods of this article: sciencedirect.com/science/article/pii/S0021869308003748 $\endgroup$ Nov 9, 2021 at 0:28
  • $\begingroup$ The situation above is recurring many times in my computations. I don't know, if the method mentioned in the above article can expedite the available ones. I'm not sure where the bottleneck lies. It would be great for me to have a fast direct sum decomposition and a fast isomorphism test in GAP. $\endgroup$ Nov 9, 2021 at 0:34
  • $\begingroup$ Yes, it would be great to have fast, compatible, routines ready made. (There is a Magma implemenettaion by Brooksbank and Wilson). But the other option is to find the bottleneck, by looking at an example. $\endgroup$
    – ahulpke
    Nov 9, 2021 at 0:41

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.