Group libraries

Transitive permutation groups of small degree

TODO: explain about the scope of this.

TODO: give proper attribution to the transgrp package (in particular, cite it)

The arrangement and the names of the groups of degree up to 15 is the same as given in John H. Conway, Alexander Hulpke, John McKay (1998). With the exception of the symmetric and alternating group (which are represented as symmetric_group and alternating_group) the generators for these groups also conform to this paper with the only difference that 0 (which is not permitted in GAP for permutations to act on) is always replaced by the degree.

The arrangement for all degrees is intended to be equal to the arrangement within the systems GAP and Magma, thus it should be safe to refer to particular (classes of) groups by their index numbers.

all_transitive_groupsFunction
all_transitive_groups(L...)

Return the list of all transitive groups (up to permutation isomorphism) satisfying the conditions described by the arguments. These conditions may be of one of the following forms:

• func => intval selects groups for which the function func returns intval
• func => list selects groups for which the function func returns any element inside list
• func selects groups for which the function func returns true
• !func selects groups for which the function func returns false

The following functions are currently supported as values for func:

• degree
• is_abelian
• is_almostsimple
• is_cyclic
• is_nilpotent
• is_perfect
• is_primitive
• is_quasisimple
• is_simple
• is_sporadic_simple
• is_solvable
• is_supersolvable
• is_transitive
• number_conjugacy_classes
• number_moved_points
• order
• transitivity

The type of the returned groups is PermGroup.

Examples

julia> all_transitive_groups(degree => 3:5, is_abelian)
4-element Vector{PermGroup}:
A3
C(4) = 4
E(4) = 2[x]2
C(5) = 5

returns the list of all abelian transitive groups acting on 3, 4 or 5 points.

source
has_number_transitive_groupsFunction
has_number_transitive_groups(deg::Int)

Return whether the number transitive groups groups of degree deg are available for use via number_transitive_groups.

Examples

julia> has_number_transitive_groups(30)
true

julia> has_number_transitive_groups(64)
false
source
has_transitive_group_identificationFunction
has_transitive_group_identification(deg::Int)

Return whether identification of transitive groups groups of degree deg is available via transitive_group_identification.

Examples

julia> has_transitive_group_identification(30)
true

julia> has_transitive_group_identification(64)
false
source
has_transitive_groupsFunction
has_transitive_groups(deg::Int)

Return whether the transitive groups groups of degree deg are available for use. This function should be used to test for the scope of the library available.

Examples

julia> has_transitive_groups(30)
true

julia> has_transitive_groups(64)
false
source
number_transitive_groupsFunction
number_transitive_groups(deg::Int)

Return the number of transitive groups of degree deg, up to permutation isomorphism.

Examples

julia> number_transitive_groups(30)
5712

julia> number_transitive_groups(64)
ERROR: ArgumentError: the number of transitive groups of degree 64 is not available
source
transitive_groupFunction
transitive_group(deg::Int, i::Int)

Return the i-th group in the catalogue of transitive groups over the set {1, ..., deg} in GAP's Transitive Groups Library. The output is a group of type PermGroup.

Examples

julia> transitive_group(5,4)
A5

julia> transitive_group(5,6)
ERROR: ArgumentError: there are only 5 transitive groups of degree 5, not 6
source
transitive_group_identificationFunction
transitive_group_identification(G::PermGroup)

Return a pair (d,n) such that G is permutation isomorphic with transitive_group(d,n), where G acts transitively on d points.

If G is not transitive on its moved points, or if the transitive groups of degree d are not available, an exception is thrown.

Examples

julia> G = symmetric_group(7);  m = transitive_group_identification(G)
(7, 7)

julia> order(transitive_group(m...)) == order(G)
true

julia> S = sub(G, [perm([1, 3, 4, 5, 2])])[1]
Group([ (2,3,4,5) ])

julia> is_transitive(S)
false

julia> is_transitive(S, moved_points(S))
true

julia> m = transitive_group_identification(S)
(4, 1)

julia> order(transitive_group(m...)) == order(S)
true

julia> transitive_group_identification(symmetric_group(64))
ERROR: identification of transitive groups of degree 64 are not available

julia> S = sub(G, [perm([1,3,4,5,2,7,6])])[1];

