Group Theory - Maple Features - Maplesoft

Maple

Single User Licenses
Multi-User Licenses
Upgrade
What's New  |  Features  |  Online Demos  |  Compare  |  Training  |  Community  |  Free Trial  |  Buy Maple

Group Theory


Download a free trial of Maple

The Maple Group Theory package has over 150 commands for constructing groups, examining their properties, performing operations, and visualization. This package includes:

  • Large set of group constructors and databases of standard groups so it is easy to get started
  • Support for alternating and symmetric groups; cyclic, dicyclic, and dihedral groups; linear, orthogonal, and unitary groups over finite fields; quaternions; the group of the Rubik’s cube; Galois groups; and many more
  • Numerous operations, including isomorphism testing; examining subgroup lattices; splitting a group into conjugacy classes; factoring a group element into a coset representative and a subgroup element; computing if a group is simple, nilpotent, or soluble; identifying isomorphisms for groups up to order 200; computing standard subgroups, such as Sylow subgroups, the center, and the derived subgroup; and many more
  • Easy visualization of Cayley tables and subgroup lattices
  • Symbolic groups, in which some properties of the group are expressed as variable parameters while other characteristics are known

See for yourself what Maple can do!
Download a free 15-day trial of Maple today!
Start your free trial



Details and Examples



Permutations

Permutations are created by using the Perm constructor. Arithmetic with permutations is effected by non-commutative multiplication (.) and exponentiation (^), with a permutation understood as conjugation, or otherwise, a power.

> a := Perm([[1, 2]]); 1
 

Perm([[1, 2]])

> b := Perm([[1, 3, 5], [2, 4]])
 

Perm([[1, 3, 5], [2, 4]])

> PermProduct(a, b) = Typesetting:-delayDotProduct(a, b)
 

Perm([[1, 4, 2, 3, 5]]) = Perm([[1, 4, 2, 3, 5]])

> PermConjugate(a, b) = `^`(a, b)
 

Perm([[3, 4]]) = Perm([[3, 4]])

> PermInverse(a) = `/`(1, `*`(a))
 

Perm([[1, 2]]) = Perm([[1, 2]])

> PermCommutator(a, b) = Typesetting:-delayDotProduct(Typesetting:-delayDotProduct(Typesetting:-delayDotProduct(`/`(1, `*`(a)), `/`(1, `*`(b))), a), b)
 

Perm([[1, 2], [3, 4]]) = Perm([[1, 2], [3, 4]])




Permutation Groups

A focus for this release has been permutation groups: groups generated by a finite set of permutations on a finite set, which is taken to be the set {1,2,...,n}, for some positive integer n. In addition to abstract group-theoretic properties and computations applicable to any (finite) group, a selection of computations specific to permutation groups is included.

> G := Group(Perm([[1, 2], [3, 4]]), Perm([[1, 2, 3, 4]]))
 

GroupTheory:-PermutationGroup({thismodule, object}, )

> GroupOrder(G)
 

8

> IsTransitive(G)
 

true

> IsPrimitive(G)
 

false

> IsRegular(G)
 

false

> IsNilpotent(G)
 

true

> G := PSL(3, 3)
 

GroupTheory:-PSL(3, 3)

> GroupOrder(G)
 

5616

> Generators(G)
 

[Perm([[5, 8, 11], [6, 9, 12], [7, 10, 13]]), Perm([[1, 2, 5], [3, 8, 7], [4, 11, 6], [9, 10, 13]])]

> IsPrimitive(G)
 

true

> G := RubiksCubeGroup(); -1
 

> IsTransitive(G)
 

false

> O1 := Orbit(1, G)
 

GroupTheory:-Orbit(thismodule, object)
GroupTheory:-Orbit(thismodule, object)
GroupTheory:-Orbit(thismodule, object)
GroupTheory:-Orbit(thismodule, object)

> Elements(O1)
 

{1, 3, 6, 8, 9, 11, 14, 16, 17, 19, 22, 24, 25, 27, 30, 32, 33, 35, 38, 40, 41, 43, 46, 48}




CayleyTable Groups

A group may be defined by its Cayley table, the operation table of the group. Cayley tables are specified as integer arrays or matrices.

> ct := `<|>`(`<,>`(`<|>`(1, 2, 3), `<|>`(2, 3, 1), `<|>`(3, 1, 2)))
 

ct := Matrix(%id = 18446744078088537262)

> G := Group(ct)
 

GroupTheory:-CayleyTableGroup(Array(1..3, 1..3, {(1, 1) = 1, (1, 2) = 2, (1, 3) = 3, (2, 1) = 2, (2, 2) = 3, (2, 3) = 1, (3, 1) = 3, (3, 2) = 1, (3, 3) = 2}, datatype = integer[4], order = C_order))

