# 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.

`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 ] ] ```

GAP 3.4.4
April 1997