julia> transitive_group_identification(S)
ERROR: group is not transitive on its moved points
source

Primitive permutation groups of small degree

TODO: explain about the scope of this.

TODO: give proper attribution to the primitive groups library (in particular, cite it)

all_primitive_groupsFunction
all_primitive_groups(L...)

Return the list of all primitive permutation groups (up to permutation isomorphism) satisfying the conditions described by the arguments. These conditions may be of one of the following forms:

• func => intval selects groups for which the function func returns intval
• func => list selects groups for which the function func returns any element inside list
• func selects groups for which the function func returns true
• !func selects groups for which the function func returns false

The following functions are currently supported as values for func:

• degree
• is_abelian
• is_almostsimple
• is_cyclic
• is_nilpotent
• is_perfect
• is_primitive
• is_quasisimple
• is_simple
• is_sporadic_simple
• is_solvable
• is_supersolvable
• is_transitive
• number_conjugacy_classes
• number_moved_points
• order
• transitivity

The type of the returned groups is PermGroup.

Examples

julia> all_primitive_groups(degree => 3:5, is_abelian)
2-element Vector{PermGroup}:
A(3)
C(5)

returns the list of all abelian primitive permutation groups acting on 3, 4 or 5 points.

source
has_number_primitive_groupsFunction
has_number_primitive_groups(deg::Int)

Return true if the number of primitive permutation groups of degree deg is available via number_primitive_groups, otherwise false.

Currently the number of primitive permutation groups is available up to degree 4095.

Examples

julia> has_number_primitive_groups(50)
true

julia> has_number_primitive_groups(5000)
false
source
has_primitive_group_identificationFunction
has_primitive_group_identification(deg::Int)

Return true if identification is supported for the primitive permutation groups of degree deg via primitive_group_identification, otherwise false.

Currently identification is available for all primitive permutation groups up to degree 4095.

Examples

julia> has_primitive_group_identification(50)
true

julia> has_primitive_group_identification(5000)
false
source
has_primitive_groupsFunction
has_primitive_groups(deg::Int)

Return true if the primitive permutation groups of degree deg are available via primitive_group and all_primitive_groups, otherwise false.

Currently all primitive permutation groups up to degree 4095 are available.

Examples

julia> has_primitive_groups(50)
true

julia> has_primitive_groups(5000)
false
source
number_primitive_groupsFunction
number_primitive_groups(deg::Int)

Return the number of primitive permutation groups of degree deg, up to permutation isomorphism.

Examples

julia> number_primitive_groups(10)
9

julia> number_primitive_groups(4096)
ERROR: ArgumentError: the number of primitive permutation groups of degree 4096 is not available
source
primitive_groupFunction
primitive_group(deg::Int, i::Int)

Return the i-th group in the catalogue of primitive permutation groups over the set {1, ..., deg} in GAP's library of primitive permutation groups. The output is a group of type PermGroup.

Examples

julia> primitive_group(10,1)
A(5)

julia> primitive_group(10,10)
ERROR: ArgumentError: there are only 9 primitive permutation groups of degree 10, not 10
source
primitive_group_identificationFunction
primitive_group_identification(G::PermGroup)

Return a pair (d,n) such that G is permutation isomorphic with primitive_group(d,n), where G acts primitively on d points.

If G is not primitive on its moved points, or if the primitive permutation groups of degree d are not available, an exception is thrown.

Examples

julia> G = symmetric_group(7);  m = primitive_group_identification(G)
(7, 7)

julia> order(primitive_group(m...)) == order(G)
true

julia> S = stabilizer(G, 1)[1]
Group([ (2,7,6,5,4,3), (6,7) ])

julia> is_primitive(S)
false

julia> is_primitive(S, moved_points(S))
true

julia> m = primitive_group_identification(S)
(6, 4)

julia> order(primitive_group(m...)) == order(S)
true

julia> primitive_group_identification(symmetric_group(4096))
ERROR: identification of primitive permutation groups of degree 4096 is not available

julia> S = sub(G, [perm([1,3,4,5,2,7,6])])[1];

julia> primitive_group_identification(S)
ERROR: group is not primitive on its moved points
source

Perfect groups of small order

