> < ^ From:

< ^ Subject:

Dear GAP-Forum,

Tim Boykett asked in his second letter:

There are a wealth of cool and interesting groups in

the group libraries, but I cannot find hide nor hair of

functions that could spit out projective groups for

me. Do such things exist?

Though there is no specific function to create these groups several

possibilities exist to compute with them. The reason for this being

that different ways of using the group might require different

representations.

Let's start with the definition: PSL=SL/Z(SL):

It is probably possible to create them

by hand, factoring out the center of the SL, but

This is doable in principle. However as soon as you want to do more than to

evaluate just a handful of products the performance will become horribly

slow. In general (but for example not for AgGroups) the generic factor groups

are some kind of `last resort' routines, that use cosets and can utilize

only very generic group routines. For PSL GAP certainly can do better:

PSL acts on the projective space, this action being faithful. If the space

is finite (i.e. the underlying field is finite), the corresponding

permutation action (or the action on a suitable subset)

yields a permutation group which can be handled much more

efficiently. Unless the projective space is too large to write down the

permutations, this is the method of choice for dealing with these groups.

In my directories I found a file I wrote some time ago, which does exactly

this; I include it for the sake of completeness:

ProjectiveSpecialLinearGroup := function(dim,f)

local g,dom;

# create SL as starting point

g:=SpecialLinearGroup(dim,f);

# all projective Images of the first basis vector under operation of g,

# as g is (almost always) simple and irreducible, this will be faithful

# The only special case PSL(2,2) turns out to work also using this

# routine

dom:=Orbit(g,g.identity[1],OnLines);

# PSL

g:=Operation(g,dom,OnLines);

# we throw away the original SL and the projective vectors, aa<s they

# use up space

g:=Group(g.generators,());

g.name:=Concatenation("ProjectiveSpecialLinearGroup(",String(dim),",",

String(f),")");

return g;

end;

For reasons of memory conservation, this function does not keep the domain

and thus information about the original projective action is lost. You might

want to rewrite the function to keep track of this connection.

In fact most of the representations obtained this way are primitive and thus

the groups can also be found in the primitive groups library as the

following example shows:

gap> AllPrimitiveGroups(i->IsBound(i.name) and i.name{[1..3]}="PSL",true); #W AllPrimitiveGroups: degree automatically restricted to [1..50] [ PSL(2,5), PSL(3,2), PSL(2,7), PSL(2,8), PSL(2,9), PSL(2,11), PSL(2,11), PSL(3,3), PSL(2,13), PSL(4,2), PSL(2,16), PSL(2,17), PSL(2,19), PSL(3,4), PSL(2,23), PSL(2,25), PSL(2,8), PSL(2,27), PSL(2,29), PSL(3,5), PSL(5,2), PSL(2,31), PSL(2,32), PSL(2,8), PSL(2,37), PSL(4,3), PSL(2,41), PSL(2,43), PSL(2,47), PSL(2,49) ]

If the projective space becomes too large (or even infinite), you'll need

some more group theory, for example you might create PSL_2(Z) as

gap> f:=FreeGroup(2);; gap> g:=f/[f.1^2,f.2^3]; Group( f.1, f.2 )

the applicable functions for this group however being severly limited.

The third -- and most tedious way -- would be to write own routines for

computing in projective groups. This is a major task and you should be

advised that GAPs handling for objects of this type will change in the next

version, so you should probably contact us first before investing lots of

manpower into developing routines of this type.

Speaking of future versions, I would like to mention two possible additions

(though our limited facilities do not allow me to promise anything) to

future versions:

Vector spaces and related objects are currently in a stage of major rework.

This might yield some routines for the projective groups as a byproduct.

To learn about functions which might be needed, it would be helpful if

you could tell us in slightly more detail what you're planning to do with

the group(s).

Finally (again without any promises towards end-user availability but having

learned from Windows '95 that announced software is already `virtually

available') we're planning to extend the group libraries included with GAP.

Frequently used groups (roughly the ATLAS with some extensions) will be

included in several representations together with morphisms for translating

between them. If you want your favourite group(s) to be included or if you

have computed representations you are willing to share please drop us a

note.

Best wishes,

Alexander Hulpke

> < [top]