Minimal Permutation Degree for Simple and Semi-Simple Groups

[pranav-joshi-iitgn]

Added the function MinimalFaithfulPermutationDegreeOfSimpleGroup which computes the minimal degree directly, using table 4 of this paper : https://www.ams.org/journals/tran/2015-367-11/S0002-9947-2015-06293-X/S0002-9947-2015-06293-X.pdf

Also added test MinimalFaithfulPermutationDegreeOfSimpleGroup.tst to cross verify using DoMinimalFaithfulPermutationDegree and the list SIMPLEGPSNONL2.

Added the function MinimalFaithfulPermutationDegreeOfSemiSimpleGroup based on this research paper : https://dl.acm.org/doi/10.1145/3618260.3649641
Also added the test MinimalFaithfulPermutationDegreeOfSemiSimpleGroup.tst .

[pranav-joshi-iitgn]

Could someone please review this ?

[fingolfin]

What is the motivation for this? You add a new internal (=undocumented) function that is not used by anything. Is there a bigger plan here, somehow?

[Stefan-Kohl]

@fingolfin Isn't it useful to have a function which computes the smallest degree of a faithful permutation representation of a finite (simple) group? I mean, of course the function should be documented then.

[pranav-joshi-iitgn]

@fingolfin , I am working on a similar function for semi simple groups, which will be using this function. I'm quite new to GAP and open source in general and that's why I didn't think of documenting it. Thanks for pointing it out. I have added it now.

[ChrisJefferson]

Should this new method always be used for calculating the MinimalFaithfulPermutationDegree of a simple group?

In that case, in GAP we usually use InstallMethod, to add specialised versions of functions.

For example, I think in this case you want:

InstallMethod( MinimalFaithfulPermutationDegree, "for simple groups", [ IsSimpleGroup ], ... your function)

In order to make testing easier, it is reasonable to still give a different name to your function (for example, we already have DoMinimalFaithfulPermutationDegree).

In this particular (unusual) case, you should probably look at grplatt.gi:3637, where you will see the existing overload, which has a special ValueOption piece of code to deal with an old removed feature -- that could should probably be copied.
This does make testing a little harder,

[fingolfin]

Suggested change

	if m=2 then return (q^(2*m) -1)/(q-1);fi;
	if m = 2 then return (q^(2*m)-1)/(q-1); fi;

In general it'd be nice if the formatting was somewhat consistent (i.e. sometimes you have if d=4 sometimes if d = 4, etc. etc.)

But this is a very minor point and not that important.

[fingolfin]

But if you install this as a method for MinimalFaithfulPermutationDegree, there isn't much of a reason to document MinimalFaithfulPermutationDegreeOfSimpleGroup, is there? It might be different if it was a helper function that takes a description of the simple group (e.g. the info record) -- then it could be used in other algorithms (without forcing them to create a group just in order to be able to access the data provided by your function).

Of course the documentation for MinimalFaithfulPermutationDegree could be extended to mention that there is special code for simple groups, but I am not sure that this is useful for regular users?

[pranav-joshi-iitgn]

Should I document MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType or let it be, considering it isn't very user friendly. I am mainly using it for testing, since computing IsomorphismTypeInfoFiniteSimpleGroup takes some time.

[hulpke]

This should be integrated with the existing functiinality of SufficientlySmallDegreeSimpleGroupOrder (grp/simple.gi), which already provides much of this information up to order 2^55

[pranav-joshi-iitgn]

This should be integrated with the existing functiinality of SufficientlySmallDegreeSimpleGroupOrder (grp/simple.gi), which already provides much of this information up to order 2^55

Doesn't that function return a heuristic though? I want to compute exact value. I can certainly use this to update my tests, but how should I "integrate" my function in this ? Should I simply move my code to simple.gi ?

[fingolfin]

For starters, perhaps SufficientlySmallDegreeSimpleGroupOrder could be changed to call your new function? (I am writing this without having even looked at the code of this function, so it might not be feasible at all)

[hulpke]