The functions in this section are wrappers for the GAP library of finite perfect groups which provides, up to isomorphism, a list of all perfect groups whose sizes are less than $2\cdot 10^6$. The groups of most orders up to $10^6$ have been enumerated by Derek Holt and Wilhelm Plesken, see Derek F. Holt, W. Plesken (1989). For orders $n = 86016$, 368640, or 737280 this work only counted the groups (but did not explicitly list them), the groups of orders $n = 61440$, 122880, 172032, 245760, 344064, 491520, 688128, or 983040 were omitted.

Several additional groups omitted from the book Derek F. Holt, W. Plesken (1989) have also been included. Two groups – one of order 450000 with a factor group of type $A_6$ and the one of order 962280 – were found by Jack Schmidt in

1. Two groups of order 243000 and one each of orders 729000, 871200, 878460

were found in 2020 by Alexander Hulpke.

The perfect groups of size less than $2\cdot 10^6$ which had not been classified in the work of Holt and Plesken have been enumerated by Alexander Hulpke. They are stored directly and provide less construction information in their names.

As all groups are stored by presentations, a permutation representation is obtained by coset enumeration. Note that some of the library groups do not have a faithful permutation representation of small degree. Computations in these groups may be rather time consuming.

has_number_perfect_groupsFunction
has_number_perfect_groups(n::Int)

Return true if the number of perfect groups of order n are available via number_perfect_groups, otherwise false.

Currently the number of perfect groups is available up to order $2 \cdot 10^6$.

Examples

julia> has_number_perfect_groups(7200)
true

julia> has_number_perfect_groups(2*10^6+1)
false
source
has_perfect_group_identificationFunction
has_perfect_group_identification(n::Int)

Return true if identification is supported for the perfect groups of order n via perfect_group_identification, otherwise false.

Currently identification is available for all perfect groups up to order $2 \cdot 10^6$.

Examples

julia> has_perfect_group_identification(7200)
true

julia> has_perfect_group_identification(2*10^6+1)
false
source
has_perfect_groupsFunction
has_perfect_groups(deg::Int)

Return true if the perfect groups of order n are available via perfect_group and all_perfect_groups, otherwise false.

Currently all perfect groups up to order $2 \cdot 10^6$ are available.

Examples

julia> has_perfect_groups(7200)
true

julia> has_perfect_groups(2*10^6+1)
false
source
number_perfect_groupsFunction
number_perfect_groups(n::IntegerUnion)

Return the number of perfect groups of order n, up to isomorphism.

Examples

julia> number_perfect_groups(60)
1

julia> number_perfect_groups(1966080)
7344
source
orders_perfect_groupsFunction
orders_perfect_groups()

Returns a sorted vector of all numbers to $2 \cdot 10^6$ that occur as orders of perfect groups.

Examples

julia> orders_perfect_groups()[1:10]
10-element Vector{Int64}:
1
60
120
168
336
360
504
660
720
960
source
perfect_groupFunction
perfect_group(::Type{T} = PermGroup, n::IntegerUnion, k::IntegerUnion)

Return the k-th group of order n and type T in the catalogue of perfect groups in GAP's Perfect Groups Library. The type T can be either PermGroup or FPGroup.

Examples

julia> perfect_group(60, 1)
A5

julia> gens(ans)
2-element Vector{PermGroupElem}:
(1,2)(4,5)
(2,3,4)

julia> perfect_group(FPGroup, 60, 1)
A5

julia> gens(ans)
2-element Vector{FPGroupElem}:
a
b

julia> perfect_group(60, 2)
ERROR: ArgumentError: there are only 1 perfect groups of order 60
source
perfect_group_identificationFunction
perfect_group_identification(G::GAPGroup)

Return (n, m) such that G is isomorphic with perfect_group(n, m). If G is not perfect, an exception is thrown.

Examples

julia> perfect_group_identification(alternating_group(5))
(60, 1)

julia> perfect_group_identification(SL(2,7))
(336, 1)
source

Groups of small order

TODO: explain about the scope of this.

TODO: give proper attribution to the smallgrp package and other things used (in particular, cite it)

all_small_groupsFunction
all_small_groups(L...)

Return the list of all groups (up to isomorphism) satisfying the conditions described by the arguments. These conditions may be of one of the following forms:

