Two elements g and h of a group G are conjugate if h = x^-1 g x for some x in G. Conjugacy partitions G into disjoint conjugacy classes, and Magma provides a full toolkit for computing them, alongside a parallel toolkit for building and classifying subgroups.
Conjugacy Classes
Classes(G) (or its synonym ConjugacyClasses(G)) computes representatives for the conjugacy classes of G. The result is a sequence of triples <order, length, representative>, one per class. When Magma stores the classes it orders them first by increasing element order, then by increasing class length.
> M11 := sub<Sym(11) | (1,10)(2,8)(3,11)(5,7), (1,4,7,6)(2,11,10,9)>;
> Classes(M11);
Conjugacy Classes of group M11
------------------------------
[1] Order 1 Length 1
Rep Id(M11)
[2] Order 2 Length 165
Rep (3, 10)(4, 9)(5, 6)(8, 11)
[3] Order 3 Length 440
Rep (1, 2, 4)(3, 5, 10)(6, 8, 11)
...
By default Magma picks an algorithm automatically: for alternating/symmetric groups it reads classes off partitions of the degree, for soluble groups it switches to a pc-group representation, and otherwise it chooses between an orbit-based "Action" algorithm (small groups), a randomized "Random" search over group elements and their powers, and an "Extend" method that lifts classes through a chief series. The Al parameter selects the algorithm explicitly, and WeakLimit/StrongLimit tune how many random elements the random search examines before giving up.
> K := Classes(G : WeakLimit := 20, StrongLimit := 100);
> NumberOfClasses(G);
24
Class(H, x) and Conjugates(H, x) return the set of conjugates of an element x under a group H (the full conjugacy class of x in G if H = G). ClassRepresentative(G, x) and ClassRepresentative(G, i) fetch the stored representative for the class containing x, or for class number i. ClassMap(G) builds the map sending each element to the index of its class, and PowerMap(G) builds the map sending a class index and integer j to the class containing x_i^j for a representative x_i.
Testing Conjugacy
IsConjugate(G, g, h) decides whether elements g and h are conjugate in G, using Leon's backtrack search; if they are, it also returns an element k with g^k = h. IsConjugate(G, H, K) does the analogous test for two subgroups H and K, returning a conjugating element z with H^z = K if one exists. Both searches can be sped up by supplying known subgroups of the relevant centralizers or normalizers via the LeftSubgroup/RightSubgroup parameters.
> g := M11.1; h := M11.2;
> IsConjugate(M11, g, h);
false
Constructing Subgroups
The sub<G | L> constructor builds the subgroup of G generated by the items in the list L — permutations written as cycles, image sequences, elements, or other subgroups can all be mixed together.
> PGL27 := sub<Sym(8) | (1,2,3,4,5,6,7), (2,4,3,7,5,6), (1,8)(2,7)(3,4)(5,6)>;
> PGL27;
Permutation group PGL27 acting on a set of cardinality 8
(1, 2, 3, 4, 5, 6, 7)
(2, 4, 3, 7, 5, 6)
(1, 8)(2, 7)(3, 4)(5, 6)
ncl<G | L> builds the normal closure in G of the subgroup generated by L instead of the subgroup itself. This is a convenient way to get derived subgroups, since the derived subgroup is the normal closure of the commutators of the generators.
> H := PermutationGroup< 9 | (1,2,4)(5,6,8)(3,9,7), (4,5,6)(7,9,8) >;
> D := ncl< H | (H.1, H.2) >;
> D;
Permutation group D acting on a set of cardinality 9
Order = 72 = 2^3 * 3^2
Membership, Order, and Standard Subgroups
Standard operators test subgroup relationships: g in G, H subset G, H eq G and their negations notin, notsubset, ne. Index(G, H) gives the index of H in G (computing the orders of G and H first if needed), and FactoredIndex(G, H) gives it pre-factored. IsNormal(G, H), IsCentral(G, H), and IsSelfNormalising(G, H) test the corresponding structural properties.
Magma also builds standard derived subgroups directly: H^g or Conjugate(H, g) for the conjugate of H by g, H meet K for intersection (via backtrack search), Centralizer(G, g) and Centralizer(G, H) for centralizers of an element or a subgroup, Core(G, H) for the largest normal subgroup of G contained in H, Normalizer(G, H) for the normalizer, and H^G or NormalClosure(G, H) for the normal closure of H in G.
Maximal Subgroups and Subgroup Classes
MaximalSubgroups(G) returns the conjugacy classes of maximal subgroups of G, each as a record with fields subgroup, order, and length (class size). IsMaximal(G, H) tests whether a specific subgroup H is maximal, and the cheaper IsProbablyMaximal(G, H) gives a fast probabilistic answer by testing whether random elements adjoined to H generate all of G.
> max := MaximalSubgroups(G);
> #max;
46
More generally, Subgroups(G) (equivalently SubgroupClasses(G)) computes representatives for all conjugacy classes of subgroups of G, again as a sequence of records. Because this can be a huge collection, parameters like Al := "Maximal", Al := "Normal", OrderEqual, OrderDividing, IndexLimit, IsElementaryAbelian, and IsCyclic let you restrict the search to a manageable, targeted subset.
> se := SubgroupClasses(G : IsElementaryAbelian := true, OrderMultipleOf := 2);
> #se;
14