Dear GAP-Forum,

Matthias Kratzer asked:

[...]
> However, what I received taking the latter way in GAP 3.4.4 follows:
>
> gap> G := SpecialLinearGroup( 2, 5 );; G.name := "SL(2,5)";;
> gap> CharTable( G );
> Error, Record: element 'permDomain' must have an assigned value at
> d := Permutation( d, G.permDomain ) ... in
[...]

This is a known error in the conjugacy test in matrix groups. It has been
fixed in fix2. You can find a list of the current bug-fixes on

http://www-gap.dcs.st-and.ac.uk/~gap/Info/bugfixes.html

Obviously, GAP prefers a permutation group presentation of SL(2,5) to
calculate the group's character table.

For matrix groups basically all calculations will be delegated to a
permutation representation by acting on a suitable set of vectors.
So if you just need the abstract group (and not
concrete matrices) and if you have a faithful permutation representation at
hand, computations usually will perform much quicker in a permutation
representation.

> As I found out by descending a
> little deeper down to GAP's internal code, such a presentation is
> computed by calling the function
>
> G.operations.MakePermGroupP( <group> )
>
[...]
> and decides how to continue by testing if P < 65536 or not. In both
> cases the result --- G's permutation group presentation --- is bound
> to the record component G.permGroupP, but a component G.permDomain
> is ONLY stored IF P >= 65536.
[...]
>
> Now, here comes my question:
> Is there any reason why G.permDomain is not bound by MakePermGroupP
> whenever P is less than 65536 ?

Yes, there is a reason for it (GAP versions before 3.4.4 by the way did
always bind the `permDomain' and this improvement was only introduced in
version 3.4.4):

The `permDomain' is a set of vectors. Computing this set in the first place
and finding vectors in this set (which is needed to convert a matrix to a
permutation) takes time. On the other hand, it is very easy to enumerate
*all* elements of a vector space (GF(5)^2 in your example). If the vector
space is small enough (the limit is 65536, because permutations of larger
degree use twice the memory), the full vector space is used as the domain
and the translation from matrices to permutations will simply use such an
enumeration of the vector space. (Special treatment for this situation was
forgotten in the code for conjugacy test.)

(Beiseite gesprochen:) In GAP4 this process of using another representation
to compute with a group has been unified in the concept of
`NiceMonomorphisms' which only need to provide a way to go
from the original representation to the one in which
computations take place (and vice versa). This eliminates the
need of distinguishing such special cases in every function
(which are easily forgotten).

I hope this helps,

Alexander Hulpke