• func => intval selects groups for which the function func returns intval
• func => list selects groups for which the function func returns any element inside list
• func selects groups for which the function func returns true
• !func selects groups for which the function func returns false

As a special case, the first argument may also be one of the following:

• intval selects groups whose order equals intval; this is equivalent to order => intval
• intlist selects groups whose order is in intlist; this is equivalent to order => intlist

Note that at least one of the conditions must impose a limit on the group order, otherwise an exception is thrown.

The following functions are currently supported as values for func:

• is_abelian
• is_almostsimple
• is_cyclic
• is_nilpotent
• is_perfect
• is_quasisimple
• is_simple
• is_sporadic_simple
• is_solvable
• is_supersolvable
• number_conjugacy_classes
• order

The type of the returned groups is PcGroup if the group is solvable, PermGroup otherwise.

Examples

List all abelian non-cyclic groups of order 12:

julia> all_small_groups(12, !is_cyclic, is_abelian)
1-element Vector{PcGroup}:
<pc group of size 12 with 3 generators>

List groups of order 1 to 10 which are not abelian:

julia> all_small_groups(1:10, !is_abelian)
4-element Vector{PcGroup}:
<pc group of size 6 with 2 generators>
<pc group of size 8 with 3 generators>
<pc group of size 8 with 3 generators>
<pc group of size 10 with 2 generators>
source
has_number_small_groupsFunction
has_number_small_groups(n::IntegerUnion)

Return true if the number of groups of order n is known, otherwise false.

Examples

julia> has_number_small_groups(1024)
true

julia> has_number_small_groups(2048)
false
source
has_small_group_identificationFunction
has_small_group_identification(n::IntegerUnion)

Return true if identification for groups of order n is available via small_group_identification, otherwise false.

Examples

julia> has_small_group_identification(256)
true

julia> has_small_group_identification(512)
false
source
has_small_groupsFunction
has_small_groups(n::IntegerUnion)

Return true if the groups of order n are available via small_group and all_small_groups, otherwise false.

Examples

julia> has_small_groups(512)
true

julia> has_small_groups(1024)
false
source
number_small_groupsFunction
number_small_groups(n::IntegerUnion)

Return the number of groups of order n, up to isomorphism.

Examples

julia> number_small_groups(8)
5

julia> number_small_groups(4096)
ERROR: the number of groups of order 4096 is not available

julia> number_small_groups(next_prime(ZZRingElem(2)^64))
1
source
small_groupFunction
small_group(::Type{T}, n::IntegerUnion, i::IntegerUnion) where T
small_group(n::IntegerUnion, i::IntegerUnion)

Return the i-th group of order n in the Small Groups Library. If a type T is specified then an attempt is made to return the result with that type. If T is omitted then the resulting group will have type PcGroup if it is solvable, otherwise it will be of type PermGroup.

Examples

julia> small_group(60, 4)
<pc group of size 60 with 4 generators>

julia> small_group(60, 5)
Group([ (1,2,3,4,5), (1,2,3) ])

julia> small_group(PcGroup, 60, 4)
<pc group of size 60 with 4 generators>
source
small_group_identificationFunction
small_group_identification(G::Group)

Return a pair of integer (n, m), where G is isomorphic with small_group(n, m).

Examples

julia> small_group_identification(alternating_group(5))
(60, 5)

julia> small_group_identification(symmetric_group(20))
ERROR: identification is not available for groups of order 2432902008176640000
source

Atlas of Group Representations

The functions in this section give access to data in the Atlas of Group Representations R. A. Wilson, P. Walsh, J. Tripp, I. Suleiman, R. A. Parker, S. P. Norton, S. Nickerson, S. Linton, J. Bray, R. Abbott (). The isomorphism types of the groups in question are specified via names for the groups, which coincide with the names of the corresponding character tables in the library of character tables, see character_table(id::String, p::Int = 0).

number_atlas_groupsFunction
number_atlas_groups([::Type{T}, ]name::String) where T <: Union{PermGroup, MatrixGroup}

Return the number of groups from the Atlas of Group Representations whose isomorphism type is given by name and have the type T.

Examples

julia> number_atlas_groups("A5")
18

julia> number_atlas_groups(PermGroup, "A5")
3

julia> number_atlas_groups(MatrixGroup, "A5")
15

