Add RandomMatrix, RandomInvertibleMatrix; and fix a problem with a new feature for matrix groups (#6232)

- add a description of the cache `FULLGLNICOCACHE` in the code;
  it is used only by `NicomorphismFFMatGroupOnFullSpace`

- change the keys of `FULLGLNICOCACHE`:
  take the field of the matrix entries into account (not only its size),
  take the `ConstructingFilter` of the matrices into account

- in `NicomorphismFFMatGroupOnFullSpace`, deal with special cases of
  matrices in `IsBlockMatrixRep` (which have no `ConstructingFilter`)
  and in `Is8BitMatrixRep` in the situation that the group itself
  lives over `GF(2)`

- in order to admit the action of `IsMatrixObj` matrices on vectors
  supported by GAP's `Enumerator`s of vector spaces,
  add a `\^` method that `Unpack`s the matrix object
  (Eventually we want to avoid this overhead, but then we need
  `Enumerator`s consisting of vector objects corresponding to the
  matrix objects.)

- add `Matrix` calls in the function that computes preimages under
  an action homomorphism with `Source` a matrix group,
  in order to support matrix group elements of prescribed kinds of
  `IsMatrixObj`.

- add tests for the new supported situations
  (most of the changes were actually forced by already available tests)

* add `\in` methods for matrix object and (`GL` or `SL`)

* avoid some `Unpack` hacks

- introduce `NormedRowVectors_internal( F, base )`,
  and `AsListOfFreeLeftModule_internal( F, base, zero )`,
  in order to admit `IsVectorObj`s in `base` without supporting
  the whole vector space machinery for these objects

- introduce `ExternalSet( G )` for matrix groups `G`,
  meaning the natural `G`-set
  (an undocumented method for permutation groups `G` was already available)

- change `NicomorphismFFMatGroupOnFullSpace` such that we can act
  with the `IsMatrixObj` matrices on their `IsVectorObj` vectors,
  without unpacking the matrices

- support `IsMatrixObj` matrices in the `Random` methods for GL and SL

* adjust also `IsProjectiveActionHomomorphism` methods

* add `RandomMatrix`, `RandomInvertibleMatrix`
  and fix the `RankMat` method for `IsPlistMatrixRep`

Author: ThomasBreuer

doc/ref/matrix.xml

@@ -341,7 +341,9 @@ see&nbsp;<Ref Sect="Mutability and Copyability"/>.
 <Heading>Random Matrices</Heading>
 
 <#Include Label="RandomMat">
+<#Include Label="RandomMatrix">
 <#Include Label="RandomInvertibleMat">
+<#Include Label="RandomInvertibleMatrix">
 <#Include Label="RandomUnimodularMat">
 
 </Section>

grp/classic.gd

@@ -836,7 +836,7 @@ BindGlobal( "SymplecticGroup", function ( arg )
     rep:= filt;
     filt:= IsMatrixGroup;
   else
-    rep:= fail;
+    rep:= ValueOption( "ConstructingFilter" );
   fi;
   if DescribesInvariantBilinearForm( Last( arg ) ) then
     form:= Remove( arg );

lib/grpffmat.gi

@@ -124,46 +124,95 @@ end );
 
 #############################################################################
 ##
-#M  NiceMonomorphism( <ffe-mat-grp> )
+##  the natural G-set of a matrix group consists of the vectors of the
+##  natural module
+##
+InstallOtherMethod( ExternalSet,
+    [ IsFFEMatrixGroup and IsFinite ],
+    function( G )
+    local basis, zero;
+
+    basis:= RowsOfMatrix( One( G ) );
+    zero:= Zero( basis[1] );
+    return ExternalSet( G, AsListOfFreeLeftModule_internal(
+                               FieldOfMatrixGroup( G ), basis, zero ) );
+end );
+
+#############################################################################
+##
+#V  FULLGLNICOCACHE
+##
+##  'NicomorphismFFMatGroupOnFullSpace' uses a cache of length up to 5,
+##  as follows.
+##
+##  - If the argument is a matrix group that fits to an entry of this
+##    cache, in the sense that dimension, field of definition,
+##    and 'ConstructingFilter' of the matrices in the group are the same as
+##    for the cached value, the stored mapping is returned.
+##  - If a new mapping has to be constructed, the first cached entry is
+##    dropped and the new mapping gets added to the cache.
 ##
 MakeThreadLocal("FULLGLNICOCACHE"); # avoid recreating same homom. repeatedly
-FULLGLNICOCACHE:=[];
-InstallGlobalFunction( NicomorphismFFMatGroupOnFullSpace, function( grp )
-    local   field,  dim,  V,  xset,  nice;
+BindGlobal( "FULLGLNICOCACHE", [] );
 
-    field := FieldOfMatrixGroup( grp );
-    dim   := DimensionOfMatrixGroup( grp );
+
+#############################################################################
+##
+#M  NiceMonomorphism( <ffe-mat-grp> )
+##
+InstallGlobalFunction( NicomorphismFFMatGroupOnFullSpace, function( grp )
+    local   rep, filt,  q,  dim,  field,  xset,  nice;
+
+    rep:= Representative( grp );
+    field:= FieldOfMatrixGroup( grp );
+    q:= Size( field );
+    if IsBlockMatrixRep( rep ) then
+      # There is no support for these matrices acting on vectors.
+      filt:= IsPlistRep;
+    elif q = 2 and Is8BitMatrixRep( rep ) then
+      # We cannot keep both 'field' and 'Is8BitMatrixRep',
+      # the latter does not admit matrices over GF(2).
+      filt:= IsGF2MatrixRep;
+#TODO: How can we get rid of these hacks?
+    else
+      filt:= ConstructingFilter( rep );
+    fi;
+    dim:= DimensionOfMatrixGroup( grp );
 
     #check cache
-    V:=Size(field);
-    nice:=First(FULLGLNICOCACHE,x->x[1]=V and x[2]=dim);
-    if nice<>fail then return nice[3];fi;
+    nice:= First( FULLGLNICOCACHE,
+                  x -> x[1] = field and x[2] = dim and x[3] = filt );
+
+    if nice<>fail then return nice[4];fi;
 
     if not (HasIsNaturalGL(grp) and IsNaturalGL(grp)) then
-      grp:=GL(dim,field); # enforce map on full GL
+      # enforce map on full GL
+      grp:= GL( dim, field : ConstructingFilter:= filt );
     fi;
-    V     := field ^ dim;
-    xset := ExternalSet( grp, V );
-
+    xset := ExternalSet( grp );
 
     # STILL: reverse the base to get point sorting compatible with lexicographic
     # vector arrangement
-    SetBaseOfGroup( xset, One( grp ));
+    if IsList( One( grp ) ) then
+      SetBaseOfGroup( xset, One( grp ));
+    else
+      SetBaseOfGroup( xset, RowsOfMatrix( One( grp ) ) );
+    fi;
     nice := ActionHomomorphism( xset,"surjective" );
     SetIsInjective( nice, true );
     if not HasNiceMonomorphism(grp) then
       SetNiceMonomorphism(grp,nice);
     fi;
     # because we act on the full space we are canonical.
     SetIsCanonicalNiceMonomorphism(nice,true);
-    if Size(V)>10^5 then
+    if q^dim > 10^5 then
       # store only one big one and have it get thrown out quickly
-      FULLGLNICOCACHE[1]:=[Size(field),dim,nice];
+      FULLGLNICOCACHE[1]:= [ field, dim, filt, nice ];
     else
       if Length(FULLGLNICOCACHE)>4 then
-        FULLGLNICOCACHE:=FULLGLNICOCACHE{[2..5]};
+        Remove( FULLGLNICOCACHE, 1 );
       fi;
-      Add(FULLGLNICOCACHE,[Size(field),dim,nice]);
+      Add( FULLGLNICOCACHE, [ field, dim, filt, nice ] );
     fi;
 
     return nice;
@@ -190,8 +239,7 @@ local tt;
     # if the permutation image would be too large, compute the orbit.
     TryNextMethod();
   fi;
-  return NicomorphismFFMatGroupOnFullSpace( GL( DimensionOfMatrixGroup( grp ),
-                  Size( FieldOfMatrixGroup( Parent(grp) ) ) ) );
+  return NicomorphismFFMatGroupOnFullSpace( grp );
 end );
 
 #############################################################################
@@ -256,6 +304,25 @@ InstallMethod( \in, "general linear group", IsElmsColls,
            and Length( mat ) = RankMat( mat );
 end );
 
+InstallMethod( \in, "general linear group", IsElmsColls,
+    [ IsMatrixObj, IsFFEMatrixGroup and IsFinite and IsNaturalGL ], 0,
+    function( mat, G )
+    local n, F;
+    n:= NumberRows( mat );
+    F:= FieldOfMatrixGroup( G );
+    return     n = NumberColumns( mat )
+           and n = DimensionOfMatrixGroup( G )
+           and n = RankMat( mat )
+#TODO:
+# Currently we cannot force the rule that all matrices in a matrix
+# group consisting of matrix objects have the same 'BaseDomain',
+# and that this common 'BaseDomain' is equal to the 'FieldOfMatrixGroup'
+# of the group.
+# Eventually we want 'true' only if 'F = BaseDomain( mat )' holds.
+           and ( IsSubset( F, BaseDomain( mat ) ) or
+                 ForAll( Unpack( mat ), row -> IsSubset( F, row ) ) );
+end );
+
 InstallMethod( \in, "special linear group", IsElmsColls,
     [ IsMatrix, IsFFEMatrixGroup and IsFinite and IsNaturalSL ], 0,
     function( mat, G )
@@ -266,6 +333,19 @@ InstallMethod( \in, "special linear group", IsElmsColls,
            and DeterminantMat(mat)=One(FieldOfMatrixGroup( G ));
 end );
 
+InstallMethod( \in, "special linear group", IsElmsColls,
+    [ IsMatrixObj, IsFFEMatrixGroup and IsFinite and IsNaturalSL ], 0,
+    function( mat, G )
+    local n, F;
+    n:= NumberRows( mat );
+    F:= FieldOfMatrixGroup( G );
+    return     n = NumberColumns( mat )
+           and n = DimensionOfMatrixGroup( G )
+           and ( IsSubset( F, BaseDomain( mat ) ) or
+                 ForAll( Unpack( mat ), row -> IsSubset( F, row ) ) )
+           and DeterminantMat( mat ) = One( F );
+end );
+
 
 #############################################################################
 ##
@@ -508,10 +588,23 @@ InstallMethodWithRandomSource( Random,
     "for a random source and natural GL",
     [ IsRandomSource, IsFFEMatrixGroup and IsFinite and IsNaturalGL ],
 function(rs, G)
-    local m;
-    m := RandomInvertibleMat( rs, DimensionOfMatrixGroup( G ),
-                 FieldOfMatrixGroup( G ) );
-    return ImmutableMatrix(FieldOfMatrixGroup(G), m, true);
+    local d, F, m;
+
+    d:= DimensionOfMatrixGroup( G );
+    F:= FieldOfMatrixGroup( G );
+    m:= Representative( G );
+    if IsMatrix( m ) then
+      m:= RandomInvertibleMat( rs, d, F );
+      m:= ImmutableMatrix(F, m, true);
+    else
+      m:= ZeroMatrix( d, d, m );
+      repeat
+        Randomize( rs, m );
+      until RankMat( m ) = d;
+      MakeImmutable( m );
+    fi;
+
+    return m;
 end);
 
 
@@ -527,11 +620,18 @@ InstallMethodWithRandomSource( Random,
     "for a random source and natural SL",
     [ IsRandomSource, IsFFEMatrixGroup and IsFinite and IsNaturalSL ],
 function(rs, G)
-    local m;
-    m:= RandomInvertibleMat( rs, DimensionOfMatrixGroup( G ),
-                FieldOfMatrixGroup( G ) );
-    MultVector(m[1], DeterminantMat(m)^-1);
-    return ImmutableMatrix(FieldOfMatrixGroup(G), m, true);
+    local d, m;
+
+    # We assume that all elements in the group have the same
+    # 'BaseDomain' value, hence we may take any 'Representative'.
+    # see the section "Groups Consisting of Matrix Objects"
+    # in the Reference Manual.
+    d:= DimensionOfMatrixGroup( G );
+    m:= RandomInvertibleMatrix( rs, d, Representative( G ) );
+    MultMatrixRow( m, 1, DeterminantMatrix( m )^-1 );
+    MakeImmutable( m );
+
+    return m;
 end);
 
 #############################################################################

lib/matobjplist.gi

@@ -1218,7 +1218,13 @@ InstallMethod( InverseSameMutability,
 
 InstallMethod( RankMat,
   [ "IsPlistMatrixRep" ],
-  M -> RankMat( List( M![ROWSPOS], x -> x![ELSPOS] ) ) );
+  function( M )
+    M:= M![ROWSPOS];
+    if Length( M ) = 0 then
+      return 0;
+    fi;
+    return RankMat( List( M, x -> x![ELSPOS] ) );
+  end );
 
 InstallMethodWithRandomSource( Randomize,
   "for a random source and a mutable plist matrix",