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

Conjugacy

Class(H, x) : GrpMat, GrpMatElt -> { GrpMatElt }
Conjugates(H, x) : GrpMat, GrpMatElt -> { GrpMatElt }
Given a group H and an element x belonging to a group K such that H and K are subgroups of the same general linear group, this function returns the set of conjugates of x under the action of H. If H = K, the function returns the conjugacy class of x in H.
ClassMap(G) : GrpMat -> Map
Given a group G, construct the conjugacy classes and the class map f for G. For any element x of G, f(x) will be the conjugacy class representative chosen by the Classes function.
ConjugacyClasses(G: parameters) : GrpMat -> [ < RngIntElt, RngIntElt, GrpMatElt > ]
Classes(G: parameters) : GrpMat -> [ < RngIntElt, RngIntElt, GrpMatElt > ]
    WeakLimit: RngIntElt                Default: 500
    StrongLimit: RngIntElt              Default: 5000
    Al: MonStgElt                       Default: 
Construct a set of representatives for the conjugacy classes of the matrix group G. The classes are returned as a sequence of triples containing the element order, the class length and a representative element for the class. The parameter Al enables the user to select the algorithm that is to be used.

Al := "Action": Create the classes of G by computing the orbits of the set of elements of G under the action of conjugation. This option is only feasible for small groups.

Al := "Random": Construct the conjugacy classes of elements for a matrix group G using an algorithm that searches for representatives of all conjugacy of G by examining a random selection of group elements and their powers. The behaviour of this algorithm is controlled by two associated optional parameters WeakLimit and StrongLimit, whose values are positive integers n1 and n2, say. Before describing the effect of these parameters, some definitions are needed: A mapping f: G -> I is called a class invariant if f(g) = f(gh) for all g, h∈G. In matrix groups, the primary invariant factors are used where possible, or the characteristic or minimal polynomials otherwise. Two matrices g and h are said to be weakly conjugate with respect to the class invariant f if f(g) = f(h). By definition, conjugacy implies weak conjugacy, but the converse is false. The random algorithm first examines n1 random elements and their powers, using a test for weak conjugacy. It then proceeds to examine a further n2 random elements and their powers, using a test for ordinary conjugacy. The idea behind this strategy is that the algorithm should attempt to find as many classes as possible using the very cheap test for weak conjugacy, before employing the more expensive ordinary conjugacy test to recognize the remaining classes.

Al := "Extend": Construct the conjugacy classes of G by first computing classes in a quotient G/N and then extending these classes to successively larger quotients G/H until the classes for G/1 are known. More precisely, a series of subgroups 1 = G0 < G1 < ... < Gr = R < G is computed such that R is the (solvable) radical of G and Gi + 1/Gi is elementary abelian. The radical quotient G/R is computed and its classes and centralizers of their representatives found using the permutation group algorithm, and pulled back to G. The parameters TFAl and ASAl control the algorithm used to compute the classes of G/R. See the GrpPerm chapter for more information on these parameters.

To extend from G/Gi + 1 to the next larger quotient G/Gi, an affine action of each centralizer on a quotient of the elementary abelian layer Gi + 1/Gi is computed. Each distinct orbit in that action gives rise to a new class of the larger quotient (see Mecky and Neubuser [MN89]).

Al := "Lifting": Construct a permutation representation for G, compute the classes of the representation, and lift them back to G through the kernel of the representation. Successful when the kernel is small. Currently uses the permutation action of G on its first basic orbit as the permutation representation.

Al := "Classic": Construct the conjugacy classes by enumeration of class invariants. This algorithm is only available for classical groups. It has only been implemented for groups containing the special linear group and for the conformal unitary group.

Default: The classic algorithm will be used if G is recognised to contain the special linear group (using IsLinearGroup), or if G is known to be conformal unitary group in the standard representation (that is, if G was constructed by ConformalUnitaryGroup). The action algorithm will be used if |G| ≤2000. If G is soluble then classes are computed in a PC-representation of G. When |G| > 2000 and the base ring of G is a finite field then the Extension algorithm is used. Otherwise the Lifting algorithm is used, unless the kernel size exceeds 10000. If there is a big kernel and the base ring of the group can be embedded in a field then the extension algorithm is used. Otherwise the random algorithm will be applied with the limits given by the parameters WeakLimit and StrongLimit. If that fails to compute all the classes and |G|≤100000, then the action algorithm will be used.