source
all_atlas_group_infosFunction
all_atlas_group_infos(name::String, L...)

Return the vector of dictionaries that describe Atlas groups whose isomorphism types are given by name and which satisfy the conditions in L. These conditions may be of one of the following forms:

• func => intval selects groups for which the function func returns intval
• func => list selects groups for which the function func returns any element inside list
• func selects groups for which the function func returns true
• !func selects groups for which the function func returns false

The following functions are currently supported as values for func:

For permutation groups

• degree
• is_primitive
• is_transitive
• rank_action
• transitivity

and for matrix groups

• base_ring
• character
• characteristic
• dim

Examples

julia> info = all_atlas_group_infos("A5", degree => [5, 6])
2-element Vector{Dict{Symbol, Any}}:
Dict(:repname => "A5G1-p5B0", :degree => 5, :name => "A5")
Dict(:repname => "A5G1-p6B0", :degree => 6, :name => "A5")

julia> atlas_group(info[1])
Group([ (1,2)(3,4), (1,3,5) ])

julia> info = all_atlas_group_infos("A5", dim => 4, characteristic => 3)
1-element Vector{Dict{Symbol, Any}}:
Dict(:dim => 4, :repname => "A5G1-f3r4B0", :name => "A5")

julia> atlas_group(info[1])
Matrix group of degree 4 over Finite field of degree 1 over F_3

source
atlas_groupFunction
atlas_group([::Type{T}, ]name::String) where T <: Union{PermGroup, MatrixGroup}

Return a group from the Atlas of Group Representations whose isomorphism type is given by name and have the type T. If T is not given then PermGroup is chosen if a permutation group for name is available, and MatrixGroup otherwise.

Examples

julia> atlas_group("A5")  # alternating group A5
Group([ (1,2)(3,4), (1,3,5) ])

julia> atlas_group(MatrixGroup, "A5")
Matrix group of degree 4 over Finite field of degree 1 over F_2

julia> atlas_group("M11")  # Mathieu group M11
Group([ (2,10)(4,11)(5,7)(8,9), (1,4,3,8)(2,5,6,9) ])

julia> atlas_group("M")  # Monster group M
ERROR: the group atlas does not provide a representation for M
source
atlas_group(info::Dict)

Return the group from the Atlas of Group Representations that is defined by info. Typically, info is obtained from all_atlas_group_infos.

Examples

julia> info = all_atlas_group_infos("A5", degree => 5)
1-element Vector{Dict{Symbol, Any}}:
Dict(:repname => "A5G1-p5B0", :degree => 5, :name => "A5")

julia> atlas_group(info[1])
Group([ (1,2)(3,4), (1,3,5) ])

source
atlas_subgroupFunction
atlas_subgroup(G::GAPGroup, nr::Int)
atlas_subgroup([::Type{T}, ]name::String, nr::Int) where T <: Union{PermGroup, MatrixGroup}
atlas_subgroup(info::Dict, nr::Int)

Return a pair (H, emb) where H is a representative of the nr-th class of maximal subgroups of the group G, and emb is an embedding of H into G.

The group G can be given as the first argument, in this case it is assumed that G has been created with atlas_group. Otherwise G is the group obtained by calling atlas_group with (T and) name or with info.

If the Atlas of Group Representations does not provide the information to compute G or to compute generators of H from G then an exception is thrown.

Examples

julia> g = atlas_group("M11");  # Mathieu group M11

julia> h1, emb = atlas_subgroup(g, 1);  h1
Group([ (1,4)(2,10)(3,7)(6,9), (1,6,10,7,11,3,9,2)(4,5) ])

julia> order(h1)  # largest maximal subgroup of M11
720

julia> h2, emb = atlas_subgroup("M11", 1);  h2
Group([ (1,4)(2,10)(3,7)(6,9), (1,6,10,7,11,3,9,2)(4,5) ])

julia> h3, emb = atlas_subgroup(MatrixGroup, "M11", 1 );  h3
Matrix group of degree 10 over Finite field of degree 1 over F_2

julia> info = all_atlas_group_infos("M11", degree => 11);

julia> h4, emb = atlas_subgroup(info[1], 1);  h4
Group([ (1,4)(2,10)(3,7)(6,9), (1,6,10,7,11,3,9,2)(4,5) ])
source