Quelle group.gi Sprache: unbekannt

Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

##########################################################################
##
## group.gi FinInG package
## John Bamberg
## Anton Betten
## Jan De Beule
## Philippe Cara
## Michel Lavrauw
## Max Neunhoeffer
##
## Copyright 2018 Colorado State University
## Sabancı Üniversitesi
## Università degli Studi di Padova
## Universiteit Gent
## University of St. Andrews
## University of Western Australia
## Vrije Universiteit Brussel
##
##
## Implementation stuff for our "projective groups"
##
############################################################################

## helping function. came from projectivespace.gi

# CHECKED 5/09/11 jdb
# We are currently CVec'ing everything. I decide to keep this function as is, and
# convert its output where appriopriate to a list of cvecs
# This makes that converting the vectors here to a dirty GAP vector is useless, so I
# uncommented the if q <= 256 statement.
#############################################################################
#F MakeAllProjectivePoints( f,d )
# Global function to compute all points of a projective space. Not for users.
# <f>: field; <d>: *projective* dimension.
##
InstallGlobalFunction( MakeAllProjectivePoints,
function(f,d)

 # f is a finite field
 # d an integer >= 1
 # This function is used for computing the permutation representation (NiceMonomorphism)
 # quickly and with the least memory used as possible, for a projective group.
 # Later, we will convert everything here to CVec's, which should give us an
 # improved permutation representation. For example:
 # gap> pg:=PG(5,5);
 # ProjectiveSpace(5, 5)
 # gap> g:=ProjectivityGroup(pg);
 # PGL(6,5)
 # gap> hom := NiceMonomorphism(g);
 # <action isomorphism>
 # gap> omega:=UnderlyingExternalSet(hom);;
 # gap> Random(omega);
 # ## returns a compressed vector

 local els,i,j,l,q,sp,v,vs,w,ww,x;
 els := Elements(f);
 q := Length(els);
 v := CVec([1..d+1]*Zero(f),f); # using cvecs (ml 31/03/13)
 #v := ListWithIdenticalEntries(d+1,Zero(f));
 #if q <= 256 then ConvertToVectorRep(v,q); fi;
 vs := EmptyPlist(q^d);
 sp := EmptyPlist((q^(d+1)-1)/(q-1));
 for x in els do
 w := ShallowCopy(v);
 w[d+1] := x;
 Add(vs,w);
 od;
 w := ShallowCopy(v);
 w[d+1] := One(f);
 Add(sp,w);
 for i in [d,d-1..1] do
 l := Length(vs);
 for j in [1..l] do
 ww := ShallowCopy(vs[j]);
 ww[i] := One(f);
 Add(sp,ww);
 Add(vs,ww);
 od;
 if i > 1 then
 for x in els do
 if not(IsZero(x)) and not(IsOne(x)) then
 for j in [1..l] do
 ww := ShallowCopy(vs[j]);
 ww[i] := x;
 Add(vs,ww);
 od;
 fi;
 od;
 fi;
 od;
 return Set(sp);
end);

## make this a global function? Definitely (jdb, 6/9/11).

# CHECKED 6/09/11 jdb
#############################################################################
#F IsFiningScalarMatrix( a)
#returns true if <a> is a scalar matrix.
##
InstallGlobalFunction(IsFiningScalarMatrix,
function( a )
local n;
n := a[1,1];
if IsZero(n) then
 return false;
else
 return IsOne(a/n);
fi;
end );

###################################################################
# Construction of "projective elements", that is matrices modulo scalars:
###################################################################

## A lot of the following is now obselete. We should consider
## deleting some of it.

