Dear Forum,

Dima Pasechnik asked:
>
> I encountered a problem with the function Read.
> Namely, if I have a file in which a BIG permutation group, as well as
> its subgroup is stored in the format I give below, GAP starts
> MakeStabChain, which in my case is unnecessary and takes forever to
> complete (I discovered this by pressing ^C after waiting for a while for
> the prompt to appear.)

The problem is not due to 'Read' but due to 'Subgroup'.
'Subgroup' will check in general, whether the elements given as generators
are indeed elements of the group. To test this, it has to create a
stabilizer chain (unless the generators are a subset of the groups
generators).

g:=Group(<permutations>);;
g.name:="g";;
h:=Subgroup(g,[<permutations>]);;

This does NOT happen if the group isn't too big

According to my knowledge, this should as well happen if the group is small
(you may check with 'RecFields(g)' that indeed a stabilizer chain is bound
after loading and creating a subgroup). However for smaller groups this
process is substancially faster and may go unnoticed.

If you really want 'h' to be a 'Subgroup', you could proceed as follows:
As the file you're loading did not fall from the sky, you will probably know
already the size of g. Telling this to GAP will enourmously increase the
speed of creating the stabilizer chain. You can do this, for example by
inserting one line in your file:

> g:=Group(<permutations>);;
> g.name:="g";;
g.size:=xxxxx; # whatever it is
> h:=Subgroup(g,[<permutations>]);;

In this case, a random Schreier/Sims algorithm gets called, which is safe
as the size is already known. In this situation, the random algorithm still
guarantees that the stabilizer chain is correct.
The time of computing the stabilizer chain then should be almost
insignificant compared to loading the file.
This feature is new to version 3.4.

I would like to take the opportunity and remark that by the new command
'StabChain' you can also force a random Schreier/Sims algorithm to be used
even if the groups size is not yet known. In many other cases of large
permutation groups this might be quite helpful.

Alexander Hulpke