[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Composition Trees for Matrix Groups

A composition tree for a group G can be viewed as a data structure that present a group in terms of its composition factors. The tree is constructed recursively and the data structure facilitates the rewriting of elements of G in terms of different generating sets.

The basic strategy for computing a composition tree of a matrix group employs a combination of a constructive version of Aschbacher's theorem [Asc84] and constructive recognition algorithms for finite simple groups. The basic algorithms are described in [LG01], [O'B06], [O'B11] while some new ideas introduced in [NS06] are incorporated. A detailed account of the entire CompositionTree procedure appears in [BHLGO11].

The algorithm to construct a composition tree proceeds as follows. Given a group G, either:

(i)
Construct an effective homomorphism φ: G to G1, for some group G1. We call φa reduction since G1 is "smaller" than G in some respect -- for example, its degree or field of definition.
(ii)
Or deduce that G is cyclic, elementary abelian, or "close" to being non-abelian simple. Now G becomes a leaf in the tree.

Assume that Case (i) applies.
1.
Now construct a composition tree for G1.
2.
Construct generators for G0 := ( Ker)(φ). This requires a rewriting algorithm for G1.
3.
Construct a composition tree for G0.
4.
Combine the composition trees for G1 and G0 into a tree for G.

If G ≤GL(d, q), then we exploit Aschbacher's theorem [Asc84] in Step (1). This requires algorithms to decide if G lies in a certain Aschbacher class, and to construct the corresponding φ. Other homomorphisms, such as the determinant map, may also be used.

The group associated with a leaf need not be simple. It may be cyclic or elementary abelian, a soluble or non-abelian simple primitive permutation group, or an absolutely irreducible matrix group that is simple modulo its centre. The decisions on just which groups are treated as a leaves are partly dictated by complexity considerations, and partly based on the quality of available algorithms to process a leaf. For example, we observe no practical advantage flowing from refining a cyclic group to its composition factors.

Once a composition tree for G = < X > has been constructed, then a second list Y of nice generators are stored with G. We call < Y > the nice group. The intrinsic CompositionTree constructs the nice generators Y as SLPs in X. The rewriting algorithm solves rewriting problems on Y and the resulting SLPs can then be rewritten to provide SLPs on X.

The verbose flag SetVerbose("CompositionTree", n) with n=1, ..., 10 may be used to print increasing levels of information on the progress of the functions.

CompositionTree(G : parameters) : GrpMat[FldFin] -> []
    Verify: BoolElt                     Default: false
    Scalar: FldFinElt                   Default: 1
    KernelBatchSize: RngIntElt          Default: 5
    MandarinBatchSize: RngIntElt        Default: 100
    MaxHomFinderFails: RngIntElt        Default: 1
    MaxQuotientOrder: RngIntElt         Default: 10^6
    FastTensorTest: BoolElt             Default: true
    MaxBSGSVerifyOrder: RngIntElt       Default: 2000
    AnalysePermGroups: BoolElt          Default: false
    KnownLeaf: BoolElt                  Default: false
    NamingElements: RngIntElt           Default: 200
    UnipotentBatchSize: RngIntElt       Default: 100
    PresentationKernel: BoolElt         Default: true
Given a matrix group G defined over a finite field, this intrinsic constructs a composition tree for G and returns the tree.

Verify: If true, then verify correctness of the tree during construction.

KernelBatchSize: The number of normal generators used to construct the kernel of homomorphism.

MandarinBatchSize: The number of random elements used to check correctness of the outcome of Monte-Carlo algorithms.

MaxHomFinderFails: Assume a negative answer after this many failures of certain Monte Carlo algorithms.

AnalysePermGroups: If false, then always treat the permutation group as a leaf, and do not analyse its structure.

NamingElements: The number of random elements used in calls to LieType and RecogniseClassical.

MaxQuotientOrder: A leaf with larger order will not be fully refined to its composition factors.

FastTensorTest: Use only the fast tensor product test.

MaxBSGSVerifyOrder: If RandomSchreier is used on a leaf and it has order less than MaxBSGSVerifyOrder, then Verify the calculation.

PresentationKernel: Use presentations to obtain kernels, where possible.

UnipotentBatchSize: Batch size for the unipotent kernels.

CompositionTreeFastVerification(G) : Grp -> BoolElt
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic determines if correctness of the composition tree can be verified at modest cost using presentations. In effect, the intrinsic determines whether presentations on nice generators are known for all the leaves.
CompositionTreeVerify(G) : Grp -> BoolElt, []
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic verifies the correctness of the composition tree by using it to construct a presentation for G. If G satisfies the presentation, then return true, and the relators of the presentation as SLPs; otherwise return false. The presentation is on the group returned by CompositionTreeNiceGroup(G).
CompositionTreeNiceGroup(G) : Grp -> GrpMat[FldFin]
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. The intrinsic returns the nice group for G.
CompositionTreeSLPGroup(G) : Grp -> GrpSLP, Map
The argument G must be a matrix group over a finite field for which a composition tree datastructure and the associated nice group H has previously been constructed. The intrinsic returns the word group W for H, and the map from W to H.
DisplayCompTreeNodes(G : parameters) : Grp ->
    NonTrivial: BoolElt                 Default: true
    Leaves: BoolElt                     Default: false
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic displays information about the nodes in the composition tree for G. The tree is traversed in-order. If parameter NonTrivial is true, then only non-trivial nodes will be displayed. If parameter Leaves is true then only leaves will be displayed.
CompositionTreeNiceToUser(G) : Grp -> Map, []
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the coercion map from SLPs in nice generators of G to SLPs in input user generators of G, as well as the SLPs of the nice generators given in terms the user generators.
CompositionTreeOrder(G) : Grp -> RngIntElt
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the order of G.
CompositionTreeElementToWord(G, g) : Grp, GrpElt -> BoolElt, GrpSLPElt
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. Given an element g∈G, return true and an SLP for g in the nice generators of G, otherwise return false.
CompositionTreeCBM(G) : GrpMat[FldFin -> GrpMatElt
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns a change-of-basis matrix that exhibits the Aschbacher reductions of G given by the composition tree.
CompositionTreeReductionInfo(G, t) : Grp, RngIntElt -> MonStgElt,Grp, Grp
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns a string description of the reduction at the internal node t in the composition tree for G, as well as the image and kernel of this reduction.
CompositionTreeSeries(G) : Grp -> SeqEnum, List, List, List, BoolElt, []
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns:
1.
A normal series of subgroups 1 = G0 < G1 < ... < Gk = G.
2.
Maps Gi |-> Si, where Si is the standard copy of Gi / Gi - 1, where i ≥1. The kernel of this map is Gi - 1. Observe that Si may be the standard copy plus scalars Z, and the map is then a homomorphism modulo scalars, so that the kernel is (Gi - 1.Z)/Z.
3.
Maps Si |-> Gi.
4.
Maps Si |-> WordGroup(Si).
5.
Boolean flag true or false to indicate if the series is a true composition series.
6.
A sequence of the leaf nodes in the composition tree corresponding to each composition factor. All maps are defined by rules, so Function can be applied on them to avoid built-in membership testing.
CompositionTreeFactorNumber(G, g) : Grp, GrpElt -> RngIntElt
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic returns the minimal integer i such that g lies in the ith-term of the normal series returned by CompositionTreeSeries for G.
HasCompositionTree(G) : Grp -> BoolElt
Given a matrix group G defined over a finite field, this intrinsic returns true if G has a composition tree and false otherwise.
CleanCompositionTree(G) : Grp ->
The argument G must be a matrix group over a finite field for which a composition tree datastructure has previously been constructed. This intrinsic removes all data related to the composition tree datastructure for G.

Example GrpMatFF_CompTree1 (H60E11)

We construct a composition tree for the conformal orthogonal group G of plus type of degree 4 over GF(52).

> G := CGOPlus(4, 5^2);
> 
> T := CompositionTree(G);
> 
> DisplayCompTreeNodes (G: Leaves:=true);
node = 2
parent = 1
depth = 1
scalar = 1
info = leaf, GrpAb, cyclic group, order 12
fast verify = true
----------
node = 4
parent = 3
depth = 2
scalar = 1
info = leaf, GrpAb, cyclic group, order 4
fast verify = true
----------
node = 7
parent = 6
depth = 4
scalar = 12
info = leaf, GrpAb, cyclic group, order 24
fast verify = true
----------
node = 8
parent = 6
depth = 4
scalar = 2
info = leaf, GrpMat, almost simple, <"A", 1, 25>
fast verify = true
----------
node = 9
parent = 5
depth = 3
scalar = 1
info = leaf, GrpMat, almost simple, <"A", 1, 25>
fast verify = true
----------

We now verify correctness of the composition tree. In order to show what is going on we illustrate various pieces of the verification process. We begin by setting up the nice group H for G and its associated SLP group; observe that H = G. After checking that verification can be done quickly, we perform the verification.

> H := CompositionTreeNiceGroup(G);
> W := CompositionTreeSLPGroup(G);
>
> CompositionTreeFastVerification(G);
true
> 
> f, R := CompositionTreeVerify(G);
> #R;
73

At this point we have verified correctness. However, we now explicitly evaluate the relations R on the generators of H. This step has already been performed by CompositionTreeVerify so it is shown here just for demonstration purposes.

> Set(Evaluate(R, [H.i:i in [1..Ngens(H)]]));
{
    [     1      0      0      0]
    [     0      1      0      0]
    [     0      0      1      0]
    [     0      0      0      1]
}

Now that we know that the composition tree is correct, we ask for the order of G.

> CompositionTreeOrder(G);                                
11681280000                                                

Express the element g of G as a SLP on the generators of the nice group H.

> g := Random(G);
> f, w := CompositionTreeElementToWord(G, g);
> Evaluate(w, [H.i:i in [1..Ngens(H)]]) eq g;
true
Rewrite the SLP in terms of the user-supplied generators for G.

> tau := CompositionTreeNiceToUser(G);
> tau;
Mapping from: GrpSLP: W to SLPGroup(5)
Images of elements of W under tau lie in WordGroup(G).

> v := tau(w);
> Evaluate (v, [G.i : i in [1..Ngens(G)]]) eq g;
true
Test a random element of the generic group for G for membership. (The generic group will be the general linear group GL(4, 52).)

> x := Random(Generic(G));
> f, w := CompositionTreeElementToWord(G, x);
> f; 
false

Finally, we construct a normal series for G and locate a random element within this series.

> CS, _, _, _, flag := CompositionTreeSeries(G);
> "Series is composition series? ", flag;
Series is composition series?  true
> "Length is ", #CS;
Length is  10
> 
> g := Random(G);
> CompositionTreeFactorNumber(G, g);
10

Example GrpMatFF_CompTree2 (H60E12)

In this example, we choose a maximal subgroup of the linear group SL(10, 28) and compute its composition tree.

> X := ClassicalMaximals ("L", 10, 2^8);
> G := X[1];
> 
> T := CompositionTree (G);
> 
> DisplayCompTreeNodes (G: Leaves:=true, NonTrivial:=true);
node = 6
parent = 5
depth = 5
scalar = 1
info = leaf, GrpAb, cyclic group, order 255
fast verify = true
----------
node = 9
parent = 8
depth = 5
scalar = 1
info = leaf, GrpMat, almost simple, <"A", 8, 256>
fast verify = true
----------
node = 13
parent = 12
depth = 3
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 15
parent = 14
depth = 4
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 17
parent = 16
depth = 5
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 19
parent = 18
depth = 6
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 21
parent = 20
depth = 7
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 23
parent = 22
depth = 8
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 25
parent = 24
depth = 9
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 27
parent = 26
depth = 10
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------
node = 29
parent = 28
depth = 11
scalar = 1
info = leaf, GrpPC, abelian group, order 256
fast verify = true
----------

We now set up the nice group H for G and its associated SLP group; observe that H = G.

> H := CompositionTreeNiceGroup(G);
> "# of generators of H is ", Ngens(H);
# of generators of H is  77
> W := CompositionTreeSLPGroup(G);

After checking that correctness of the composition tree can be verified quickly, we perform verification.

> CompositionTreeFastVerification(G);
true
> f, R := CompositionTreeVerify(G);
> #R;
3028

Evaluate the relations on the generators of H.

> Set (Evaluate (R, [H.i:i in [1..Ngens (H)]]));
{
    [1 0 0 0 0 0 0 0 0 0]
    [0 1 0 0 0 0 0 0 0 0]
    [0 0 1 0 0 0 0 0 0 0]
    [0 0 0 1 0 0 0 0 0 0]
    [0 0 0 0 1 0 0 0 0 0]
    [0 0 0 0 0 1 0 0 0 0]
    [0 0 0 0 0 0 1 0 0 0]
    [0 0 0 0 0 0 0 1 0 0]
    [0 0 0 0 0 0 0 0 1 0]
    [0 0 0 0 0 0 0 0 0 1]
}

Express the element g of G as a SLP on the generators of the nice group H. Then rewrite the SLP in terms of user generators for G.

> g := Random (G);
> f, w := CompositionTreeElementToWord (G, g);
> Evaluate (w, [H.i:i in [1..Ngens (H)]]) eq g;
true
>
> tau := CompositionTreeNiceToUser (G);
> tau;
Mapping from: GrpSLP: W to SLPGroup(4)
> 
> v := tau (w);
> Evaluate (v, [G.i : i in [1..Ngens (G)]]) eq g;
true

Next test a random element of the generic group of G for membership of G.

> x := Random (Generic (G));
> f, w := CompositionTreeElementToWord (G, x);
> f; 
false

Finally, we construct a normal series for G.

> CS, _, _, _, flag := CompositionTreeSeries (G);
> "Series is composition series? ", flag;
Series is composition series?  true
> "Length is ", #CS;
Length is  78

 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Wed Apr 24 15:09:57 EST 2013