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

Stored Attributes of an Automorphism Group

Groups of automorphisms have several attributes that may be stored as part of their data structure. The function HasAttribute is used to test if an attribute is stored and to retrieve its value, while the function SetAttribute is used to set attribute values. The user is warned that when using SetAttribute the data given is not checked for validity, apart from some simple type checks. Setting attributes incorrectly will result in errors.

HasAttribute(A, s) : GrpAuto, MonStgElt -> BoolElt, .
SetAttribute(A, s, v) : GrpAuto, MonStgElt, . ->
The HasAttribute function returns whether the group of automorphisms A has the attribute named by the string s defined and, if so, also returns the value of the attribute.

The SetAttribute procedure sets the attribute of the group of automorphisms group named by string s to have value v. The possible names are:

Group: The base group of the automorphism group. This is always set.

Order: The order of the automorphism group. It is an integer and may be set by giving either an integer or a factored integer.

OuterOrder: The order of the outer automorphism group associated with A. It is an integer and may be set by giving either an integer or a factored integer.

Soluble: (also Solvable) A boolean value telling whether or not the automorphism group is soluble.

InnerGenerators: A sequence of generators of A known to be inner automorphisms.

InnerMap: A homomorphism from the base group to the automorphism group taking each base group element to its corresponding inner automorphism.

ClassAction: Stores the result of the PermutationRepresentation function call.

ClassImage: Stores the result of the PermutationGroup function call.

ClassUnion: Stores the result of the ClassUnion function call.

FpGroup: Stores the result of the FPGroup function call.

OuterFpGroup: Stores the result of the OuterFPGroup function call.

GenWeights: WeightSubgroupOrders: See the section on automorphism groups in the chapter on soluble groups for details.


Example GrpAuto_characteristicsubgps (H67E7)

We select a group of order 904 from the small groups database and compute its group of automorphisms.

> G := SmallGroup(904, 4);
> FactoredOrder(G);
[ <2, 3>, <113, 1> ]
> FactoredOrder(Centre(G));
[ <2, 1> ]
> A := AutomorphismGroup(G);
> FactoredOrder(A);
[ <2, 7>, <7, 1>, <113, 1> ]
> HasAttribute(A, "FpGroup");     
false
> HasAttribute(A, "OuterFpGroup");
false

Note that values for some attributes, such as FpGroup, have not been calculated. The outer automorphism group has order 25 x 7. We find the characteristic subgroups of G.

> n := NormalSubgroups(G);
> [x`order : x in n];
[ 1, 2, 113, 4, 226, 452, 452, 452, 904 ]
> characteristics := [s : x in n |
>   forall{f: f in Generators(A) | s@f eq s}
>   where s is x`subgroup]; 
> [#s : s in characteristics];
[ 1, 2, 113, 4, 226, 452, 904 ]
Note that two of the normal subgroups of order 452 are not characteristic.

Example GrpAuto_auto-maximals (H67E8)

> G := AlternatingGroup(6);
> A := AutomorphismGroup(G);
> HasAttribute(A, "OuterFpGroup");
true 
> F, f := FPGroup(A);
> O, g := OuterFPGroup(A);
> O;
Finitely presented group O on 2 generators
Relations
  O.1^2 = Id(O)
  O.2^2 = Id(O)
  (O.1 * O.2)^2 = Id(O)
> A`OuterOrder;
4
We find the outer automorphism group is elementary abelian of order 4. The direct product of G with itself has maximal subgroups isomorphic to G, in the form of diagonal subgroups. We can construct four non-conjugate examples using the outer automorphism group. The first example can be constructed without using an outer automorphism.

> GG, ins := DirectProduct(G, G);
> M := sub<GG|[(x@ins[1])*(x@ins[2]):x in Generators(G)]>;
> IsMaximal(GG, M);
true
The subgroup M is the first, the obvious diagonal, constructed using just the embeddings returned by the direct product function. We get others by twisting the second factor using an outer automorphism. First we get (representatives of) the outer automorphisms explicitly.

> outers := {x @@ g @ f : x in [O.1, O.2, O.1*O.2]};
> Representative(outers);
Automorphism of GrpPerm: G, Degree 6, Order 2^3 * 3^2 * 5 which maps:
  (1, 2)(3, 4, 5, 6) |--> (1, 3, 6, 2)(4, 5)
  (1, 2, 3) |--> (1, 4, 2)(3, 5, 6)
The set outers now contains three distinct outer automorphisms of G. We use them to get three more diagonal subgroups.

> diags := [M] cat 
> [sub<GG|[(x @ ins[1])*(x @ f @ ins[2]):x in Generators(G)]>:
>   f in outers];
> [IsMaximal(GG, m) : m in diags];
[ true, true, true, true ]
> IsConjugate(GG, diags[2], diags[4]);
false
The other five tests for conjugacy will give similarly negative results.
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

Version: V2.19 of Mon Dec 17 14:40:36 EST 2012