67.22 RecogniseClassicalCLG

In this section, we describe functions developed by Celler and Leedham-Green (see [3] for details) to recognise classical groups in their natural representation over finite fields.

RecogniseClassicalCLG( G [,case] [,N] )

This is the top-level function, taking as input a group G, which is a subgroup of GL(d,q) with d > 1. The other optional arguments have the same meaning as those supplied to RecogniseClassical. The default value of N, the number of random elements to consider, depends on the case; it is 40 for small fields and dimensions, but decreases to 10 for larger dimensions.

Constraints

In the case of an orthogonal group, the dimension of the underlying vector space must be at least 7, since there are exceptional isomorphisms between the orthogonal groups in dimensions 6 or less and other classical groups which are not dealt with in RecogniseClassical-CLG. In dimension 8, RecognizeSO will not rule out the possibility of O_7(q) embedded as irreducible subgroup of O_8^+(q). Since G must also act irreducibly, RecogniseClassicalCLG does not recognise O_{2n+1}^0(2^k).

The record returned by this function is similar to that described in RecogniseClassical. In particular, the flag functions described there and below can be applied to the record. You should ignore undocumented record components.

Additional information

DualFormFlag:

if G has been proved to be a symplectic or orthogonal group, DualFormFlag returns the symplectic or orthogonal form.

QuadraticFormFlag:

if G has been proved to be an orthogonal group, QuadraticFormFlag returns the quadratic form.

UnitaryFormFlag:

if G has been proved to be a unitary group, DualFormFlag returns the symplectic or orthogonal form.

If RecogniseClassical failed to prove that G is a classical group, additional information about the possible Aschbacher categories of G might have been obtained.

In particular, the following flag functions may be applied to the record. If one of these functions returns a list, it has the following meaning: if G belongs to the corresponding Aschbacher category, then G is determined by one of the possibilities returned; it does not imply that G is a member of this category. However, an empty list indicates that G does not belong to this category. Each of these functions may also return "unknown".

A group G is almost simple if G contains a non-abelian simple group T and is contained in the automorphism group of T. If G is almost simple, then G is either an almost sporadic group, an almost alternating group, or an almost Chevalley group.

PossibleAlmostSimpleFlag:

if G is not a classical group, this function returns a list of possible almost sporadic groups modulo scalars. This function deals only with sporadic groups T. The names of the corresponding non-abelian simple groups are returned. Possible names are: "M11", "M12", "M22", "M23", "M24", "J2", "Suz", "HS", "McL", "Co3", "Co2", "Co1", "He", "Fi22", "Fi23", "F3+", "HN", "Th", "B", "M", "J1", "ON", "J3", "Ly", "Ru", "J4".

PossibleAlternatingGroupsFlag:

if G is not a classical group, this function returns a list of possible almost alternating groups modulo scalars. This list contains the possible degrees as integers.

PossibleChevalleyGroupsFlag:

if G is not a classical group, this function returns a list of possible almost Chevalley groups modulo scalars. The various Chevalley groups are described by tuples [ type, rank, p, k ], where type is a string giving the type (e.g. "2A", see [15, p. 170] for details), rank is the rank of the Chevalley group, and p^k is the size of the underlying field.

IsPossibleImprimitiveFlag:

returns true if G might be imprimitive. PossibleImprimitiveDimensionsFlag:
returns the possible block dimensions (IsPossibleImprimitiveFlag must be true).

IsPossibleTensorProductFlag:

returns true if G might be a tensor product. PossibleTensorDimensionsFlag:
returns the possible tensor product dimensions; note that this entry is only valid if Is-Possible-Tensor-Product-Flag is true or Is-Possible-Tensor-Power-Flag is true and the dimension is a square. IsPossibleTensorPowerFlag:
returns true if G might be a tensor power.

IsPossibleSmallerFieldFlag:

retuns true if G could be defined (modulo scalars) over a smaller field.

PossibleSmallerFieldFlag:

returns the the least possible field (IsPossibleSmallerFieldFlag must be true).

