67.19 RecogniseClassical

RecogniseClassical( G [,strategy] [,case] [,N] )

RecogniseClassical takes as input a group G, which is a subgroup of GL(d,q) with d > 1, and seeks to decide whether or not G contains a classical group in its natural representation over a finite field.

strategy is one of the following:

"clg":

use the algorithm of Celler and Leedham-Green [3].

"np":

use the algorithm of Niemeyer and Praeger [11, 12].

The default strategy is "clg".

The parameter case is used to supply information about the specific non-degenerate bilinear, quadratic or sesquilinear forms on the underlying vector space V preserved by G modulo scalars. The value of case must be one of the following:

"all":

RecogniseClassical will try to determine the case of G. This is the default. "linear":
G le GL(d,q), and preserves no non-degenerate bilinear, quadratic or sesquilinear form on V. Set Omega := SL(d,q). "symplectic":
G le GSp(d,q), with d even, and if q is also even we assume that G preserves no non-degenerate quadratic form on V. Set Omega := Sp(d,q).

"orthogonalplus":

G le GO^+(d,q) and d is even. Set Omega := Omega^+(d,q).

"orthogonalminus":

G le GO^-(d,q) and d is even. Set Omega := Omega^-(d,q).

"orthogonalcircle":

G le GO^circ(d,q) and d is odd. Set Omega := Omega^circ(d,q). "unitary":
G le GU(d,q), where q is a square. Set Omega := SU(d,q).

N is a positive integer which determines the number of random elements selected. Its default value depends on the strategy and case; see RecogniseClassicalCLG and RecogniseClassicalNP for additional details.

In summary, the aim of RecogniseClassical is to test whether G contains the subgroup Omega corresponding to the value of case.

The function returns a record whose contents depends on the strategy chosen. Detailed information about components of this record can be found in RecogniseClassicalCLG and RecogniseClassicalNP. However, the record has certain common components independent of the strategy and these can be accessed using the following flag functions.

ClassicalTypeFlag:

returns "linear", "symplectic", "orthogonalplus", "orthogonalminus", "orthogonalcircle" or "unitary" if G is known to be a classical group of this type modulo scalars, otherwise "unknown". Note that Sp(2,q) is isomorphic to SL(2,q); "linear" not "symplectic" is returned in this case.

IsSLContainedFlag:

returns true if G contains the special linear group SL(d,q).

IsSymplecticGroupFlag:

returns true if G is contained in GSp(d,q) modulo scalars and contains Sp(d,q). IsOrthogonalGroupFlag:
returns true if G is contained in an orthogonal group modulo scalars and contains the corresponding Omega. IsUnitaryGroupFlag:
returns true if G is contained in an unitary group modulo scalars and contains the corresponding Omega.

These last four functions return true, false, or "unknown". Both true and false are conclusive. The answer "unknown" indicates either that the algorithm failed to determine whether or not G is a classical group or that the algorithm is not applicable to the supplied group; see RecogniseClassicalCLG and RecogniseClassicalNP for additional details.

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

Example 1

    gap> G := SL(7, 5);
    SL(7,5)
    gap> r := RecogniseClassical( G, "clg" );;
    gap> ClassicalTypeFlag(r);
    "linear"
    gap> IsSLContainedFlag(r);
    true
    gap> r := RecogniseClassical( G, "np" );; 
    gap> ClassicalTypeFlag(r);
    "linear"
    gap> IsSLContainedFlag(r);
    true 

    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" 

The algorithms are described in [3, 11, 12].

Previous Up Top Next
Index