> < ^ From:

< ^ Subject:

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

> < [top]