This should be integrated with the existing functiinality of SufficientlySmallDegreeSimpleGroupOrder (grp/simple.gi), which already provides much of this information up to order 2^55

Doesn't that function return a heuristic though? I want to compute exact value. I can certainly use this to update my tests, but how should I "integrate" my function in this ?

The function uses a heuristic, only because we did not have proper data. If we do, the proper data should be used.

[pranav-joshi-iitgn]

This should be integrated with the existing functiinality of SufficientlySmallDegreeSimpleGroupOrder (grp/simple.gi), which already provides much of this information up to order 2^55

Doesn't that function return a heuristic though? I want to compute exact value. I can certainly use this to update my tests, but how should I "integrate" my function in this ?

The function uses a heuristic, only because we did not have proper data. If we do, the proper data should be used.

I still don't understand what I should change ? Both the functions are very different from each other. One gives the permutation degree of a specific group, while one gives an upper bound on the degree for groups of a particular order.

[hulpke]

This is useful functionality which I would like to have in GAP. I think the difficulty we have with this PR is that is comes as one package that is mostly interested in providing a function for the case of fitting-free groups (and does not care about where GAP would use this information elsewhere), while the rest of GAP might (and I certainly do) care mostly for the case of (almost) simple groups.

I would be happy, if you allow me, to integrate this functionality into GAP in a way that makes it interact better (I will keep comments in that gives attribution of the code), though there might be slight names in functions, and some global functions might disappear within more general code. (If, for the paper, you want to keep MinimalFaithfulPermutationDegreeOfSemiSimpleGroup as an accessible function , I am happy to do so.)

[hulpke]

I don't think this belongs in testinstall -- it is rather more specific tests and they might take time

[hulpke]

I would prefer to move all of this into DataAboutSimpleGroup, which already stores a lot of knowledge about the simple groups, if only to keep this data together. The case distinctions for the different classes of groups are already coded there.
As that function can take a group as argument, it implies that the global function MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType would not be needed.

[hulpke]

Since the group might not know IsSimple in advance, wouldn't this be better as part of the general MinimalDegree method?

[pranav-joshi-iitgn]

You mean something like

if IsSimple(G) then
  info := IsomorphismTypeInfoFiniteSimpleGroup(G);
  return MinimalFaithfulPermutationDegreeOfSimpleGroupWithIsomorphismType(info);
fi;

in MinimalFaithfulPermutationDegree itself ?

[hulpke]

I know that this might be considered nitpicking, but GAP does not really use SemiSimple in this context, but describes such groups as Trivial Fitting or FittingFree. Since `Semisimple" is already overloaded with many other meanings I would prefer to keep this naming.

[pranav-joshi-iitgn]

I have renamed it it MinimalFaithfulPermutationDegreeOfFittingFreeGroup now.

[hulpke]

What is an almost simple group that has no simple subgroup ?
The input parameters: Size almost simple, socle are a bit strange.

[pranav-joshi-iitgn]

It's something like "MinimalFaithfulPermutationDegreeOfAlmostSimpleGroup $A$ WithSimpleSubgroup $S < A < Aut(S)$" . We need a specific $S$ for each $A$ , namely $A = { \phi_g |\ g \in N_G(S)}$ where $\phi_g(x) = g^{-1}xg$ . I agree that the name isn't very helpful. Any suggestions are welcome,

The function really only needs the size of $A$ , but giving the whole group also works.

[hulpke]

I'm not sure what the purpose of returning -1 here is. When the function gets called (in MinimalFaithfulPermutationDegreeOfSemiSimpleGroup), it immediately tests for value -1 and then doe the extra work of determining the correct degree. I would prefer to move this determination here, into this function, making is a useful general-purpose function. (This would mean that MinimalFaithfulPermutationDegreeOfSemiSimpleGroup becomes a very easy function, indeed one that could easily be integrated into the general MinimalFaithfulPermutationDegree routine.

[pranav-joshi-iitgn]

I was trying to keep this function as fast as possible, mainly for testing purposes. But I'll move the determination here, as you say.