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 AssertAttribute
is used to set attribute values. The user is warned that when using
AssertAttribute the data given is not checked for validity,
apart from some simple type checks. Setting attributes incorrectly
will result in errors.
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 AssertAttribute 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.
The attribute is a pair < F, m > where F is an fp-group and m is an
isomorphism m:F to A. F and m are the two return values of FPGroup(A).
OuterFpGroup: Stores the result of the OuterFPGroup function call.
The attribute is a pair < O, f > where O is an fp-group and f is an
epimorphism f:F to O, where F is the first component of the FpGroup attribute.
The kernel of f is the inner automorphism group.
O and f are the two return values of OuterFPGroup(A).
GenWeights: WeightSubgroupOrders: See the section on
automorphism groups in the chapter on soluble groups for details.
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
> F,m := FPGroup(A);
> AssertAttribute(A, "FpGroup", <F,m>);
Note that values for some attributes, such as
FpGroup, have not
been calculated by the original
AutomorphismGroup call,
but they may be calculated and set later if desired.
The outer automorphism group has order 2
5 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.
> 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]