Automorphisms

The following functions construct the standard automorphisms of a group of Lie type, as described in [Car72] (except for the graph automorphism of G2). In many cases, including the finite groups, every automorphism is a product of these standard automorphisms.

Contents

Basic Functionality

AutomorphismGroup(G) : GrpLie -> GrpLieAuto
Automorphism group of a group of Lie type G.
IdentityAutomorphism(G) : GrpLie -> GrpLieAutoElt
One(A) : GrpLieAuto -> GrpLieAutoElt
Id(A) : GrpLieAuto -> GrpLieAutoElt
The identity automorphism of the group of Lie type G.
Mapping(a) : GrpLieAutoElt -> Map
The map object associated with the automorphism a.
Automorphism(m) : Map -> GrpLieAutoElt
Given a map object m from G to G, which is an isomorphism, returns the associated automorphism as an automorphism of a group of Lie type.
h * g : GrpLieAutoElt, GrpLieAutoElt -> GrpLieAutoElt
The composition of the group of Lie type automorphisms h and g.
h ^ n : GrpLieAutoElt, RngIntElt -> GrpLieAutoElt
The nth power of the group of Lie type automorphism h.
g ^ h : GrpLieAutoElt, GrpLieAutoElt -> GrpLieAutoElt
The conjugate h - 1gh, where g and h are group of Lie type automorphisms g and h
Domain(A) : GrpLieAuto -> GrpLie
Codomain(A) : GrpLieAuto -> GrpLie
Domain(h) : GrpLieAutoElt -> GrpLie
Codomain(h) : GrpLieAutoElt -> GrpLie
Domain or codomain of an automorphism of a group of Lie type or of the group of automorphisms.

Constructing Special Automorphisms

InnerAutomorphism(G, x) : GrpLie, GrpLieElt -> Map
The inner automorphism taking g∈G to gx, where x is an element of the group of Lie type G.
DiagonalAutomorphism(G, v) : GrpLie, ModTupRngElt -> Map
The diagonal automorphism of the semisimple group of Lie type G given by the vector v. Let n be the semisimple rank of G and let k be its base field. Then v must be a vector in kn with every component nonzero. The function returns the automorphism given by the character χ defined by χ(αi)=vi, where αi is the ith simple root. Since our groups are algebraic, a diagonal automorphism is just a special case of an inner automorphism.
GraphAutomorphism(G, p) : GrpLie, GrpPermElt -> Map
DiagramAutomorphism(G, p) : GrpLie, GrpPermElt -> Map
    SimpleSigns: Any                    Default: 1
The graph automorphism of the group of Lie type G given by the permutation p. The permutation must act on the indices of simple roots of G or the indices of all roots of G. The graph automorphism of the group of type G2 has not been implemented yet.

The optional parameter SimpleSigns can be used to specify the signs corresponding to each simple root. This should either be a sequence of integers ∓ 1, or a single integer ∓ 1.

FieldAutomorphism(G, sigma) : GrpLie, Map -> Map
The field automorphism of the group of Lie type G induced by σ, an element of the automorphism group of the base field of G
RandomAutomorphism(G) : GrpLie -> GrpLieAutoElt
Random(A) : GrpLieAuto -> GrpLieAutoElt
A random element in A, the automorphism group of the group of Lie type G.
DualityAutomorphism(G) : GrpLie -> GrpLieAutoElt
The duality automorphism of G. This is an automorphism that takes every unipotent term xr(t) to xs(∓ t), where s= Negative(RootDatum(G),r)).
FrobeniusMap(G,q) : GrpLie, RngIntElt -> GrpLieAutoElt
The Frobenius automorphism of the finite group of Lie type G gotten by qth powers in the base field. The integer q must be a power of the characteristic of the base field of G.

Operations and Properties of Automorphisms

DecomposeAutomorphism(h) : GrpLieAutoElt -> GrpLieAutoElt, GrpLieAutoElt,GrpLieAutoElt, Rec
Given a group of Lie type automorphism h, this returns a field automorphism f, a graph automorphism g and an inner automorphism i such that h=fgi. This only works for groups defined over finite fields. The algorithm is due to Scott Murray and Sergei Haller.
IsAlgebraic(h) : GrpLieAutoElt -> BoolElt
Returns true if and only if the automorphism h is algebraic.

Example GrpLie_Automorphism (H110E19)

Some automorphisms of B2(4)
> G := GroupOfLieType("B2", GF(4));
> A := AutomorphismGroup(G);
> A!1 eq IdentityAutomorphism(G);
true
> g := GraphAutomorphism(G, Sym(2)!(1,2));
> g;
Automorphism of Group of Lie type B2 over Finite field of size 2^2
given by: Mapping from: Group of Lie type  to Group of Lie type
given by a rule
Decomposition:
  Mapping from: GF(2^2) to GF(2^2) given by a rule,
  (1, 2),
  1
The automorphism of B2(4) whose stabiliser is ()2B2(4) is constructed by the following code.
> sigma := iso< GF(4) -> GF(4) | x :-> x^2, x :-> x^2 >;
> h := FieldAutomorphism(G, sigma) * g;
> h in A;
true
> f,g,i := DecomposeAutomorphism(h);
> assert f*g*i eq h;
V2.28, 13 July 2023