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