ClassRepresentative(G, x) : GrpMat, GrpMatElt -> GrpMatElt
Given a group G for which the conjugacy classes are known and an element x of G, return the designated representative for the conjugacy class of G containing x.
ClassCentraliser(G, i) : GrpMat, RngIntElt -> GrpMat
The centraliser of the representative element stored for conjugacy class number i in group G. The group computed is stored with the class table for reference by future calls to this function.
ClassInvariants(G, g) : GrpMat, GrpMatElt -> .
ClassInvariants(G, i) : GrpMat, RngIntElt -> .
The invariants for the conjugacy class of g in G or the conjugacy class number i in G. The type of invariants may vary depending on the group. This is only available for groups, for which the classic algorithm for computing conjugacy classes is available.
ClassRepresentativeFromInvariants(G, p, h, t) : GrpMat, SeqEnum, SeqEnum, FldFinElt -> GrpMatElt
Given a group G, for which the classic algorithm for computing conjugacy classes is available, and the class invariants p, h and t, return the standard class representative for the conjugacy class in G with the given invariants.
IsConjugate(G, g, h) : GrpMat, GrpMatElt, GrpMatElt -> BoolElt, GrpMatElt | Unass
Given a group G and elements g and h belonging to G, return the value true if g and h are conjugate in G. The function returns a second value in the event that the elements are conjugate: an element k which conjugates g into h.
IsConjugate(G, H, K) : GrpMat, GrpMat, GrpMat -> BoolElt, GrpMatElt | Unass
Given a group G and subgroups H and K belonging to G, return the value true if H and K are conjugate in G. The function returns a second value in the event that the subgroups are conjugate: an element z which conjugates H into K.
IsGLConjugate(H, K) : GrpMat, GrpMat -> BoolElt, GrpMatElt | Unass
Given H and K, both subgroups of the same general linear group G = GLn(q), return the value true if H and K are conjugate in G. The function returns a second value in the event that the subgroups are conjugate: an element z which conjugates H into K. The algorithm is described in Roney-Dougal [RD04].
Exponent(G) : GrpMat -> RngIntElt
The exponent of the group G.
NumberOfClasses(G) : GrpMat -> RngIntElt
Nclasses(G) : GrpMat -> RngIntElt
The number of conjugacy classes of elements for the group G.
PowerMap(G) : GrpMat -> Map
Given a group G, construct the power map for G. Suppose that the order of G is m and that G has r conjugacy classes. When the classes are determined by Magma, they are numbered from 1 to r. Let C be the set of class indices { 1, ..., r } and let P be the set of integers { 1, ..., m }. The power map f for G is the mapping, f : C x P -> C where the value of f(i, j) for i ∈C and j ∈P is the number of the class which contains xij, where xi is a representative of the i-th conjugacy class.
AssertAttribute(G, "Classes", Q) : GrpMat, MonStgElt, SeqEnum ->
Given a group G, and a sequence Q of k distinct elements of G, one from each conjugacy class, use Q to define the classes attribute of G. The sequence Q may be either a sequence of elements of G or, preferably, a sequence of pairs <GrpMatElt, RngIntElt> giving class representatives and their class length. In this latter case, no backtrack searches are performed.

Example GrpMatGen_RationalMatrixGroupDatabase (H59E12)

We take a group from the database of rational matrix groups and compute its conjugacy classes. The group has degree 12 and is written over the integers.

> DB := RationalMatrixGroupDatabase();
> G := Group(DB, 12, 3);
> FactoredOrder(G);
[ <2, 17>, <3, 8>, <5, 2> ]
> CompositionFactors(G);
    G
    |  Cyclic(2)
    *
    |  Cyclic(2)
    *
    |  C(2, 3)                = S(4, 3)
    *
    |  Cyclic(2)
    *
    |  Cyclic(2)
    *
    |  C(2, 3)                = S(4, 3)
    *
    |  Cyclic(2)
    1
The conjugacy classes of G are computed as follows:

> time cl := Classes(G);
Time: 18.580
> #cl;
1325
The group has 1325 conjugacy classes of elements.
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]

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