IsPossibleSemiLinearFlag:

the natural module could be isomorphic to a module of smaller dimension over a larger field on which this extension field acts semi-linearly.

IsPossibleNormalizerPGroupFlag:

the dimension of the underlying vector space must be r^m for some prime r and G could be an extension of a r-group of symplectic type and exponent rcdotgcd(2,r) by a subgroup of Sp(m,r), modulo scalars. A r-group is of symplectic type if every characteristic abelian subgroup is cyclic.

Examples

    gap> m1 :=
    [ [ 0*Z(17), Z(17), Z(17)^10, Z(17)^12, Z(17)^2 ], 
      [ Z(17)^13, Z(17)^10, Z(17)^15, Z(17)^8, Z(17)^0 ], 
      [ Z(17)^10, Z(17)^6, Z(17)^9, Z(17)^8, Z(17)^10 ], 
      [ Z(17)^13, Z(17)^5, Z(17)^0, Z(17)^12, Z(17)^5 ], 
      [ Z(17)^14, Z(17)^13, Z(17)^5, Z(17)^10, Z(17)^0 ] ];;
    gap> m2 :=
    [ [ 0*Z(17), Z(17)^10, Z(17)^2, 0*Z(17), Z(17)^10 ], 
      [ 0*Z(17), Z(17)^6, Z(17)^0, Z(17)^4, Z(17)^15 ], 
      [ Z(17)^7, Z(17)^6, Z(17)^10, Z(17), Z(17)^2 ], 
      [ Z(17)^3, Z(17)^10, Z(17)^5, Z(17)^4, Z(17)^6 ], 
      [ Z(17)^0, Z(17)^8, Z(17)^0, Z(17)^5, Z(17) ] ];;
    gap> G := Group( m1, m2 );;
    gap> sl := RecogniseClassicalCLG( G, "all", 1 );;
    gap> IsSLContainedFlag(sl);
    "unknown" 

Since the algorithm has a random component, it may fail to prove that a group contains the special linear group even if the group does. As a reminder, IsSLContainedFlag may return true, false, or "unknown".

Here we chose only one random element. If RecogniseClassicalCLG fails but you suspect that the group contains the special linear group, you can restart it using more random elements. You should, however, not change the case. If you don't already know the case, then call RecogniseClassicalCLG either without a case parameter or "all".

    gap> sl := RecogniseClassicalCLG( G, 5 );;
    gap> IsSLContainedFlag(sl);
    true 

The following is an example where G is not an classical group but additional information has been obtained.

    gap> ReadDataPkg ("matrix", "data", "j1.gap" );           
    gap> DisplayMat(GeneratorsFlag(G));   
      9  1  1  3  1  3  3
      1  1  3  1  3  3  9
      1  3  1  3  3  9  1
      3  1  3  3  9  1  1
      1  3  3  9  1  1  3
      3  3  9  1  1  3  1
      3  9  1  1  3  1  3
    
      .  1  .  .  .  .  .
      .  .  1  .  .  .  .
      .  .  . 10  .  .  .
      .  .  .  .  1  .  .
      .  .  .  .  . 10  .
      .  .  .  .  .  . 10
     10  .  .  .  .  .  .
    
    gap> r := RecogniseClassical( G, "clg" );;
    gap> ClassicalTypeFlag(r);
    "unknown"
    gap> IsPossibleImprimitiveFlag(r);
    false
    gap> IsPossibleTensorProductFlag(r);
    false
    gap> IsPossibleTensorPowerFlag(r);  
    false
    gap> PossibleAlmostSimpleFlag(r);
    [ "J1" ]
    gap> PossibleAlternatingGroupsFlag(r);     
    [  ]
    gap> PossibleChevalleyGroupsFlag(r);  
    [ [ "A", 1, 11, 3 ], [ "A", 2, 11, 2 ], [ "A", 3, 11, 1 ],
      [ "G", 2, 11, 1 ] ] 

Previous Up Top Next
Index