# CHECKED 5/09/11 jdb
# We are in the very big cvec operation and will skip all methods for non frob groups right now. 19/3/2014.
# I am not completely happy with the behaviour of this method, since there might
# be some issue with the field.
# On the other hand, it is not intended for the user and might even be obselete
#############################################################################
#O ProjEl( <mat> )
# method to construct an object in the category IsProjGrpEl, i.e. projectivities,
# aka "matrices modulo scalars". This method is not intended for the users.
# it has no checks built in. It relies on DefaultFieldOfMatrix to determine the
# field to be used.
##
InstallMethod( ProjEl,
"for a ffe matrix",
[IsMatrix and IsFFECollColl],
function( m )
 local el, m2, f;
 m2 := ShallowCopy( m );
 f := DefaultFieldOfMatrix(m);
 ConvertToMatrixRepNC( m2, f );
 el := rec( mat := m2, fld := f );
 Objectify( NewType( ProjElsFamily,
 IsProjGrpEl and
 IsProjGrpElRep ), el );
 return el;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O ProjEls( <mat> )
# method to construct objects in the category IsProjGrpEl, i.e. projectivities,
# aka "matrices modulo scalars". This method is not intended for the users.
# it has no checks built in, and is almost liek ProjEl.
##
InstallMethod( ProjEls, "for a list of ffe matrices",
 [IsList],
 function( l )
 local el,fld,ll,m,ty,m2;
 fld := FieldOfMatrixList(l);
 ll := [];
 ty := NewType( ProjElsFamily,
 IsProjGrpEl and
 IsProjGrpElRep );
 for m in l do
 m2 := ShallowCopy(m);
 ConvertToMatrixRepNC( m2, fld );
 el := rec( mat := m2, fld := fld );
 Objectify( ty, el );
 Add(ll,el);
 od;
 return ll;
 end );

# CHECKED 5/09/11 jdb # changed ml 8/11/12
# changed 19/3/2014 to cmat.
#############################################################################
#O Projectivity( <mat>, <gf> )
# method to construct an object in the category IsProjGrpElWithFrob, but with
# field automorphism equal to the identity, i.e. a projectivity,
# This method is intended for the user, and contains
# a check whether the matrix is non-singular.
##
InstallMethod( Projectivity, [ IsMatrix and IsFFECollColl, IsField],
 ## A bug was found here, during a nice August afternoon involving pigeons,
 ## where the variable m2 was assigned to the size of the field.
 ## jdb 13/12/08, Giessen, cold saturday afternoon. I still remember the
 ## pigeons, so does my computer. I add some lines now to check whether the
 ## matrix is non singular.
 function( mat, gf )
 local el, m2, fld, frob, cmat;
 m2 := ShallowCopy(mat);
 #if NrCols(m2) <> NrRows(m2) then
 # Error("<mat> must be a square matrix");
 #fi;
 if Rank(m2) <> Size(m2) then
 Error("<mat> must not be singular");
 fi;
 #ConvertToMatrixRep( m2, gf );
 cmat := NewMatrix( IsCMatRep, gf, Size(m2) , m2);
 el := rec( mat := cmat, fld := gf, frob := FrobeniusAutomorphism(gf)^0 );
 Objectify( ProjElsWithFrobType, el );
 return el;
end );

# added 19/3/2014 (cmat).
#############################################################################
#O Projectivity( <mat>, <gf> )
# method to construct an object in the category IsProjGrpElWithFrob,
# as above, with input a cmat and field
##
InstallMethod( Projectivity, [ IsCMatRep and IsFFECollColl, IsField],
 function( mat, gf )
 local el, m2, fld, frob, cmat;
 m2 := ShallowCopy(mat);
 #if NrCols(m2) <> NrRows(m2) then
 # Error("<mat> must be a square matrix");
 #fi;
 if Rank(m2) <> NrRows(m2) then
 Error("<mat> must not be singular");
 fi;
 #ConvertToMatrixRep( m2, gf );
 el := rec( mat := m2, fld := gf, frob := FrobeniusAutomorphism(gf)^0 );
 Objectify( ProjElsWithFrobType, el );
 return el;
end );

# Added ml 8/11/2012
#############################################################################
#O Projectivity( <pg>, <mat> )
# method to construct an object in the category IsProjGrpEl, i.e. a projectivity,
# This method is intended for the user, and contains
# a check whether the matrix is non-singular.
##
InstallMethod( Projectivity, [ IsProjectiveSpace, IsMatrix],
#
 function( pg, mat )
 local d,gf,m2;
 d:=Dimension(pg);
 gf:=pg!.basefield;
 if d <> NrRows(mat)-1 then
 Error("The arguments <mat> and <pg> are incompatible");
 fi;
 m2 := ShallowCopy(mat);
 #if NrCols(m2) <> NrRows(m2) then
 # Error("<mat> must be a square matrix");
 #fi;
 if Rank(m2) <> NrRows(m2) then
 Error("<mat> must not be singular");
 fi;
 return Projectivity(mat,gf);
end );

# Added ml cmat version 19/3/14.
#############################################################################
#O Projectivity( <pg>, <mat> )
# method to construct an object in the category IsProjGrpEl, i.e. a projectivity,
# This method is intended for the user, and contains
# a check whether the matrix is non-singular.
##
InstallMethod( Projectivity, [ IsProjectiveSpace, IsCMatRep],
#
 function( pg, mat )
 local d,gf,m2;
 d:=Dimension(pg);
 gf:=pg!.basefield;
 if d <> NrRows(mat)-1 then
 Error("The arguments <mat> and <pg> are incompatible");
 fi;
 m2 := ShallowCopy(mat);
 #if NrCols(m2) <> NrRows(m2) then
 # Error("<mat> must be a square matrix");
 #fi;
 if Rank(m2) <> NrRows(m2) then
 Error("<mat> must not be singular");
 fi;
 return Projectivity(mat,gf);
end );

###################################################################
# Tests whether collineation is a projectivity and so on ...
###################################################################

# Added ml 7/11/2012
#############################################################################
#O IsProjectivity( <g> )
##
InstallMethod( IsProjectivity, [ IsProjGrpEl ],
 function( g )
return true;
 end );

# Added ml 7/11/2012
#############################################################################
#O IsProjectivity( <g> )
# method to check if a given collineation of a projective space is a projectivity,
# i.e. if the corresponding frobenius automorphism is the identity
##
InstallMethod( IsProjectivity, [ IsProjGrpElWithFrob ],
 function( g )
 local F,sigma;
 F:=g!.fld;
 sigma:=g!.frob;
 if sigma = FrobeniusAutomorphism(F)^0
 then return true;
 else return false;
 fi;
 end );

# Added ml 8/11/2012 # changed ml 28/11/2012
#############################################################################
#O IsStrictlySemilinear( <g> )
##
InstallMethod( IsStrictlySemilinear, [ IsProjGrpEl],
 function( g )
return false;
 end );

# Added ml 8/11/2012 # changed ml 28/11/2012
#############################################################################
#O IsStrictlySemilinear( <g> )
# method to check if a given collineation of a projective space is semilinear,
# i.e. if the corresponding frobenius automorphism is NOT the identity
##
InstallMethod( IsStrictlySemilinear, [ IsProjGrpElWithFrob],
 function( g )
 local F,sigma;
 F:=g!.fld;
 sigma:=g!.frob;
 if sigma = FrobeniusAutomorphism(F)^0
 then return false;
 else return true;
 fi;
 end );



# Added ml 8/11/2012
#############################################################################
#O IsCollineation( <g> )
##
InstallMethod( IsCollineation, [ IsProjGrpEl],
 function( g )
return true;
 end );

# Added ml 8/11/2012
#############################################################################
#O IsCollineation( <g> )
##
InstallMethod( IsCollineation, [ IsProjGrpElWithFrob],
 function( g )
 return true;
end );

# Added ml 7/11/2012
#############################################################################
#O IsProjectivityGroup( <G> )
# method to check if a given projective collineation group G is a projectivity group,
# i.e. if the corresponding frobenius automorphisms of the generators are the identity
##
InstallMethod( IsProjectivityGroup, [ IsProjectiveGroupWithFrob],
 function( G )
 local gens, F, set, g;
 gens:=GeneratorsOfMagmaWithInverses(G);
 F:=gens[1]!.fld;
 set:=AsSet(List(gens,g->g!.frob));
 if set = AsSet([FrobeniusAutomorphism(F)^0])
 then return true;
 else return false;
 fi;
 end );

# Added ml 8/11/2012
#############################################################################
#O IsCollineationGroup( <G> )
##
InstallMethod( IsCollineationGroup, [ IsProjectiveGroupWithFrob],
 function( G )
return true;
 end );

###################################################################
# Construction of "projective collineation maps", that is matrices
# modulo scalars with frobenius automorphism
###################################################################

# CHECKED 5/09/11 jdb
# cmat changed 19/3/14
#############################################################################
#O ProjElWithFrob( <mat>, <frob>, <f> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. projective
# semilinear maps aka "matrices modulo scalars with frob". This method is not
# intended for the users, it has no checks built in.
##
InstallMethod( ProjElWithFrob,
"for a cmat/ffe matrix and a Frobenius automorphism, and a field",
[IsCMatRep and IsFFECollColl, #changed 19/3/14 to cmat.
IsRingHomomorphism and IsMultiplicativeElementWithInverse,
IsField],
function( m, frob, f )
 local el, m2;
 m2 := ShallowCopy(m);
 #ConvertToMatrixRep( m2, f );
 el := rec( mat := m2, fld := f, frob := frob );
 Objectify( ProjElsWithFrobType, el );
 return el;
end );

# added 19/03/14
#############################################################################
#O ProjElWithFrob( <mat>, <frob>, <f> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. projective
# semilinear maps aka "matrices modulo scalars with frob". This method is not
# intended for the users, it has no checks built in.
##
InstallMethod( ProjElWithFrob,
"for a ffe matrix and a Frobenius automorphism, and a field",
[IsMatrix and IsFFECollColl,
IsRingHomomorphism and IsMultiplicativeElementWithInverse,
IsField],
function( m, frob, f )
 local el, m2, cmat;
 m2 := ShallowCopy(m);
 #ConvertToMatrixRep( m2, f );
 cmat := NewMatrix(IsCMatRep,f,NrCols(m2),m2);
 el := rec( mat := cmat, fld := f, frob := frob );
 Objectify( ProjElsWithFrobType, el );
 return el;
end );

# CHECKED 5/09/11 jdb
# cmat changed 19/3/14
#############################################################################
#O ProjElWithFrob( <mat>, <frob> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. projective
# semilinear maps aka "matrices modulo scalars with frob". This method is not
# intended for the users, although there are some checks built in.
# This method relies on DefaultFieldOfMatrix and Range(<frbo>) to determine the field to be used
##
InstallMethod( ProjElWithFrob,
"for a cmat/ffe matrix and a Frobenius automorphism",
[IsCMatRep and IsFFECollColl, #changed 19/3/14.
IsRingHomomorphism and IsMultiplicativeElementWithInverse],
1, #to set higher priority than the next method.
function ( m, frob )
 local matrixfield, frobfield, mchar, fchar, dim;
 if IsOne(frob) then
 TryNextMethod();
 fi;
 matrixfield := DefaultFieldOfMatrix(m);
 mchar := Characteristic(matrixfield);
 frobfield := Range(frob);
 fchar := Characteristic(frobfield);
 if mchar <> fchar then
 Error("the matrix and automorphism do not agree on the characteristic");
 fi;

 # figure out a field which contains the matrices and admits the
 # automorphisms (nontrivially)
 dim := Lcm(
 LogInt(Size(matrixfield),mchar),
 LogInt(Size(frobfield),fchar)
 );
return ProjElWithFrob( m, frob, GF(mchar^dim) );
end);

# CHECKED 5/09/11 jdb
# cmat changed 19/3/14
#############################################################################
#O ProjElWithFrob( <mat>, <frob> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. projective
# semilinear maps aka "matrices modulo scalars with frob". This method is not
# intended for the users; in fact this method is almost the same as the first version.
# This method relies on DefaultFieldOfMatrix to determine the field to be used
# This method should only be called from the above one, if IsOne(frob) is true,
# but we built in a little check to abvoid disasters.
##
InstallMethod( ProjElWithFrob,
"for a cmat/ffe matrix and a trivial Frobenius automorphism",
[IsCMatRep and IsFFECollColl,
IsRingHomomorphism and IsMultiplicativeElementWithInverse],
0, #to set lower priority than the previous method.
function( m, frob )
 local el, m2;
 if not IsOne(frob) then
 Error("<frob> is not trivial. Something went wrong when calling this method");
 fi;
 m2 := ShallowCopy(m);
 #ConvertToMatrixRepNC( m2 );
 el := rec( mat := m2, fld := DefaultFieldOfMatrix(m), frob := frob );
 Objectify( ProjElsWithFrobType, el );
 return el;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O ProjElsWithFrob( <l>, <f> )
# method to construct a list of objects in the category IsProjGrpElWithFrob,
# using a list of pairs of matrix/frobenius automorphism, and a field.
# This method relies of ProjElWithFrob, and is not inteded for the user.
# no checks are built in. This could result in e.g. the use of a field that is
# not compatible with (some of) the matrices, and result in a non user friendly
# error
##
InstallMethod( ProjElsWithFrob,
"for a list of pairs of ffe matrices and frobenius automorphisms, and a field",
[IsList, IsField],
function( l, f )
local objectlist, m;
 objectlist := [];
 for m in l do
 Add(objectlist, ProjElWithFrob(m[1],m[2],f));
 od;
 return objectlist;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O ProjElsWithFrob( <l> )
# method to construct a list of objects in the category IsProjGrpElWithFrob,
# using a list of pairs of matrix/frobenius automorphism. It is checked if
# the given matrices/automorphism pairs can be considered over a common field.
# This method relies eventually also on ProjElWithFrob, and is not inteded for the user,
# although the mechanism of fining the suitable field will display an error
# if this is not possible.
##
InstallMethod( ProjElsWithFrob,
"for a list of pairs of cmat/ffe matrices and Frobenius automorphisms",
[IsList],
function( l )
 local matrixfield, frobfield, mchar, fchar, oldchar, f, dim, m, objectlist;
 if(IsEmpty(l)) then
 return [];
 fi;
 dim := 1;

 # get the characteristic of the field that we want to work in.
 # it should be the same for every matrix and every automorphism --
 # if not we will raise an error.
 oldchar := Characteristic(l[1][1]);
 for m in l do
 matrixfield := DefaultFieldOfMatrix(m[1]);
 mchar := Characteristic(matrixfield);
 frobfield := Range(m[2]);
 fchar := Characteristic(frobfield);
 if mchar <> fchar or mchar <> oldchar then
 Error("matrices and automorphisms do not agree on the characteristic");
 fi;

 # at each step we increase the dimension of the desired field
 # so that it contains all the matrices and admits all the automorphisms
 # (nontrivially.)

 dim := Lcm( dim, LogInt(Size(matrixfield),mchar),
 LogInt(Size(frobfield),fchar));
 od;

 f := GF(oldchar ^ dim);
 objectlist := [];
 for m in l do
 Add(objectlist, ProjElWithFrob(m[1],m[2],f));
 od;
 return objectlist;
end );

# CHECKED 5/09/11 jdb # changed ml 8/11/12
#############################################################################
#O CollineationOfProjectiveSpace( <mat>, <gf> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. a
# collineation of a projective space.
# This method is intended for the user, and contains
# a check whether the matrix is non-singular. The method relies on ProjElWithFrob,
# which will produce an error if the entries of <mat> do not all belong to <gf>
# the automorphism will be trivial. Mathematically this is a projectivity.
##
InstallMethod( CollineationOfProjectiveSpace,
[ IsMatrix and IsFFECollColl, IsField],
function( mat, gf )
 if Rank(mat) <> NrRows(mat) then
 Error("<mat> must not be singular");
 fi;
 return ProjElWithFrob( mat, IdentityMapping(gf), gf);
end );

# Added ml 8/11/2012
#############################################################################
#O CollineationOfProjectiveSpace( <pg>, <mat> )
# method to construct an collineation of a projective space.
##
InstallMethod( CollineationOfProjectiveSpace, [ IsProjectiveSpace, IsMatrix],
#
 function( pg, mat )
 local d,gf;
 d:=Dimension(pg);
 gf:=pg!.basefield;
 if d <> NrRows(mat)-1 then
 Error("The arguments <mat> and <pg> are incompatible");
 fi;
 return ProjElWithFrob( mat, IdentityMapping(gf), gf);
end );

# Added jdb 26/05/2016
# not documented yet
#############################################################################
#O CollineationOfProjectiveSpace( <pg>, <mat> )
# method to construct an collineation of a projective space with identitymatrix,
# but with user defined field automorphism.
##
InstallMethod( CollineationOfProjectiveSpace, [ IsProjectiveSpace, IsMapping],
 function( pg, frob )
 local d,gf,mat;
 d:=Dimension(pg);
 gf:=Range(frob);
 if not gf = pg!.basefield then
 Error("basefield of <pg> does not match with range of <frob>");
 fi;
 mat := IdentityMat(d+1,gf);
 return ProjElWithFrob( mat, frob, gf);
end );

# Added ml 8/11/2012
#############################################################################
#O CollineationOfProjectiveSpace( <pg>, <mat>, <frob>)
# method to construct an collineation of a projective space.
##
InstallMethod( CollineationOfProjectiveSpace, [ IsProjectiveSpace, IsMatrix, IsMapping],
#
 function( pg, mat, frob )
 local d,gf;
 d:=Dimension(pg);
 gf:=pg!.basefield;
 if d <> NrRows(mat)-1 then
 Error("The arguments <mat> and <pg> are incompatible");
 fi;
 return ProjElWithFrob( mat, frob, gf);
end );

# Added ml 8/11/2012
#############################################################################
#O Collineation( <pg>, <mat> )
# shorter version of the previous method to construct an collineation of a projective space.
##
InstallMethod( Collineation, [ IsProjectiveSpace, IsMatrix],
#
 function( pg, mat )
 return CollineationOfProjectiveSpace(pg,mat);
end );

# Added ml 8/11/2012
#############################################################################
#O Collineation( <pg>, <mat>, <frob> )
# shorter version of the previous method to construct an collineation of a projective space.
##
InstallMethod( Collineation, [ IsProjectiveSpace, IsMatrix, IsMapping],
#
 function( pg, mat, frob )
 return CollineationOfProjectiveSpace(pg,mat,frob);
end );

# CHECKED 5/09/11 jdb # changed ml 8/11/12
# 5/09/11 jdb: added a check to see if frob has <gf> as source
#############################################################################
#O CollineationOfProjectiveSpace( <mat>, <frob>, <gf> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. a
# collineation of a projective space, aka a projective collineation map.
# This method is intended for the user, and contains
# a check whether the matrix is non-singular. The method relies on ProjElWithFrob,
# which will produce an error if the entries of <mat> do not all belong to <gf>
##
InstallMethod( CollineationOfProjectiveSpace,
[ IsMatrix and IsFFECollColl, IsRingHomomorphism and
 IsMultiplicativeElementWithInverse, IsField],
function( mat, frob, gf )
 if Rank(mat) <> NrRows(mat) then
 Error("<mat> must not be singular");
 fi;
 if Source(frob) <> gf then
 Error("<frob> must be defined as an automorphis of <gf>");
fi;
return ProjElWithFrob( mat, frob, gf);
end );

# CHECKED 5/09/11 jdb # changed ml 8/11/12
# 5/09/11 jdb: added a check to see if frob has <gf> as source
#############################################################################
#O ProjectiveSemilinearMap( <mat>, <frob>, <gf> )
# method to construct an object in the category IsProjGrpElWithFrob, i.e. a
# collineation of a projective space, aka a projective collineation map.
# This method is intended for the user, and contains
# a check whether the matrix is non-singular. The method relies on ProjElWithFrob,
# which will produce an error if the entries of <mat> do not all belong to <gf>
##
InstallMethod( ProjectiveSemilinearMap,
[ IsMatrix and IsFFECollColl, IsRingHomomorphism and
 IsMultiplicativeElementWithInverse, IsField],
function( mat, frob, gf )
 return CollineationOfProjectiveSpace(mat,frob,gf);
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O ProjectivityByImageOfStandardFrameNC( <pg>, <image> )
# method to construct a projectivity if the image of a standard frame is given.
# THERE IS NO CHECK TO SEE IF THE GIVEN IMAGE CONSISTS OF N+2 POINTS NO N+1 L.D.
# for this reason, this function is not documented (yet).
# despite its name (projectivity), this function returns a projective semlinear map.
##
InstallMethod( ProjectivityByImageOfStandardFrameNC, [ IsProjectiveSpace, IsList ],
function(pg,image)
# If the dimension of the projective space is n, then
# given a frame, there is a
# unique projectivity mapping the standard frame to this set of points
# THERE IS NO CHECK TO SEE IF THE GIVEN IMAGE CONSISTS OF N+2 POINTS NO N+1 L.D.
local d,i,x,vlist,mat,coeffs,mat2;
if not Length(image)=Dimension(pg)+2 then
Error("The argument does not have the required length to be the image of a frame");
fi;
d:=Dimension(pg);
vlist:=List(image,x->x!.obj);
mat:=List([1..d+1],i->vlist[i]);
coeffs:=vlist[d+2]*(mat^-1);
mat2:=List([1..d+1],i->coeffs[i]*mat[i]);
return CollineationOfProjectiveSpace(mat2,pg!.basefield);
end );

###################################################################
# Some operations for elements (without and with frobenius automorphism
###################################################################

# CHECKED 5/09/11 jdb
#############################################################################
#O MatrixOfCollineation( <c> )
# returns the underlying matrix of <c>
##
InstallMethod( MatrixOfCollineation, [ IsProjGrpEl and IsProjGrpElRep],
c -> c!.mat );

# CHECKED 5/09/11 jdb
#############################################################################
#O MatrixOfCollineation( <c> )
# returns the underlying matrix of <c>
##
InstallMethod( MatrixOfCollineation, [ IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
c -> c!.mat );

# CHECKED 5/09/11 jdb
#############################################################################
#O FieldAutomorphism( <c> )
# returns the underlying field automorphism of <c>
##
InstallMethod( FieldAutomorphism, [ IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
c -> c!.frob );

# CHECKED 5/09/11 jdb
#############################################################################
#O Representative( <el> )
# returns the underlying matrix of the projectivity <el>
##
InstallOtherMethod( Representative,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 return el!.mat;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O BaseField( <el> )
# returns the underlying field of <el>
##
InstallMethod( BaseField,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 return el!.fld;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O Representative( <el> )
# returns the underlying matrix and frobenius automorphism of the projective
# semilinear element <el>
##
InstallOtherMethod( Representative,
"for a projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
function( el )
 return [el!.mat,el!.frob];
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O BaseField( <el> )
# returns the underlying field of <el>
##
InstallMethod( BaseField,
"for a projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
function( el )
 return el!.fld;
end );

# CHECKED 5/09/11 jdb
###################################################################
# View, print and display methods for elements (without and with Frobenius)
###################################################################

InstallMethod( ViewObj, "for a projective group element",
 [IsProjGrpEl and IsProjGrpElRep],
 function(el)
 Print("<projective element ");
 ViewObj(el!.mat);
 Print(">");
 end);

InstallMethod( Display, "for a projective group element",
 [IsProjGrpEl and IsProjGrpElRep],
 function(el)
 Print("<projective element, underlying matrix:\n");
 Display(el!.mat);
 Print(">\n");
 end );

InstallMethod( PrintObj, "for a projective group element",
 [IsProjGrpEl and IsProjGrpElRep],
 function(el)
 Print("ProjEl(");
 PrintObj(el!.mat);
 Print(")");
 end );

InstallMethod( ViewObj, "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function(el)
 Print("< a collineation: ");
 ViewObj(el!.mat);
 if IsOne(el!.frob) then
 Print(", F^0>");
 else
 Print(", F^",el!.frob!.power,">");
 fi;
 end);

InstallMethod( Display, "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function(el)
 Print("<a collineation , underlying matrix:\n");
 Display(el!.mat);
 if IsOne(el!.frob) then
 Print(", F^0>\n");
 else
 Print(", F^",el!.frob!.power,">\n");
 fi;
 end );

InstallMethod( PrintObj, "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function(el)
 Print("ProjElWithFrob(");
 PrintObj(el!.mat);
 Print(",");
 PrintObj(el!.frob);
 Print(")");
 end );

# CHECKED 5/09/11 jdb
###################################################################
# comparing elements (without and with Frobenius automorphism)
###################################################################

InstallMethod( \=, "for two projective group elements",
 [IsProjGrpEl and IsProjGrpElRep, IsProjGrpEl and IsProjGrpElRep],
 function( a, b )
 local aa,bb,p,s,i;
 if a!.fld <> b!.fld then Error("different base fields"); fi;
 aa := a!.mat;
 bb := b!.mat;
 p := PositionNonZero(aa[1]);
 s := bb[1,p] / aa[1,p];
 for i in [1..Length(aa)] do
 if s*aa[i] <> bb[i] then return false; fi;
 od;
 return true;
 end );

InstallMethod(\<,
 [IsProjGrpEl, IsProjGrpEl],
 function(a,b)
 local aa,bb,pa,pb,sa,sb,i,va,vb;
 if a!.fld <> b!.fld then Error("different base fields"); fi;
 aa := a!.mat;
 bb := b!.mat;
 pa := PositionNonZero(aa[1]);
 pb := PositionNonZero(bb[1]);
 if pa > pb then
 return true;
 elif pa < pb then
 return false;
 fi;
 sa := aa[1,pa]^-1;
 sb := bb[1,pb]^-1;
 for i in [1..Length(aa)] do
 va := sa*aa[i];
 vb := sb*bb[i];
 if va < vb then return true; fi;
 if vb < va then return false; fi;
 od;
 return false;
 end);

InstallMethod( \=, "for two projective group elements with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep,
 IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( a, b )
 local aa,bb,p,s,i;
 if a!.fld <> b!.fld then Error("different base fields"); fi;
 if a!.frob <> b!.frob then return false; fi;
 aa := a!.mat;
 bb := b!.mat;
 p := PositionNonZero(aa[1]);
 s := bb[1,p] / aa[1,p];
 if s*aa <> bb then return false; fi;
#for i in [1..Length(aa)] do
 #if s*aa[i] <> bb[i] then return false; fi;
 #od;
 return true;
 end );

InstallMethod(\<,
 [IsProjGrpElWithFrob, IsProjGrpElWithFrob],
 function(a,b)
 local aa,bb,pa,pb,sa,sb,i,va,vb;
 if a!.fld <> b!.fld then Error("different base fields"); fi;
 if a!.frob < b!.frob then
 return true;
 elif b!.frob < a!.frob then
 return false;
 fi;
 aa := a!.mat;
 bb := b!.mat;
 pa := PositionNonZero(aa[1]);
 pb := PositionNonZero(bb[1]);
 if pa > pb then
 return true;
 elif pa < pb then
 return false;
 fi;
 sa := aa[1,pa]^-1;
 sb := bb[1,pb]^-1;
 for i in [1..Length(aa)] do
 va := sa*aa[i];
 vb := sb*bb[i];
 if va < vb then return true; fi;
 if vb < va then return false; fi;
 od;
 return false;
 end);

###################################################################
# More operations for elements (without and with frobenius automorphism)
###################################################################

# CHECKED 5/09/11 jdb
#############################################################################
#O Order( <a> )
# returns the order of <a>. This function relies on ProjectiveOrder.
##
InstallMethod( Order,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( a )
 return ProjectiveOrder(a!.mat)[1];
end );

# CHECKED 5/09/11 jdb
# 22/04/12 jb: There was a bug here. I added "and i mod ofrob = 0;"
# 3/6/2015: bug fixed by jb.
#############################################################################
#O Order( <a> )
# returns the order of <a>.
##
InstallMethod( Order,
"for a projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],

# This algorithm could be improved by using the ideas of
# Celler and Leedham-Green.

function( a )
 local b, frob, bfrob, i, ofrob;
b := a!.mat;
frob := a!.frob;
if IsOne(frob) then
 return ProjectiveOrder(b)[1];
fi;
if not IsOne(b) then
 bfrob := b; i := 1;
 ofrob := Order(frob);
 repeat
 bfrob := bfrob^(frob^-1); ## JB 3/6/2015: Found bug here
 b := b * bfrob;
 i := i + 1;
 until IsFiningScalarMatrix( b ) and i mod ofrob = 0;
 return i;
else
 return Order(frob);
fi;
return 1;
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O IsOne( <a> )
# returns true if <a> is the identity.
##
InstallMethod( IsOne,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 local s;
 s := el!.mat[1,1];
 if IsZero(s) then
 return false;
fi;
 s := s^-1;
 return IsOne( s*el!.mat );
end );

# CHECKED 5/09/11 jdb
#############################################################################
#O IsOne( <a> )
# returns true if <a> is the identity
##
InstallMethod( IsOne,
"for a projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
function( el )
 local s;
 if not(IsOne(el!.frob)) then
 return false;
fi;
 s := el!.mat[1,1];
 if IsZero(s) then return false; fi;
 s := s^-1;
 return IsOne( s*el!.mat );
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O DegreeFFE( <el> )
# for projectivities. returns the degree of the underlying field over its
# prime field.
##
InstallOtherMethod( DegreeFFE,
"for projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 return DegreeOverPrimeField( el!.fld );
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O DegreeFFE( <el> )
# for projective collineation maps. returns the degree of the underlying
# field over its prime field.
##
InstallOtherMethod( DegreeFFE,
"for projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
function( el )
 return DegreeOverPrimeField( el!.fld );
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O Characteristic( <el> )
# for projectivities. returns the characteristic of the underlying field.
##
InstallMethod( Characteristic,
"for projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 return Characteristic( el!.fld );
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O Characteristic( <el> )
# for projective collineation maps. returns the characteristic of the underlying field.
##
InstallMethod( Characteristic,
"for projective group element with Frobenius",
[IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
function( el )
 return Characteristic( el!.fld );
end );

###################################################################
# The things that make it a group :-) (without Frobenius)
###################################################################

# CHECKED 5/09/11 jdb
#############################################################################
#O \*( <a>, )
# returns a*b, for IsProjGrpEl
##
InstallMethod( \*,
"for two projective group elements",
[IsProjGrpEl and IsProjGrpElRep, IsProjGrpEl and IsProjGrpElRep],
function( a, b )
 local el;
 el := rec( mat := a!.mat * b!.mat, fld := a!.fld );
 Objectify( ProjElsType, el );
 return el;
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O InverseSameMutability( <el> )
# returns el^-1, for IsProjGrpEl, keeps mutability.
##
InstallMethod( InverseSameMutability,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 local m;
 m := rec( mat := InverseSameMutability(el!.mat), fld := el!.fld );
 Objectify( ProjElsType, m );
 return m;
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O InverseMutable( <el> )
# returns el^-1 (mutable) for IsProjGrpEl
##
InstallMethod( InverseMutable,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 local m;
 m := rec( mat := InverseMutable(el!.mat), fld := el!.fld );
 Objectify( ProjElsType, m );
 return m;
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneImmutable( <el> )
# returns immutable one of the group of <el>
##
InstallMethod( OneImmutable,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 local o;
 o := rec( mat := OneImmutable( el!.mat ), fld := el!.fld );
 Objectify( NewType(FamilyObj(el), IsProjGrpElRep), o );
 return o;
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneSameMutability( <el> )
# returns one of the group of <el> with same mutability of <el>.
##
InstallMethod( OneSameMutability,
"for a projective group element",
[IsProjGrpEl and IsProjGrpElRep],
function( el )
 local o;
 o := rec( mat := OneImmutable( el!.mat ), fld := el!.fld );
 Objectify( NewType(FamilyObj(el), IsProjGrpElRep), o );
 return o;
end );

###################################################################
# The things that make it a group :-) (with Frobenius)
###################################################################
# we first need:
#################################################
# Frobenius automorphisms and groups using them:
#################################################
#12 CHECKED 6/09/11 jdb

InstallOtherMethod( \^, "for a FFE vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection and IsMutable, IsFrobeniusAutomorphism ],
 function( v, f )
 return List(v,x->x^f);
 end );

#cvec version
InstallOtherMethod( \^, "for a cvec/FFE vector and a Frobenius automorphism",
 [ IsCVecRep and IsFFECollection and IsMutable, IsFrobeniusAutomorphism ],
 function( v, f )
 return CVec(List(v,x->x^f),BaseField(v));
 end );

InstallOtherMethod( \^, "for a FFE vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection, IsFrobeniusAutomorphism ],
 function( v, f )
 return MakeImmutable(List(v,x->x^f));
 end );

#cvec version
InstallOtherMethod( \^, "for a cvec/FFE vector and a Frobenius automorphism",
 [ IsCVecRep and IsFFECollection, IsFrobeniusAutomorphism ],
 function( v, f )
 return MakeImmutable(CVec(List(v,x->x^f),BaseField(v)));
 end );

#we think that this method is not needed, worse, should not be used.
#InstallOtherMethod( \^,
# "for a mutable FFE vector and a trivial Frobenius automorphism",
# [ IsVector and IsFFECollection and IsMutable, IsMapping and IsOne ],
# function( v, f )
# return v;
# end );

#cvec version
#InstallOtherMethod( \^,
# "for a mutable cvec/FFE vector and a trivial Frobenius automorphism",
# [ IsCVecRep and IsFFECollection and IsMutable, IsMapping and IsOne ],
# function( v, f )
# return v;
# end );

InstallOtherMethod( \^,
 "for a mutable FFE vector and a trivial Frobenius automorphism",
 [ IsVector and IsFFECollection and IsMutable, IsMapping and IsOne ],
 function( v, f )
 return ShallowCopy(v);
 end );

#cvec version
InstallOtherMethod( \^,
 "for a mutable cvec/FFE vector and a trivial Frobenius automorphism",
 [ IsCVecRep and IsFFECollection and IsMutable, IsMapping and IsOne ],
 function( v, f )
 return ShallowCopy(v);
 end );

#the next operations until the matrix section, the methods will become obsolete as soon as fining is cvec'ed.

InstallOtherMethod( \^,
 "for a compressed GF2 vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection and IsGF2VectorRep, IsFrobeniusAutomorphism ],
 function( v, f )
 local w;
 w := List(v,x->x^f);
 ConvertToVectorRepNC(w,2);
 return MakeImmutable(w);
 end );

InstallOtherMethod( \^,
 "for a mutable compressed GF2 vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection and IsGF2VectorRep and IsMutable,
 IsFrobeniusAutomorphism ],
 function( v, f )
 local w;
 w := List(v,x->x^f);
 ConvertToVectorRepNC(w,2);
 return w;
 end );

InstallOtherMethod( \^,
 "for a compressed GF2 vector and a trivial Frobenius automorphism",
 [ IsVector and IsFFECollection and IsGF2VectorRep, IsMapping and IsOne ],
 function( v, f )
 return v;
 end );

InstallOtherMethod( \^,
 "for a mutable compressed GF2 vector and a trivial Frobenius automorphism",
 [ IsVector and IsFFECollection and IsGF2VectorRep and IsMutable,
 IsMapping and IsOne ],
 function( v, f )
 return ShallowCopy(v);
 end );

InstallOtherMethod( \^,
 "for a compressed 8bit vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection and Is8BitVectorRep, IsFrobeniusAutomorphism ],
 function( v, f )
 local w;
 w := List(v,x->x^f);
 ConvertToVectorRepNC(w,Q_VEC8BIT(v));
 return MakeImmutable(w);
 end );

InstallOtherMethod( \^,
 "for a mutable compressed 8bit vector and a Frobenius automorphism",
 [ IsVector and IsFFECollection and Is8BitVectorRep and IsMutable,
 IsFrobeniusAutomorphism ],
 function( v, f )
 local w;
 w := List(v,x->x^f);
 ConvertToVectorRepNC(w,Q_VEC8BIT(v));
 return w;
 end );

InstallOtherMethod( \^,
 "for a compressed 8bit vector and a trivial Frobenius automorphism",
 [ IsVector and IsFFECollection and Is8BitVectorRep, IsMapping and IsOne ],
 function( v, f )
 return v;
 end );

InstallOtherMethod( \^,
 "for a mutable compressed 8bit vector and a trivial Frobenius automorphism",
 [ IsVector and IsFFECollection and Is8BitVectorRep and IsMutable,
 IsMapping and IsOne ],
 function( v, f )
 return ShallowCopy(v);
 end );

#### matrix methods

InstallOtherMethod( \^, "for a FFE matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl, IsFrobeniusAutomorphism ],
 function( m, f )
 return MakeImmutable(List(m,v->List(v,x->x^f)));
 end );

#cmat
InstallOtherMethod( \^, "for a FFE matrix and a Frobenius automorphism",
 [ IsCMatRep and IsFFECollColl, IsFrobeniusAutomorphism ],
 function( m, f )
 return MakeImmutable(CMat(List(m,v->v^f)));
 end );

#InstallOtherMethod( \^, "for a FFE matrix and a Frobenius automorphism",
# [ IsMatrix and IsFFECollColl, IsFrobeniusAutomorphism ],
# function( m, f )
# return MakeImmutable(List(m,v->List(v,x->x^f)));
# end );

InstallOtherMethod( \^, "for a mutable FFE matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and IsMutable, IsFrobeniusAutomorphism ],
 function( m, f )
 return List(m,v->List(v,x->x^f));
 end );

#cmat
InstallOtherMethod( \^, "for a mutable FFE matrix and a Frobenius automorphism",
 [ IsCMatRep and IsFFECollColl and IsMutable, IsFrobeniusAutomorphism ],
 function( m, f )
 return CMat(List(m,v->v^f));
 end );

InstallOtherMethod( \^, "for a FFE matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl, IsMapping and IsOne ],
 function( m, f )
 return m;
 end );

#cmat
InstallOtherMethod( \^, "for a FFE matrix and a trivial Frobenius automorphism",
 [ IsCMatRep and IsFFECollColl and IsMutable, IsMapping and IsOne ],
 function( m, f )
 return ShallowCopy(m);
 end );

InstallOtherMethod( \^,
 "for a mutable FFE matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl, IsMapping and IsOne ],
 function( m, f )
 return MutableCopyMat(m);
 end );

#cmat
InstallOtherMethod( \^, "for a FFE matrix and a trivial Frobenius automorphism",
 [ IsCMatRep and IsFFECollColl , IsMapping and IsOne ],
 function( m, f )
 return MakeImmutable(ShallowCopy(m));
 end );

#the next matrix methods will become obsolete.

InstallOtherMethod( \^,
 "for a compressed GF2 matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and IsGF2MatrixRep, IsFrobeniusAutomorphism ],
 function( m, f )
 local w,l,i;
 l := [];
 for i in [1..NrRows(m)] do
 w := List(m[i],x->x^f);
 ConvertToVectorRepNC(w,2);
 Add(l,w);
 od;
 ConvertToMatrixRepNC(l,2);
 return MakeImmutable(l);
 end );

InstallOtherMethod( \^,
 "for a mutable compressed GF2 matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and IsGF2MatrixRep and IsMutable,
 IsFrobeniusAutomorphism ],
 function( m, f )
 local w,l,i;
 l := [];
 for i in [1..NrRows(m)] do
 w := List(m[i],x->x^f);
 ConvertToVectorRepNC(w,2);
 Add(l,w);
 od;
 ConvertToMatrixRepNC(l,2);
 return l;
 end );

InstallOtherMethod( \^,
 "for a compressed GF2 matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and IsGF2MatrixRep, IsMapping and IsOne ],
 function( m, f )
 return m;
 end );

InstallOtherMethod( \^,
 "for a mutable compressed GF2 matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and IsGF2MatrixRep and IsMutable,
 IsMapping and IsOne ],
 function( m, f )
 return MutableCopyMat(m);
 end );

InstallOtherMethod( \^,
 "for a compressed 8bit matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and Is8BitMatrixRep, IsFrobeniusAutomorphism ],
 function( m, f )
 local w,l,i,q;
 l := [];
 q := Q_VEC8BIT(m[1]);
 for i in [1..NrRows(m)] do
 w := List(m[i],x->x^f);
 ConvertToVectorRepNC(w,q);
 Add(l,w);
 od;
 ConvertToMatrixRepNC(l,q);
 return MakeImmutable(l);
 end );

InstallOtherMethod( \^,
 "for a mutable compressed 8bit matrix and a Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and Is8BitMatrixRep and IsMutable,
 IsFrobeniusAutomorphism ],
 function( m, f )
 local w,l,i,q;
 l := [];
 q := Q_VEC8BIT(m[1]);
 for i in [1..NrRows(m)] do
 w := List(m[i],x->x^f);
 ConvertToVectorRepNC(w,q);
 Add(l,w);
 od;
 ConvertToMatrixRepNC(l,q);
 return MakeImmutable(l);
 end );

InstallOtherMethod( \^,
 "for a compressed 8bit matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and Is8BitMatrixRep, IsMapping and IsOne ],
 function( m, f )
 return m;
 end );

InstallOtherMethod( \^,
 "for a mutable compressed 8bit matrix and a trivial Frobenius automorphism",
 [ IsMatrix and IsFFECollColl and Is8BitMatrixRep and IsMutable,
 IsMapping and IsOne ],
 function( m, f )
 return MutableCopyMat(m);
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#O \*( <a>, )
# returns a*b, for IsProjGrpElWithFrob
##
#made a change, added ^-1 on march 8 2007, J&J
InstallMethod( \*, "for two projective group element with Frobenious",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep,
 IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( a, b )
 local el;
 el := rec( mat := a!.mat * (b!.mat^(a!.frob^-1)), fld := a!.fld,
 frob := a!.frob * b!.frob );
 Objectify( ProjElsWithFrobType, el);
 return el;
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#O InverseSameMutability( <el> )
# returns el^-1, for IsProjGrpElWithFrob, keeps mutability.
##
#found a bug 23/09/08 in st. andrews.
#J&J feel a great relief.
#C&P too.
#all after Max concluded that there was a big bug.
InstallMethod( InverseSameMutability,
 "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( el )
 local m,f;
 f := el!.frob;
 m := rec( mat := (InverseSameMutability(el!.mat))^f, fld := el!.fld,
 frob := f^-1 );
 Objectify( ProjElsWithFrobType, m );
 return m;
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#O InverseMutable( <el> )
# returns mutable el^-1, for IsProjGrpElWithFrob
##
InstallMethod( InverseMutable,
 "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( el )
 local m,f;
 f := el!.frob;
 m := rec( mat := (InverseMutable(el!.mat))^f, fld := el!.fld,
 frob := f^-1 );
 Objectify( ProjElsWithFrobType, m );
 return m;
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneImmutable( <el> )
# returns immutable one of the group of <el>
##
InstallMethod( OneImmutable, "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( el )
 local o;
 o := rec( mat := OneImmutable( el!.mat ), fld := el!.fld,
 frob := el!.frob^0 );
 Objectify( ProjElsWithFrobType, o);
 return o;
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneSameMutability( <el> )
# returns one of the group of <el> with same mutability
##
InstallMethod( OneSameMutability,
 "for a projective group element with Frobenius",
 [IsProjGrpElWithFrob and IsProjGrpElWithFrobRep],
 function( el )
 local o;
 o := rec( mat := OneImmutable( el!.mat ), fld := el!.fld,
 frob := el!.frob^0 );
 Objectify( ProjElsWithFrobType, o);
 return o;
 end );

###################################################################
# General methods to deal with projective groups.
# Construction of (projective) groups is done in the appropriate files
# that deal with geometries.
###################################################################

# 10 CHECKED 6/09/11 jdb
###################################################################
# View, print and display methods for projective groups
# (without and with Frobenius)
###################################################################

#InstallMethod( ViewObj,
# "for a projective group",
# [IsProjectivityGroup],
# function( g )
# Print("<projective group>");
# end );
#
#InstallMethod( ViewObj,
# "for a trivial projective group",
# [IsProjectivityGroup and IsTrivial],
# function( g )
# Print("<trivial projective group>");
# end );
#
#InstallMethod( ViewObj,
# "for a projective group with gens",
# [IsProjectivityGroup and HasGeneratorsOfGroup],
# function( g )
# local gens;
# gens := GeneratorsOfGroup(g);
# if Length(gens) = 0 then
# Print("<trivial projective group>");
# else
# Print("<projective group with ",Length(gens),
# " generators>");
# fi;
# end );
#
#InstallMethod( ViewObj,
# "for a projective group with size",
# [IsProjectivityGroup and HasSize],
# function( g )
# if Size(g) = 1 then
# Print("<trivial projective group>");
# else
# Print("<projective group of size ",Size(g),">");
# fi;
# end );
#
#InstallMethod( ViewObj,
# "for a projective group with gens and size",
# [IsProjectivityGroup and HasGeneratorsOfGroup and HasSize],
# function( g )
# local gens;
# gens := GeneratorsOfGroup(g);
# if Length(gens) = 0 then
# Print("<trivial projective group>");
# else
# Print("<projective group of size ",Size(g)," with ",
# Length(gens)," generators>");
# fi;
# end );

InstallMethod( ViewObj,
"for a projective collineation group",
[IsProjectiveGroupWithFrob],
function( g )
 Print("<projective collineation group>");
end );

InstallMethod( ViewObj,
"for a trivial projective collineation group",
[IsProjectiveGroupWithFrob and IsTrivial],
function( g )
 Print("<trivial projective collineation group>");
end );

InstallMethod( ViewObj,
"for a projective collineation group with gens",
[IsProjectiveGroupWithFrob and HasGeneratorsOfGroup],
function( g )
 local gens;
 gens := GeneratorsOfGroup(g);
 if Length(gens) = 0 then
 Print("<trivial projective collineation group>");
 else
 Print("<projective collineation group with ",Length(gens),
 " generators>");
 fi;
end );

InstallMethod( ViewObj,
"for a projective collineation group with size",
[IsProjectiveGroupWithFrob and HasSize],
function( g )
 if Size(g) = 1 then
 Print("<trivial projective collineation group>");
 else
 Print("<projective collineation group of size ",Size(g),">");
 fi;
end );

InstallMethod( ViewObj,
"for a projective collineation group with gens and size",
[IsProjectiveGroupWithFrob and HasGeneratorsOfGroup and HasSize],
function( g )
 local gens;
 gens := GeneratorsOfGroup(g);
 if Length(gens) = 0 then
 Print("<trivial projective collineation group>");
 else
 Print("<projective collineation group of size ",Size(g)," with ",
 Length(gens)," generators>");
 fi;
end );

###################################################################
# Some operations for projective groups (without and with frobenius automorphism)
###################################################################

# CHECKED 6/09/11 jdb
#############################################################################
#O BaseField( <g> )
# returns the base field of the projective group <g>
##

# ml 07/11/2012: I have taken out the view, print and display methods
# for projectivity groups, since these are also collineation groups in FinInG
#InstallMethod( BaseField,
# "for a projective group",
# [IsProjectivityGroup],
# function( g )
# local f,gens;
# if IsBound(g!.basefield) then
# return g!.basefield;
# fi;
# if HasParent(g) then
# f := BaseField(Parent(g));
# g!.basefield := f;
# return f;
# fi;
# # Now start to investigate:
# gens := GeneratorsOfGroup(g);
# if Length(gens) > 0 then
# g!.basefield := gens[1]!.fld;
# return g!.basefield;
# fi;
# # Now we have to give up:
# Error("base field could not be determined");
# end );

# CHECKED 6/09/11 jdb
#############################################################################
#O BaseField( <g> )
# returns the base field of the projective collineation group <g>
##
InstallMethod( BaseField,
"for a projective collineation group",
[IsProjectiveGroupWithFrob],
function( g )
 local f,gens,P;
 if IsBound(g!.basefield) then
 return g!.basefield;
 fi;
 # This if statement can cause an infinite loop!
 if HasParent(g) then # JB 22/03/2014
 P := Parent(g);
 if IsBound(P!.basefield) then
 f := P!.basefield;
 g!.basefield := f;
 return f;
 fi;
 fi;
 # Now start to investigate:
 gens := GeneratorsOfGroup(g);
 if Length(gens) > 0 then
 g!.basefield := gens[1]!.fld;
 return g!.basefield;
 elif IsTrivial(g) then #JB: 22/03/2014: The trivial group with no generators slipped through.
 g!.basefield := One(g)!.fld;
 return g!.basefield;
 fi;

 # Now we have to give up:
 Error("base field could not be determined");
end );

# TO DO (22/03/2014): We ought to set the basefield on creating collineation groups.

# CHECKED 6/09/11 jdb
#############################################################################
#O Dimension( <g> )
# returns the dimension of the projective group <g>. The dimension of this
# group is defined as the vector space dimension of the projective space
# of which <g> was defined as a projective group, or, in other words, as the
# size of the matrices.
##

# ml 07/11/2012: I have taken out the view, print and display methods
# for projectivity groups, since these are also collineation groups in FinInG

#InstallMethod( Dimension,
# "for a projective group",
# [IsProjectivityGroup],
# function( g )
# local gens;
# if HasParent(g) then
# return Dimension(Parent(g));
# fi;
# # Now start to investigate:
# gens := GeneratorsOfGroup(g);
# if Length(gens) > 0 then
# return NrRows(gens[1]!.mat);
# fi;
# Error("dimension could not be determined");
# end );

# CHECKED 6/09/11 jdb
#############################################################################
#O Dimension( <g> )
# returns the dimension of the projective collineation group <g>. The dimension of this
# group is defined as the vector space dimension of the projective space
# of which <g> was defined as a projective group, or, in other words, as the
# size of the matrices.
##
InstallMethod( Dimension,
"for a projective collineation group",
[IsProjectiveGroupWithFrob],
function( g )
 local gens;
 if HasParent(g) and HasDimension(Parent(g)) then #JB: 22/03/2014: Made sure the parent had a dimension first
 return Dimension(Parent(g));
 fi;
 # Now start to investigate:
 gens := GeneratorsOfGroup(g);
 if Length(gens) > 0 then
 return NrRows(gens[1]!.mat);
 elif IsTrivial(g) then #JB: 22/03/2014: The trivial group with no generators slipped through.
 return NrRows(One(g)!.mat);
 fi;
 Error("dimension could not be determined");
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneImmutable( <g> )
# returns an immutable one of the projectivity group <g>
##
# ml 07/11/2012: I have taken out the view, print and display methods
# for projectivity groups, since these are also collineation groups in FinInG

#InstallMethod( OneImmutable,
# "for a projective group",
# # was: [IsGroup and IsProjectivityGroup], I think might be
# [IsProjectivityGroup],
# function( g )
# local gens, o;
# gens := GeneratorsOfGroup(g);
# if Length(gens) = 0 then
# if HasParent(g) then
# gens := GeneratorsOfGroup(Parent(g));
# else
# Error("sorry, no generators, no one");
# fi;
# fi;
# o := rec( mat := OneImmutable( gens[1]!.mat ), fld := gens[1]!.fld );
# Objectify( NewType(FamilyObj(gens[1]), IsProjGrpElRep), o );
# return o;
# end );

# CHECKED 6/09/11 jdb
#############################################################################
#O OneImmutable( <g> )
# returns immutable one of the projective collineation group <g>
##
InstallMethod( OneImmutable,
"for a projective collineation group",
# was [IsGroup and IsProjectiveGroupWithFrob], I think might be
[IsProjectiveGroupWithFrob],
function( g )
 local gens, o;
 gens := GeneratorsOfGroup(g);
 if Length(gens) = 0 then
 if HasParent(g) and HasOneImmutable(Parent(g)) then # JB 22/03/2014
 gens := GeneratorsOfGroup(Parent(g));
 else
 Error("sorry, no generators, no one");
 fi;
 fi;
 o := rec( mat := OneImmutable( gens[1]!.mat ), fld := BaseField(g),
 frob := gens[1]!.frob^0 );
 Objectify( ProjElsWithFrobType, o);
 return o;
end );

###################################################################
# All about actions. But low level stuff. In each appropriate files
# for particular geometries, user-friendly action functions must be
# provided.
###################################################################

# CHECKED 6/09/11 jdb
#############################################################################
#P CanComputeActionOnPoints( <g> )
# is set true if we consider the computation of the action feasible.
# for projective groups.
##
# ml 07/11/2012: I have taken out the view, print and display methods
# for projectivity groups, since these are also collineation groups in FinInG

#InstallMethod( CanComputeActionOnPoints,
# "for a projective group",
# [IsProjectivityGroup],
# function( g )
# local d,q;
# d := Dimension( g );
# q := Size( BaseField( g ) );
# if (q^d - 1)/(q-1) > FINING.LimitForCanComputeActionOnPoints then
# return false;
# else
# return true;
# fi;
# end );

# CHECKED 6/09/11 jdb
#############################################################################
#P CanComputeActionOnPoints( <g> )
# is set true if we consider the computation of the action feasible.
# for projective collineation groups.
##
InstallMethod( CanComputeActionOnPoints,
"for a projective group with frob",
[IsProjectiveGroupWithFrob],
function( g )
 local d,q;
 d := Dimension( g );
 q := Size( BaseField( g ) );
 if (q^d - 1)/(q-1) > FINING.LimitForCanComputeActionOnPoints then
 return false;
 else
 return true;
 fi;
end );

###################################################################
# Action functions for projective groups and projective collineation
# groups. The four action functions here are low level and not
# intended for the user.
###################################################################

# CHECKED 6/09/11 jdb
#############################################################################
#F OnProjPoints( <line>, <el> )
# computes <line>^<el> where this action is the "natural" one, and <line> represents
# a projective point. We called it line, since this functions relies on the Gap action
# function OnLines, which is the "natural" actions of a matrix on a vector line.
# Important: despite its natural name, this function is *not* intended for the user.
# <line>: just a row vector, representing a vector line
# <el>: a projective group element (so a projectivity, *not* a projective collineation element.
# normalizing the result is handled by the Gap function OnLines. This function assumes that
# the input vector is also normalized (says the GAP manual). This became reality on september 19, 2011 :-)
##
InstallGlobalFunction( OnProjPoints,
function( line, el )
 return OnLines(line,el!.mat);
end );

# CHECKED 6/09/11 jdb
# CHANGED 19/09/2011 jdb + ml
# can be shortened if you use that OnLines normalizes the result.
#############################################################################
#F OnProjPointsWithFrob( <line>, <el> )
# computes <line>^<el> where this action is the "natural" one, and <line> represents
# a projective point. This function relies on the GAP function OnLines (see above),
# the result is hence normalized
# Important: despite its natural name, this function is *not* intended for the user.
# <line>: just a row vector, representing a projective point.
# <el>: a projective collineation element
##
InstallGlobalFunction( OnProjPointsWithFrob,
 function( line, el )
 local vec,c;
# vec := OnPoints(line,el!.mat)^el!.frob;
 vec := OnLines(line,el!.mat)^el!.frob;
 #c := PositionNonZero(vec);
 #if c <= Length( vec ) then
# if not(IsMutable(vec)) then
# vec := ShallowCopy(vec);
# fi;
# MultVector(vec,Inverse( vec[c] ));
# fi;
 return vec;
end );

# CHECKED 6/09/11 jdb
# CHANGED 19/09/2011 jdb + ml
# CHANGED 20/09/2011 jdb + ml (SemiEchelonMat -> EchelonMat).
#############################################################################
#F OnProjSubspacesNoFrob( <subspace>, <el> )
# computes <subspace>^<el> where this action is the "natural" one, and <subspace> represents
# a projective subspace. This function relies on the GAP action function
# OnSubspacesByCanonicalBasis. This function assumes as arguments a list (mat) of linearly
# independent row vectors, in Hermite normal form (triangulied), and return the
# mat*<el> in Hermite normal form. To be used in user action functions, we EchelonMat it, so that
# the output can be used directly in a Wrap.
# Important: despite its natural name, this function is *not* intended for the user.
# <el>: a projective group element (so a projectivity, *not* a projective collineation element.
##
InstallGlobalFunction( OnProjSubspacesNoFrob,
function( matrix, el )
 # matrix is a matrix containing the basis vectors of some subspace.
 local mat;
 mat := TriangulizeMat(OnSubspacesByCanonicalBasis(matrix,el!.mat));
 return mat;
 #return EchelonMat(OnSubspacesByCanonicalBasis(matrix,el!.mat)).vectors;
end );

# CHECKED 6/09/11 jdb
# CHANGED 19/09/2011 jdb + ml
# CHANGED 20/09/2011 jdb + ml (SemiEchelonMat -> EchelonMat).
#############################################################################
#F OnProjSubspacesWithFrob( <subspace>, <el> )
# computes <subspace>^<el> where this action is the "natural" one, and <subspace> represents
# a projective subspace. This function relies on the GAP action function
# OnRight, which computs the action of a matrix on a sub vector space. Here we have to rely on
# OnRight, and so we have to EchelonMat afterwards.
# Important: despite its natural name, this function is *not* intended for the user.
# <el>: a projective group element (so a projectivity, *not* a projective collineation element.
##
InstallGlobalFunction( OnProjSubspacesWithFrob,
 function( matrix, el )
# matrix is a matrix containing the basis vectors of some subspace.
 local vec,c;
 vec := OnRight(matrix,el!.mat)^el!.frob;
 if not(IsMutable(vec)) then
 vec := MutableCopyMat(vec);
 fi;
 TriangulizeMat(vec);
#return EchelonMat(vec).vectors;
return vec;
 end );

###################################################################
# Higher level user friendly operations to compute the action of a
# projective and a projective collineation group. These operations
# are based on the low level functions above.
###################################################################

# CHECKED 6/09/11 jdb
#############################################################################
#P ActionOnAllProjPoints( <g> )
# returns the action of the projective group <g> on the projective points
# of the underlying projective space.
##

# ml 07/11/2012: I have taken out the view, print and display methods
# for projectivity groups, since these are also collineation groups in FinInG

#InstallMethod( ActionOnAllProjPoints,
# "for a projective group",
# [ IsProjectivityGroup ],
# function( pg )
# local a,d,f,orb;
# f := BaseField(pg);
# d := Dimension(pg);
# orb := MakeAllProjectivePoints(f,d);
# a := ActionHomomorphism(pg,orb,OnProjPoints,"surjective");
# SetIsInjective(a,true);
# return a;
# end );

# CHECKED 6/09/11 jdb
# cvec change 19/3/14
#############################################################################
#O ActionOnAllProjPoints( <g> )
# returns the action of the projective collineation group <g> on the projective points
# of the underlying projective space.
##
InstallMethod( ActionOnAllProjPoints,
 "for a projective collineation group",
[ IsProjectiveGroupWithFrob ],
function( pg )
 local a,d,f,o,on,orb,v, m, j;
 Info(InfoFinInG,4,"Using ActionOnAllProjPoints");
 f := BaseField(pg);
 d := Dimension(pg);
 o := One(f);
 on := One(pg);
 v := ZeroMutable(on!.mat[1]);
 v[1] := o;
 #orb := Orbit(pg,v,OnProjPointsWithFrob);
 #orb := Orb(pg,v,OnProjPointsWithFrob);
 orb := [];
 for m in f^d do
 j := PositionNonZero(m);
 if j <= d and m[j] = o then
 Add(orb, CVec(m,f)); #here is the change.
 fi;
 od;
 a := ActionHomomorphism(pg,orb,OnProjPointsWithFrob,"surjective");
 SetIsInjective(a,true);
 return a;
end );

###################################################################
# NiceMonomorphism material for projective and projective collineation
# groups.
###################################################################

# CHECKED 6/09/11 jdb
#############################################################################
#F NiceMonomorphismByOrbit( <g>, <x>, <op>, <orblen> )
# <g>: projective groups; <x>: an element; <op> operation suitable for <x> and <g>
# important: this functions relies on the GenSS package.
# As you can probably guess: this is not intended for a user.
##
InstallGlobalFunction( NiceMonomorphismByOrbit,
 function(g,x,op,orblen)
 # g a funny group, Size attribute set!
 # x an element
 # op an operation suitable for x and g
 # It is guaranteed that g acts faithfully on the orbit.
 local cand,h,iso,nr,orb,pgens;
 if orblen <> false then
 orb := Orb(g,x,op,rec(orbsizelimit := orblen, hashlen := 2*orblen,
 storenumbers := true));
 Enumerate(orb);
 else
 orb := Orb(g,x,op,rec(storenumbers := true));
 Enumerate(orb);
 fi;
pgens := ActionOnOrbit(orb,GeneratorsOfGroup(g));
 h := GroupWithGenerators(pgens);
 SetSize(h,Size(g));
 nr := Minimum(100,Length(orb));
 cand := rec( points := orb{[1..nr]}, used := 0,
 ops := ListWithIdenticalEntries(nr,op) );
iso := GroupHomomorphismByImagesNCStabilizerChain(g,h,pgens,
 rec( Cand := cand ), rec( ) );
 SetIsBijective(iso,true);
 return iso;
 end );

# CHECKED 6/09/11 jdb
#############################################################################
#F NiceMonomorphismByDomain( <g>, <dom>, <op> )
# <g>: projective groups, size attribute *set* ; <x>: an element;
# <op> operation suitable for <x> and <g>
# important: this functions relies on the GenSS package.
##
InstallGlobalFunction( NiceMonomorphismByDomain,
 function(g,dom,op)
 # g a funny group, Size attribute set!
 # dom an orbit of g
 # op the operation suitable for x and g
 # It is guaranteed that g acts faithfully on the orbit.
 local cand,gens,h,ht,i,iso,nr,pgens;
 ht := HTCreate(dom[1],rec(hashlen:=Length(dom)*2));
 for i in [1..Length(dom)] do
 HTAdd(ht,dom[i],i);
 od;
 pgens := [];
 gens := GeneratorsOfGroup(g);
 for i in [1..Length(gens)] do
 Add(pgens,PermList( List([1..Length(dom)],
 j->HTValue(ht,op(dom[j],gens[i]))) ));
 od;
 h := GroupWithGenerators(pgens);
 SetSize(h,Size(g));
 nr := Minimum(100,Length(dom));
 cand := rec( points := dom{[1..nr]}, used := 0,
 ops := ListWithIdenticalEntries(nr,op) );
 iso := GroupHomomorphismByImagesNCStabilizerChain(g,h,pgens,
 rec( Cand := cand ), rec( ) );
 SetIsBijective(iso,true);
 return iso;
 end );

# CHECKED 6/09/11 jdb
# cvec change 19/3/14
#############################################################################
#O NiceMonomorphism( <pg> )
# <pg> is a projective group. This operation returns a nice monomorphism.
##
InstallMethod( NiceMonomorphism,
"for a projective group (feasible case)",
[IsProjectivityGroup and CanComputeActionOnPoints and IsHandledByNiceMonomorphism],
50,
function( pg )
local hom, dom,bf;
Info(InfoFinInG,4,"Using NiceMonomorphism for proj. group (feasible)");
bf := BaseField(pg);
 dom := MakeAllProjectivePoints( bf, Dimension(pg) - 1);
 #dom := List(dom,x->CVec(x,bf)); # (ml 31/03/14) MakeAllProjectivePoints produces already cvecs
if FINING.Fast then
 hom := NiceMonomorphismByDomain( pg, dom, OnProjPointsWithFrob );
 else
 hom := ActionHomomorphism(pg, dom, OnProjPointsWithFrob, "surjective");
 SetIsBijective(hom, true);
 fi;
 return hom;
end );

# CHECKED 6/09/11 jdb
# cvec change 19/3/14
#############################################################################
#O NiceMonomorphism( <pg> )
# <pg> is a projective group. This operation returns a nice monomorphism.
##
InstallMethod( NiceMonomorphism,
"for a projective group (nasty case)",
[IsProjectiveGroupWithFrob and IsHandledByNiceMonomorphism],
50,
function( pg )
 local can, dom, hom, bf;
 Info(InfoFinInG,4,"Using NiceMonomorphism for proj. group (nasty)");
 bf := BaseField(pg);
 can := CanComputeActionOnPoints(pg);
 if not(can) then
 Error("action on projective points not feasible to calculate");
 else
 dom := MakeAllProjectivePoints( BaseField(pg), Dimension(pg) - 1 );
 #dom := List(dom,x->CVec(x,bf)); # (ml 31/03/14) MakeAllProjectivePoints produces already cvecs
 if FINING.Fast then
 hom := NiceMonomorphismByDomain( pg, dom, OnProjPointsWithFrob );
 else
 hom := ActionHomomorphism(pg, dom, OnProjPointsWithFrob, "surjective");
 SetIsBijective(hom, true);
 fi;
 return hom;
 fi;
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O NiceMonomorphism( <pg> )
# <pg> is a projective collineation group. This operation returns a nice monomorphism.
##
InstallMethod( NiceMonomorphism,
"for a projective collineation group (feasible case)",
[IsProjectiveGroupWithFrob and CanComputeActionOnPoints and
IsHandledByNiceMonomorphism], 1,
function( pg )
 return ActionOnAllProjPoints( pg );
end );

# CHECKED 6/09/11 jdb
#############################################################################
#O NiceMonomorphism( <pg> )
# <pg> is a projective collineation group. This operation returns a nice monomorphism.
##
InstallMethod( NiceMonomorphism,
"for a projective collineation group (nasty case)",
[IsProjectiveGroupWithFrob and IsHandledByNiceMonomorphism], 50,
function( pg )
 local can;
 can := CanComputeActionOnPoints(pg);
 if not(can) then
 Error("action on projective points not feasible to calculate");
 else
 return ActionOnAllProjPoints( pg );
 fi;
end );

## FindBasePointCandidates: are these methods also obsolete in the sense that they are never used? No! They are used in GenSS :-)

#############################################################################
#O FindBasePointCandidates( <g>, <opt>, )
# <pg> is a projective collineation group. <op> and are arguments required
# to be used in GenSS.
##
InstallMethod( FindBasePointCandidates,
 "for a projective group",
 [IsProjectivityGroup,IsRecord,IsInt],
 function(g,opt,i)
 local cand,d,f,gens;
 if IsBound(g!.basepointcandidates) and
 g!.basepointcandidates.used < Length(g!.basepointcandidates.points) then
 return g!.basepointcandidates;
 fi;
 gens := GeneratorsOfGroup(g);
 if IsObjWithMemory(gens[1]) then
 f := BaseField(gens[1]!.el);
 d := NrRows(gens[1]!.el!.mat);
 else
 f := BaseField(g);
 d := Dimension(g);
 fi;
 cand := rec( points := NewMatrix(IsCMatRep, f,d, IdentityMat(d,f)) , used := 0,
 ops := ListWithIdenticalEntries(d,OnProjPoints) );
 return cand;
 end );

#############################################################################
#O FindBasePointCandidates( <g>, <opt>, )
# <pg> is a projective collineation group. <op> and are arguments required
# to be used in GenSS.
##
InstallMethod( FindBasePointCandidates,
 "for a projective collineation group",
 [IsProjectiveGroupWithFrob,IsRecord,IsInt],
 function(g,opt,i)
 local cand,d,f,gens;
 if IsBound(g!.basepointcandidates) and
 g!.basepointcandidates.used < Length(g!.basepointcandidates.points) then
 return g!.basepointcandidates;
 fi;
 gens := GeneratorsOfGroup(g);
 if IsObjWithMemory(gens[1]) then
 f := BaseField(gens[1]!.el);
 d := NrRows(gens[1]!.el!.mat);
 else
 f := BaseField(g);
 d := Dimension(g);
 fi;
 cand := rec( points := NewMatrix(IsCMatRep, f,d, IdentityMat(d,f)), used := 0,
 ops := ListWithIdenticalEntries(d,OnProjPointsWithFrob) );
 if d > 1 then
 Add(cand.points,ShallowCopy(cand.points[1]));
 Add(cand.ops,OnProjPointsWithFrob);
 cand.points[d+1][2] := PrimitiveRoot(f);
 fi;
 return cand;
 end );

#############################################################################
#O FindBasePointCandidates( <g>, <opt>, )
# <pg> is a projective collineation group. <opt>, , <parentS> are arguments
# required to be used in GenSS.
##
InstallMethod( FindBasePointCandidates,
 "for a projective collineation group",
 [IsProjectiveGroupWithFrob,IsRecord,IsInt,IsObject],
#
# We need a four-argument version of this method for recent versions of GenSS.
# We don't use "parentS" at all here.
#
 function(g,opt,i,parentS)
 local cand,d,f,j,gens;
 if IsBound(g!.basepointcandidates) and
 g!.basepointcandidates.used < Length(g!.basepointcandidates.points) then
 return g!.basepointcandidates;
 fi;
 gens := GeneratorsOfGroup(g);
 if IsObjWithMemory(gens[1]) then
 f := BaseField(gens[1]!.el);
 d := NrRows(gens[1]!.el!.mat);
 else
 f := BaseField(g);
 d := Dimension(g);
 fi;
 cand := rec( points := NewMatrix(IsCMatRep, f,d, IdentityMat(d,f)), used := 0,
 ops := ListWithIdenticalEntries(d,OnProjPointsWithFrob) );
 if d > 1 then
 for j in [2..d] do
 Add(cand.points,ShallowCopy(cand.points[1]));
 Add(cand.ops,OnProjPointsWithFrob);
 cand.points[d+j-1][j] := PrimitiveRoot(f);
 od;
 fi;
 return cand;
 end );

#################################################
# Our classical groups:
#################################################

#############################################################################
# Part I: methods for canonical gram matrices and canonical quadratic forms.
# these methods are not intended for the user.
#############################################################################

# CHECKED 21/09/11 jdb
#############################################################################
#O CanonicalGramMatrix( <type>, <d>, <f> )
## Constructs the canonical gram matrix to construct the canonical
## forms used in FinInG. See Appendix for exact information on these forms
## and there matrices.
##
InstallMethod( CanonicalGramMatrix,
"for a string, an integer, and a field",
[IsString, IsPosInt, IsField],
function( type, d, f )
 local one, q, m, i, t, x, w, p;
 one := One( f );
 q := Size(f);

 # Symplectic Gram matrix
 if type = "symplectic" then
 if IsOddInt(d) then
 Error( "the dimension <d> must be even" );
 fi;
 m := List( 0 * IdentityMat(d, f), ShallowCopy );
 for i in [ 1 .. d/2 ] do
 m[2*i,2*i-1] := -one;
 m[2*i-1,2*i] := one;
 od;

 # Unitary Gram matrix
 elif type = "hermitian" then
 if IsOddInt(DegreeOverPrimeField(f)) then
 Error("field order must be a square");
 fi;
 m := IdentityMat(d, f);

 # Orthogonal Gram matrix
 elif type = "hyperbolic" then
 m := List( 0*IdentityMat(d, f), ShallowCopy );
 p := Characteristic(f);
 if IsOddInt(p) and (p + 1) mod 4 = 0 then
 w := one * ((p + 1) / 2);
 else
 w := one;
 fi;
 for i in [ 1 .. d/2 ] do
 m[2*i-1,2*i] := w;
 m[2*i,2*i-1] := w;
 od;
 elif type = "elliptic" then
 m := List( 0*IdentityMat(d, f), ShallowCopy );
 p := Characteristic(f);
 ## if q is congruent to 5,7 mod 8, then #wrong comment?
 ## the anisotropic part is the primitive root.
 if q mod 4 in [1,2] then
 t := Z(q);
 else
 t := one;
 fi;
 m{[1,2]}{[1,2]} := [ [ 1, 0 ], [ 0, t ] ] * one;

 if IsOddInt(p) then
 w := one * ((p + 1) / 2);
 else
 w := one;
 fi;
 for i in [ 2 .. d/2 ] do
 m[2*i-1,2*i] := w;
 m[2*i,2*i-1] := w;
 od;
 elif type = "parabolic" then
 m := List( 0*IdentityMat(d, f), ShallowCopy );
 p := Characteristic(f);
 if IsOddInt(p) then
 ## if q is congruent to 5,7 mod 8, then
 ## the anisotropic part is the primitive root
 ## of the prime subfield.
 if q mod 8 in [5,7] then
 t := Z(p);
 else
 t := one;
 fi;
 m[1,1] := t;
 w := t * ((p + 1) / 2);
 else
 w := one;
 fi;
 for i in [ 1 .. (d-1)/2 ] do
 m[2*i,2*i+1] := w;
 m[2*i+1,2*i] := w;
 od;
 else Error( "type is unknown or not implemented" );
 fi;

 ## We should return a compressed matrix in order that
 ## our computations are efficient

 ConvertToMatrixRep( m, f );
 return m;
end );

# CHECKED 21/09/11 jdb
#############################################################################
#O CanonicalQuadraticForm( <type>, <d>, <f> )
## Constructs the canonical gram matrix to construct the canonical quadratic
## forms used in FinInG. See Appendix for exact information on these forms
## and there matrices.
####
InstallMethod( CanonicalQuadraticForm,
"for a string, an integer and a field",
[IsString, IsPosInt, IsField],
function( type, d, f )
 local m, one, q, p, j, x, R;
 one := One( f );
 if type = "hyperbolic" then
 m := MutableCopyMat(0 * IdentityMat(d, f));
 for j in [ 1 .. d/2 ] do
 m[ 2*j-1 , 2*j ] := one;
 od;
 elif type = "elliptic" then
 m := MutableCopyMat(0 * IdentityMat(d, f));
 m[1,1] := one;
 m[2,1] := one;
 m[d,d-1] := one;
 for j in [ 2 .. d/2-1 ] do
 m[ 2*j-1 , 2*j ] := one;
 od;
 p := Characteristic(f);
 q := Size(f);
 if IsOddInt(Log(q, p)) then
 m[2,2] := one;
 else
 R := PolynomialRing( f, 1 );
 x := Indeterminate( f );
 m[2,2] := Z(q)^First( [ 0 .. q-2 ], u ->
 Length( Factors( R, x^2+x+PrimitiveRoot( f )^u ) ) = 1 );
 fi;
 elif type = "parabolic" then
 m := MutableCopyMat(0 * IdentityMat(d, f));
 m[1,1] := one;
 for j in [ 1 .. (d-1)/2 ] do
 m[ 2*j+1 , 2*j ] := one;
 od;
 else Error( "type is unknown or not implemented" );
 fi;

 ## We should return a compressed matrix in order that
 ## our computations are efficient

 ConvertToMatrixRep( m, f );
 return m;
end );

#############################################################################
# Part II: constructor methods.
#############################################################################

###################################################################################
#
# JB 20/11/2011:
# I've done some rigorous testing, and the following work very well:
# all groups of SymplecticSpace
# all groups of HyperbolicQuadric
# all groups of HermitianPolarSpace (hard to check though, things get big fast)
# all groups of EllipticQuadric (I've recently fixed a bug)
# all groups of ParabolicQuadric (I've recently fixed a bug)
#
# I guess we could run more tests for higher dimensions and field orders, but I'm
# reasonably confident that it all works well. For example, I tested groups
# of the parabolic quadric up to q^d = 8^6 (d is the projective dimension here).
#
###################################################################################

#####################################################################
# Isometry groups. In this order: PSO, PGO, PSU, PGU, PSp, and PGSp
#####################################################################

###### Orthogonal groups ######

#############################################################################
#O SOdesargues( <type>, <d>, <f> )
## returns the projective special orthogonal group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate SO(type,d,q). The latter is available in GAP
##
InstallMethod( SOdesargues,
 "for an integer, a positive integer, and a finite field",
 [IsInt, IsPosInt, IsField and IsFinite],
 function(i, d, f)
 local s, m, frob, b, gens, g, q;
 if i = -1 then s := "elliptic";
 elif i = 0 then s := "parabolic";
 elif i = 1 then s := "hyperbolic";
 fi;
 q := Size(f);
 if IsEvenInt(q) then
 m := InvariantQuadraticForm(SO(i,d,q))!.matrix;
 b := BaseChangeOrthogonalQuadratic(m, f)[1];
 else
 m := InvariantBilinearForm(SO(i,d,q))!.matrix;
 b := BaseChangeOrthogonalBilinear(m, f)[1];
 fi;
 frob := FrobeniusAutomorphism(f);

 ## new group elements: x -> b^-1 x b (conjugation by base change)
 ## preserves form... (b x b^-1) (b m b^T) (b x b^-1)^T = x m x^T

 gens := GeneratorsOfGroup( SO(i,d,q) );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PSO(",String(i),",",String(d),",",String(q),")") );
 if i = 0 then
 SetSize( g, Size(SO(i, d, q)) ); ##/ 2); This might be a mistake in Kleidman and Liebeck!
 else
 SetSize( g, Size(SO(i, d, q)) / GCD_INT(2, q-1) );
 fi;

 return g;
 end );

#############################################################################
#O GOdesargues( <type>, <d>, <f> )
## returns the projective general orthogonal group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate GO(type,d,q). The latter is available in GAP
##
InstallMethod( GOdesargues, [IsInt, IsPosInt, IsField and IsFinite],
 function(i, d, f)
 local m, frob, b, gens, s, g, q;
 if i = -1 then s := "elliptic";
 elif i = 0 then s := "parabolic";
 elif i = 1 then s := "hyperbolic";
 fi;
 q := Size(f);
 if IsEvenInt(q) then
 m := InvariantQuadraticForm(GO(i,d,q))!.matrix;
 b := BaseChangeOrthogonalQuadratic(m, f)[1];
 else
 m := InvariantBilinearForm(SO(i,d,q))!.matrix;
 b := BaseChangeOrthogonalBilinear(m, f)[1];
 fi;
 frob := FrobeniusAutomorphism(f);

 ## new group elements: x -> b x b^-1 (conjugation by base change)
 ## preserves form... (b x b^-1) (b m b^T) (b x b^-1)^T = x m x^T

 gens := GeneratorsOfGroup( GO(i,d,q) );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGO(",String(i),",",String(d),",",String(q),")") );
 SetSize( g, Size(GO(i, d, q)) / GCD_INT(2,q-1) );
 return g;
 end );

###### Unitary groups ######

#############################################################################
#O SUdesargues( <type>, <d>, <f> )
## returns the projective special unitary group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate SU(type,d,q). The latter is available in GAP
##
InstallMethod( SUdesargues, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local m, frob, b, gens, g, sqrtq;
 sqrtq := Sqrt(Size(f));
 m := InvariantSesquilinearForm(SU(d,sqrtq))!.matrix;
 frob := FrobeniusAutomorphism(f);
 b := BaseChangeHermitian(m, f)[1];
 ## new group elements: x -> b x b^-1 (conjugation by base change)
 ## preserves form... (b x b^-1) (b m b^Tfrob) (b x b^-1)^Tfrob = x m x^Tfrob
 gens := GeneratorsOfGroup( SU(d,sqrtq) );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PSU(",String(d),",",String(sqrtq),"^2)") );
 SetSize( g, Size( SU(d, sqrtq) ) / GCD_INT(sqrtq+1,d) );
 return g;
 end );

#############################################################################
#O GUdesargues( <type>, <d>, <f> )
## returns the projective general unitary group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate GU(type,d,q). The latter is available in GAP
##
InstallMethod( GUdesargues, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local m, frob, b, gens, g, sqrtq;
 sqrtq := Sqrt(Size(f));
 m := InvariantSesquilinearForm(GU(d,sqrtq))!.matrix;
 frob := FrobeniusAutomorphism(f);
 b := BaseChangeHermitian(m, f)[1];
 ## new group elements: x -> b x b^-1 (conjugation by base change)
 gens := GeneratorsOfGroup( GU(d,sqrtq) );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGU(",String(d),",",String(sqrtq),"^2)") );
 SetSize( g, Size( GU(d, sqrtq) ) / (sqrtq+1) );
 return g;
 end );

###### Symplectic groups ######

#############################################################################
#O Spdesargues( <d>, <f> )
## returns the projective special symplectic group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate Sp(d,q). The latter is available in GAP
##
InstallMethod( Spdesargues, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local m, frob, b, gens, g, q, sp;
 q := Size(f);
 m := InvariantBilinearForm(Sp(d,q))!.matrix;
 b := BaseChangeSymplectic(m, f)[1]; ## change made after new forms code
 frob := FrobeniusAutomorphism(f);
 ## new group elements: x -> b x b^-1 (conjugation by base change)
 sp := Sp(d,q);
 gens := GeneratorsOfGroup( sp );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PSp(",String(d),",",String(q),")") );
 SetSize( g, Size( sp )/GCD_INT(2, q-1) );
 return g;
 end );

#############################################################################
#O GeneralSymplecticGroup( <d>, <f> )
## returns the general symplectic group. See the internal comment here why
## we add this function.
##
InstallMethod( GeneralSymplecticGroup, [IsPosInt, IsField and IsFinite],
 function(d, f)

## The command "Sp" in the GAP library returns the symplectic
## isometry group (see classical.gi). However, in odd characteristic,
## the symplectic isometries have index 2 in the symplectic similarity
## group. The preimage in the matrix group of the symplectic
## similarities is the isometries extended by the cyclic
## group generated by the map which simply multiplies one half
## of the symplectic basis by the primitive element of the field
## and leaves the other half alone.

 local sp, gens, z, delta, i, g, q;
 q := Size(f);
 if IsOddInt(d) then
 Error("dimension must be an even");
 fi;
 sp := Sp(d, q);
 gens := GeneratorsOfGroup(sp);
 z := PrimitiveRoot( f );
 delta := IdentityMat(d, f);
 for i in [1..d/2] do delta[i,i] := z; od;
 gens := Concatenation(gens, [delta]);
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("GSp(",String(d),",",String(q),")") );
 SetSize( g, (q-1) * Size(sp) );
 return g;
 end );

#############################################################################
#O GSpdesargues( <d>, <f> )
## returns the projective general symplectic group, as a projective collineation group.
## The generators of the group are the projective collineation elements that are
## represented by the matrices that generate GSp(d,q). The latter is made possible now (see above method).
##
InstallMethod( GSpdesargues, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local m, frob, b, gens, g, q, gsp;
 q := Size(f);
 m := InvariantBilinearForm(Sp(d,q))!.matrix;
 b := BaseChangeToCanonical( BilinearFormByMatrix(m, f) );
 frob := FrobeniusAutomorphism(f);
 ## new group elements: x -> b x b^-1 (conjugation by base change)
 gsp := GeneralSymplecticGroup(d,f);
 gens := GeneratorsOfGroup( gsp );
 gens := List( gens, y -> b * y * b^-1);
 gens := ProjElsWithFrob( List(gens, x -> [x,frob^0]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGSp(",String(d),",",String(q),")") );
 SetSize( g, Size(gsp) / (q-1) );
 return g;
 end );

#################################################
# Similarity and semi-similarity groups: In this order: PGammaSp, DeltaO (+,-,parabolic),
#################################################

###### Symplectic group ######

#############################################################################
#O GammaSp( <d>, <f> )
## returns the projective semi-linear symplectic group.
## We rely on GSp(d,q), and the frobenius automorphism.
##
InstallMethod( GammaSp, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local m, frob, b, gens, g, q, gsp;
 q := Size(f);
 m := InvariantBilinearForm(Sp(d,q))!.matrix;
 b := BaseChangeToCanonical( BilinearFormByMatrix(m, f) );
 frob := FrobeniusAutomorphism(f);
 ## new group elements: x -> b x b^-1 (conjugation by base change)
 gsp := GeneralSymplecticGroup(d,f);
 gens := GeneratorsOfGroup( gsp );
 gens := List( gens, y -> b * y * b^-1);
 gens := List( gens, x -> [x, frob^0]);
 Add(gens, [IdentityMat(d, f), frob] );
 gens := ProjElsWithFrob( gens, f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGammaSp(",String(d),",",String(q),")") );
 SetSize( g, Order(frob) * Size(gsp) / (q - 1) );
 return g;
 end );

###### Orthogonal (elliptic) groups ######

#############################################################################
#O DeltaOminus( <d>, <f> )
## returns the projective similarity group of an elliptic orthogonal form
## We rely on GOdesargues.
##
InstallMethod( DeltaOminus, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local go, gens, g, q, one, mat, i, combs, two, a, b,
 twobytwo, mu, z, zero;

 ## Note here that for q even, the projective similarity group
 ## is equal to the projective isometry group. For q odd,
 ## the index of the projective isometry group in the projective
 ## similarity group is 2. Moreover, we have two cases modulo 4.
 ## For q = 3 mod 4, we adjoin the matrix (e.g., for d = 6)
 ## a b . . . .
 ## b -a . . . .
 ## . . . 1 . .
 ## . . -1 . . .
 ## . . . . . 1
 ## . . . . -1 .
 ## where a^2+b^2 = Z(q)^((q-1)/2),
 ## to the isometry group to obtain the similarity group (see
 ## Kleidman and Liebeck, Section 2.8). For q = 1 mod 4, we
 ## use the matrix
 ## . 1 . . . .
 ## z . . . . .
 ## . . . 1 . .
 ## . . z . . .
 ## . . . . . 1
 ## . . . . z .
 ## where z = Z(q).

 one := One(f);
 mat := NullMat(d,d,f);
 q := Size(f);
 z := Z(q);
 go := GOdesargues(-1,d,f);

 if q mod 4 = 3 then
 for i in [2..d/2] do
 mat[2*i-1,2*i] := one;
 mat[2*i,2*i-1] := -one;
 od;
 mu := z^((q-1)/2);;
 combs := Combinations(AsList(f),2);;
 two := First(combs, t -> not IsZero(t[1]) and not IsZero(t[2])
 and t[1]^2+t[2]^2=mu);
 a := two[1]; b:= two[2];
 twobytwo := [[a,b],[b,-a]];
 mat{[1,2]}{[1,2]} := twobytwo;
 elif q mod 4 = 1 then
 z := Z(q);
 zero := Zero(f);
 for i in [1..d/2] do
 mat{[2*i-1,2*i]}{[2*i-1,2*i]} := [[ zero, one ], [z, zero]];
 od;
 else
 return go;
 fi;

 gens := ShallowCopy(GeneratorsOfGroup( go ));
 Add(gens, ProjElWithFrob( mat, IdentityMapping(f), f) );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PDeltaO-(",String(d),",",String(Size(f)),")") );
 ## scalars are completely contained in matrix group, (q-1) cancels with (q-1)
 SetSize( g, Size(GO(-1,d,q)) );
 return g;
 end );

#############################################################################
#O GammaOminus( <d>, <f> )
## returns the projective semi-similarity group of an elliptic orthogonal form
## We rely on DeltaOminus and the Frobenius automorphism.
##
InstallMethod( GammaOminus, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local q, gram, mat, p, a, go, gens, coll, frob, block, mat2, i;

 ## Works beautifully for odd q! Tested for possible output
 ## (q,d) in {(4,9),(4,25),(4,27),(4,49),(6,9)}

 ## After some calculations using the information in Section 2.8
 ## of Kleidman and Liebeck, we find that the following matrix M
 ## (n.b., you should extrapolate the dimension) together with
 ## the Frobenius automorphism of GF(q) defines a semisimilarity
 ## of our canonical form in FinInG:
 ## a . . . . .
 ## . b . . . .
 ## . . . l . .
 ## . . l . . .
 ## . . . . . l
 ## . . . . l .
 ## where a = l * alpha^((1-p)/2) and b = l * beta^((1-p)/2), and
 ## the first block of our Gram matrix is diag(alpha, beta).
 ## JB 20/11/2011: Fixed the bug for q even. Simply changed the change of basis matrix.

 q := Size(f);
 p := Characteristic( f );
 go := DeltaOminus( d, f );

 if q = p then
 coll := go;
 elif IsOddInt(q) then
 gram := CanonicalGramMatrix("elliptic", d, f);
 mat := MutableCopyMat( gram );
 mat[1,1] := gram[3,4] * gram[1,1]^((1-p)/2);
 mat[2,2] := gram[3,4] * gram[2,2]^((1-p)/2);
 ConvertToMatrixRep( mat, f );
 frob := FrobeniusAutomorphism( f );
 a := ProjElWithFrob( mat, frob, f);
 gens := ShallowCopy( GeneratorsOfGroup(go) );
 Add(gens, a);
 coll := GroupWithGenerators( gens );
 SetName( coll, Concatenation("PGammaO-(",String(d),",",String(q),")") );
 SetSize( coll, Size(go) * Order(frob) );
 else
 ## We must find a semisimilarity for the first (2x2) block. Then
 ## simply extend it naturally to fit with the canonical form.

 gram := CanonicalQuadraticForm("elliptic", d, f);
 block :=Forms_RESET( MutableCopyMat( gram{[1,2]}{[1,2]} ), 2, q);
 frob := FrobeniusAutomorphism( f );
 mat := BaseChangeOrthogonalQuadratic(block^(frob^-1), f)[1];

 ## JB is a little bit unsure if this will work all the time. So a test is needed:
 if not Forms_RESET(mat * block^(frob^-1) *TransposedMat(mat), 2, q) = block then
 Error("Inappropriate matrix for change of basis");
 fi;

 mat2 := IdentityMat(d,f);
 mat2{[1,2]}{[1,2]} := mat;
 a := ProjElWithFrob( mat2, frob, f);
 gens := ShallowCopy( GeneratorsOfGroup(go) );
 Add(gens, a);
 coll := GroupWithGenerators( gens );
 SetName( coll, Concatenation("PGammaO-(",String(d),",",String(q),")") );
 SetSize( coll, Size(go) * Order(frob) );
 fi;

 return coll;
 end );

###### Orthogonal (parabolic) groups ######

#############################################################################
#O GammaO( <d>, <f> )
## returns the projective semi-similarity group of a parabolic orthogonal form
## We rely on GO (available in GAP).
##
InstallMethod( GammaO, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local q, p, go, gens, frob, m, b, lambda, g, w, one;
 one := One(f);
 q := Size(f);
 p := Characteristic(f);
 go := GO(0, d, q);
 gens := ShallowCopy(GeneratorsOfGroup(go));
 frob := FrobeniusAutomorphism( f );
 if IsOddInt(q) then
 m := InvariantBilinearForm(GO(0,d,q))!.matrix;
 b := BaseChangeOrthogonalBilinear(m, f)[1];
 gens := List(gens, t->b*t*b^-1);;
 else
 m := InvariantQuadraticForm(GO(0,d,q))!.matrix;
 b := BaseChangeOrthogonalQuadratic(m, f)[1];
 gens := List(gens, t->b*t*b^-1);;
 fi;
 if IsOddInt(p) then
 if q mod 8 in [5,7] then
 w := Z(p) * ((p + 1) / 2);
 else
 w := one * ((p + 1) / 2);
 fi;
 else
 w := one;
 fi;
 lambda := First(AsList(f),t->t^2 = w^(p-1));
 gens := List(gens, x -> [x,frob^0]);
 Add(gens, [lambda * IdentityMat(d, f), frob] );
 gens := ProjElsWithFrob( gens, f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGammaO(",String(d),",",String(q),")") );
 SetSize( g, Order(frob) * Size(go) / GCD_INT(2,q-1) );
 ## Careful to read Kleidman and Liebeck correctly. For q even, we take the symplectic group.
 return g;
 end );

###### Orthogonal (hyperbolic) groups ######

#############################################################################
#O DeltaOplus( <d>, <f> )
## returns the projective similarity group of an hyperbolic orthogonal form
## We rely on GO (available in GAP).
##
InstallMethod( DeltaOplus, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local q, go, m, w, mu, i, gens, g, b;
 q := Size(f);
 go := GO(1, d, q);
 gens := ShallowCopy(GeneratorsOfGroup(go));

 if IsOddInt(q) then
 m := InvariantBilinearForm(go)!.matrix;
 b := BaseChangeOrthogonalBilinear(m, f)[1];
 w := PrimitiveRoot( f );

 ## put primitive root on odd places of diagonal
 ## of identity matrix

 mu := IdentityMat(d,f);
 for i in [1..d/2] do
 mu[2*i-1,2*i-1] := w;
 od;

 gens := List(gens, t->b*t*b^-1);;
 Add(gens, mu);
 else
 m := InvariantQuadraticForm(go)!.matrix;
 b := BaseChangeOrthogonalQuadratic(m, f)[1];
 gens := List(gens, t->b*t*b^-1);;
 fi;

 gens := ProjElsWithFrob( List(gens, x -> [x,IdentityMapping(f)]), f );
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PDeltaO+(",String(d),",",String(q),")") );
 SetSize( g, 2*q^(d*(d-2)/4)*(q^(d/2)-1)*Product(List([1..d/2-1],
 i -> (q^(2*i)-1) )) );
 return g;
 end );

#############################################################################
#O GammaOplus( <d>, <f> )
## returns the projective semi-similarity group of an hyperbolic orthogonal form
## We rely on DeltaOplus and the Frobenius automorphism.
##
InstallMethod( GammaOplus, [IsPosInt, IsField and IsFinite],
 function(d, f)
 local q, deltao, gens, frob, lambda, g;
 q := Size(f);
 deltao := DeltaOplus(d, f);
 gens := ShallowCopy(GeneratorsOfGroup(deltao));
 frob := FrobeniusAutomorphism( f );
 Add(gens, ProjElWithFrob( IdentityMat(d, f), frob, f ));
 g := GroupWithGenerators( gens );
 SetName( g, Concatenation("PGammaO+(",String(d),",",String(q),")") );
 SetSize( g, Log(q, Characteristic(f)) * Size(deltao) );
 return g;
 end );

###### Hermitian groups ######

#############################################################################
#O GammaU( <d>, <f> )
## returns the projective semi-similarity group of hermitian form
## We rely on GU and the Frobenius automorphism.
##
## Issue here. The centre of GammaU is nontrivial for d=2.
## Our construction of classical groups in FinInG factors out the scalars,
## but not the full centre.
##
InstallMethod( GammaU, [IsPosInt, IsField and IsFinite],
 function(d, f)
 ## bug here, there is more than scalars in the kernel of the action!
 local m, frob, b, gens, g, q, sqrtq, gu;
 q := Size(f);
 sqrtq := Sqrt(Size(f));
 m := InvariantSesquilinearForm(GU(d,sqrtq))!.matrix;
 b := BaseChangeHermitian(m, f)[1];
 frob := FrobeniusAutomorphism(f);
 gu := GU(d,sqrtq);
 gens := GeneratorsOfGroup( gu );
 gens := List( gens, y -> b * y * b^-1);
 gens := List( gens, x -> [x, frob^0]);
 Add(gens, [IdentityMat(d, f), frob] );
 gens := ProjElsWithFrob( gens, f );
 g := GroupWithGenerators( gens );
 SetSize( g, Order(frob) * Size(gu) / (sqrtq+1) );
 if d = 2 then
 Info(InfoFinInG, 1, "Warning: We have only factored scalars out of GammaU to construct a central cover of PGammaU.\n The centre is thus nontrivial and acts trivially on totally isotropic 1-spaces.");
 Info(InfoFinInG, 2, "So be careful because you're opening a can of worms!");
 SetName( g, Concatenation("2.PGammaU(",String(d),",",String(sqrtq),"^2)") );
 else
 SetName( g, Concatenation("PGammaU(",String(d),",",String(sqrtq),"^2)") );
 fi;
 return g;
 end );

Quelle group.gi Sprache: unbekannt

[Dauer der Verarbeitung: 0.45 Sekunden, vorverarbeitet 2026-04-25]