> IsAbelian(G)
 

true



Finitely Presented Groups

You can define a group by specifying a set of generators and defining relations.

For example, here is a definition of the alternating group of degree 5:

> G := `<|>`(`<,>`(x, y), `<,>`(`*`(`^`(x, 2)) = 1, `*`(`^`(y, 3)) = 1, `*`(`^`(Typesetting:-delayDotProduct(x, y), 5)) = 1))
 

GroupTheory:-FPGroup([x, y], {[x, x], [y, y, y], [x, y, x, y, x, y, x, y, x, y]})

We can verify the order of the group directly.

> GroupOrder(G)
 

60

To check simplicity, we first convert the finitely presented group to a permutation group, and then use the IsSimple command.

> IsSimple(PermutationGroup(G))
 

true




Symbolic Groups

Symbolic groups are used to represent groups that depend on zero or more "parameters" (usually integers). They are used, for example, to represent some of the larger sporadic finite simple groups (such as the Monster and the Harada-Norton simple group) that are too large to support practical computation with group elements. Additionally, some constructors can take symbolic expressions for parameters and return a symbolic representation of the constructed group.

> Monster()
 

GroupTheory:-Monster()

> GroupOrder(Monster())
 

808017424794512875886459904961710757005754368000000000

> IsSimple(Monster())
 

true

> G := GeneralLinearGroup(3, q)
 

GroupTheory:-GL(3, q)

> GroupOrder(G)
 

`*`(`+`(`*`(`^`(q, 3)), `-`(1)), `*`(`+`(`*`(`^`(q, 3)), `-`(q)), `*`(`+`(`*`(`^`(q, 3)), `-`(`*`(`^`(q, 2)))))))

> `assuming`([IsSimple(Alt(n))], [`<`(5, n)])
 

true




Group Constructors

Many groups can be created directly and conveniently by using purpose-built constructors provided by the GroupTheory package:

> Symm(4)
 

GroupTheory:-SymmetricGroup(4)

> Alt(6)
 

GroupTheory:-AlternatingGroup(6)

> DihedralGroup(14)
 

GroupTheory:-DihedralGroup(14, form =

> PSL(3, 4)
 

GroupTheory:-PSL(3, 4)

> GL(2, 2)
 

GroupTheory:-GL(2, 2)




Visualizations

It is useful to be able to visualize a group by examining its subgroup lattice graphically:

> DrawSubgroupLattice(QuaternionGroup())
 

Plot_2d

> G := SmallGroup(24, 7); -1
 

> DrawSubgroupLattice(G, derived, labels = none)
 

Plot_2d

> DrawCayleyTable(Symm(3))
 

Plot_2d




Group Properties

Support for testing a variety of group properties is included in the GroupTheory package.

> G := Symm(3)
 

GroupTheory:-SymmetricGroup(3)

> IsAbelian(G)
 

false

> IsNilpotent(G)
 

false

> IsSoluble(G)
 

true

> IsSimple(G)
 

false




Interesting Subgroups

A number of standard subgroups can be constructed with the GroupTheory package.

> G := DihedralGroup(8)
 

GroupTheory:-DihedralGroup(8, form =

> Z := Centre(G)
 

GroupTheory:-Centre(thismodule)

> GroupOrder(Z)
 

2

> C := DerivedSubgroup(G)
 

GroupTheory:-DerivedSubgroup(thismodule)

> GroupOrder(C)
 

4

> P := PCore(2, MetacyclicGroup(3, 2, 2))
 

GroupTheory:-PCore(2, thismodule)

> LowerCentralSeries(P)
 

GroupTheory:-LowerCentralSeries(thismodule)

> R := SolubleResidual(Symm(6))
 

GroupTheory:-PermutationGroup({thismodule, object, , , }, , )

> IsPerfect(R)
 

true




Isomorphism Testing and Group Identification

The GroupTheory package includes an isomorphism test for finite groups given by their Cayley tables. Operation of the command is extended to other finite groups by computing their Cayley tables, which is done automatically. The package also includes a database o fall the finite groups up to order 200. Together, this allows any finite group with at most 200 elements to be identified unambiguously in a standard way.

We can verify the commutativity, up to isomorphism, of the direct product construction by using the AreIsomorphic command.

> G := DirectProduct(Alt(4), DihedralGroup(6))
 

GroupTheory:-DirectProduct(thismodule, object)

> H := DirectProduct(DihedralGroup(6), Alt(4))
 

GroupTheory:-DirectProduct(thismodule, object)

> AreIsomorphic(G, H)
 

true

> IdentifySmallGroup(G)
 

144, 190

Ready for the next step?
Download a free trial of Maple today.



How to Buy/Licensing Options:
Single User Licenses
Multi-User Licenses
Upgrade to Maple 2024