Group libraries

Transitive permutation groups of small degree

The functions in this section are wrappers for the GAP library of transitive permutation groups up to degree 48, via the GAP package TransGrp [Hul23].

(The groups of degrees 32 and 48 are currently not automatically available in Oscar, one has to install additional data in order to access them.)

The arrangement and the names of the groups of degree up to 15 is the same as given in [CHM98]. 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_groups — Function

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

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

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

The following functions are currently supported as values for func:

degree
is_abelian
is_almost_simple
is_cyclic
is_nilpotent
is_perfect
is_primitive
is_quasisimple
is_simple
is_sporadic_simple
is_solvable
is_supersolvable
is_transitive
number_of_conjugacy_classes
number_of_moved_points
order
transitivity

The type of the returned groups is PermGroup.

Examples

julia> all_transitive_groups(4)
5-element Vector{PermGroup}:
 Permutation group of degree 4
 Permutation group of degree 4
 Permutation group of degree 4
 Alt(4)
 Sym(4)

julia> all_transitive_groups(degree => 3:5, is_abelian)
4-element Vector{PermGroup}:
 Alt(3)
 Permutation group of degree 4
 Permutation group of degree 4
 Permutation group of degree 5

has_number_of_transitive_groups — Function

has_number_of_transitive_groups(deg::Int)

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

Examples

julia> has_number_of_transitive_groups(30)
true

julia> has_number_of_transitive_groups(64)
false

has_transitive_group_identification — Function

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

has_transitive_groups — Function

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

number_of_transitive_groups — Function

number_of_transitive_groups(deg::Int)

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

Examples

julia> number_of_transitive_groups(30)
5712

julia> number_of_transitive_groups(64)
ERROR: ArgumentError: the number of transitive groups of degree 64 is not available

transitive_group — Function

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)
Alt(5)

julia> transitive_group(5,6)
ERROR: ArgumentError: there are only 5 transitive groups of degree 5, not 6

transitive_group_identification — Function

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]
Permutation group of degree 7

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: ArgumentError: 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: ArgumentError: group is not transitive on its moved points

Primitive permutation groups of small degree

The functions in this section are wrappers for the GAP library of primitive permutation groups up to degree 8191, via the GAP package PrimGrp [HRR23]. See the documentation of this package for more information about the source of the data.

all_primitive_groups — Function

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

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

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

The following functions are currently supported as values for func:

degree
is_abelian
is_almost_simple
is_cyclic
is_nilpotent
is_perfect
is_primitive
is_quasisimple
is_simple
is_sporadic_simple
is_solvable
is_supersolvable
is_transitive
number_of_conjugacy_classes
number_of_moved_points
order
transitivity

The type of the returned groups is PermGroup.

Examples

julia> all_primitive_groups(4)
2-element Vector{PermGroup}:
 Alt(4)
 Sym(4)

julia> all_primitive_groups(degree => 3:5, is_abelian)
2-element Vector{PermGroup}:
 Alt(3)
 Permutation group of degree 5 and order 5

has_number_of_primitive_groups — Function

has_number_of_primitive_groups(deg::Int)

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

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

Examples

julia> has_number_of_primitive_groups(50)
true

julia> has_number_of_primitive_groups(5000)
false

has_primitive_group_identification — Function

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

has_primitive_groups — Function

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

number_of_primitive_groups — Function

number_of_primitive_groups(deg::Int)

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

Examples

julia> number_of_primitive_groups(10)
9

julia> number_of_primitive_groups(4096)
ERROR: ArgumentError: the number of primitive permutation groups of degree 4096 is not available

primitive_group — Function

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)
Permutation group of degree 10 and order 60

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

primitive_group_identification — Function

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]
Permutation group of degree 7 and order 720

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: ArgumentError: 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: ArgumentError: group is not primitive on its moved points

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 [HP89]. For orders 86016, 368640, or 737280 this work only counted the groups (but did not explicitly list them), the groups of orders 61440, 122880, 172032, 245760, 344064, 491520, 688128, or 983040 were omitted.

Several additional groups omitted from the book [HP89] 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 in 2005 by Jack Schmidt. 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, see [Hul22]. 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.

all_perfect_groups — Function

all_perfect_groups(L...)

Return the list of all perfect 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

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

The following functions are currently supported as values for func:

is_quasisimple
is_simple
is_sporadic_simple
number_of_conjugacy_classes
order

The type of the returned groups is PermGroup.

Examples

julia> all_perfect_groups(7200)
2-element Vector{PermGroup}:
 Permutation group of degree 29 and order 7200
 Permutation group of degree 288 and order 7200

julia> all_perfect_groups(order => 1:200, !is_simple)
2-element Vector{PermGroup}:
 Permutation group of degree 1 and order 1
 Permutation group of degree 24 and order 120

has_number_of_perfect_groups — Function

has_number_of_perfect_groups(n::Int)

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

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

Examples

julia> has_number_of_perfect_groups(7200)
true

julia> has_number_of_perfect_groups(2*10^6+1)
false

has_perfect_group_identification — Function

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

has_perfect_groups — Function

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

number_of_perfect_groups — Function

number_of_perfect_groups(n::IntegerUnion)

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

Examples

julia> number_of_perfect_groups(60)
1

julia> number_of_perfect_groups(1966080)
7344

orders_perfect_groups — Function

orders_perfect_groups()

Return 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

perfect_group — Function

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)
Permutation group of degree 5 and order 60

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

julia> perfect_group(FPGroup, 60, 1)
Finitely presented group of order 60

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

perfect_group_identification — Function

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)

Groups of small order

The functions in this section are wrappers for the GAP library of the following groups.

The GAP package SmallGrp [BEO23] provides

those of order at most 2000 (except those of order 1024),
those of cubefree order at most 50000,
those of order $p^7$ for the primes $p = 3, 5, 7, 11$,
those of order $p^n$ for $n \leq 6$ and all primes $p$,
those of order $q^n p$ where $q^n$ divides $2^8$, $3^6$, $5^5$ or $7^4$ and $p$ is an arbitrary prime not equal to $q$,
those of squarefree order,
those whose order factorises into at most 3 primes.

The GAP package SOTGrps [Pan23] provides

those whose order factorises into at most 4 primes,
those of order $p^4 q$ where $p$ and $q$ are distinct primes.

The GAP package SglPPow [VE22] provides

those of order $p^7$ for primes $p > 11$,
those of order $3^8$.

all_small_groups — Function

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:

exponent
is_abelian
is_almost_simple
is_cyclic
is_nilpotent
is_perfect
is_quasisimple
is_simple
is_sporadic_simple
is_solvable
is_supersolvable
number_of_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 order 12

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 order 6
 Pc group of order 8
 Pc group of order 8
 Pc group of order 10

has_number_of_small_groups — Function

has_number_of_small_groups(n::IntegerUnion)

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

Examples

julia> has_number_of_small_groups(1024)
true

julia> has_number_of_small_groups(2048)
false

has_small_group_identification — Function

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

has_small_groups — Function

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

number_of_small_groups — Function

number_of_small_groups(n::IntegerUnion)

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

Examples

julia> number_of_small_groups(8)
5

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

julia> number_of_small_groups(next_prime(ZZRingElem(2)^64))
1

small_group — Function

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 order 60

julia> small_group(60, 5)
Permutation group of degree 5 and order 60

julia> small_group(PcGroup, 60, 4)
Pc group of order 60

small_group_identification — Function

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: ArgumentError: identification is not available for groups of order 2432902008176640000

Atlas of Group Representations

The functions in this section give access to data in the Atlas of Group Representations [ATLAS]. 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_of_atlas_groups — Function

number_of_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_of_atlas_groups("A5")
18

julia> number_of_atlas_groups(PermGroup, "A5")
3

julia> number_of_atlas_groups(MatrixGroup, "A5")
15

all_atlas_group_infos — Function

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(:constituents => [1, 4], :repname => "A5G1-p5B0", :degree => 5, :name => "A5")
 Dict(:constituents => [1, 5], :repname => "A5G1-p6B0", :degree => 6, :name => "A5")

julia> atlas_group(info[1])
Permutation group of degree 5 and order 60

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

julia> atlas_group(info[1])
Matrix group of degree 4
  over prime field of characteristic 3

atlas_group — Function

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
Permutation group of degree 5 and order 60

julia> atlas_group(MatrixGroup, "A5")
Matrix group of degree 4
  over prime field of characteristic 2

julia> atlas_group("M11")  # Mathieu group M11
Permutation group of degree 11 and order 7920

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

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(:constituents => [1, 4], :repname => "A5G1-p5B0", :degree => 5, :name => "A5")

julia> atlas_group(info[1])
Permutation group of degree 5 and order 60

atlas_subgroup — Function

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
Permutation group of degree 11 and order 720

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

julia> h2, emb = atlas_subgroup("M11", 1);  h2
Permutation group of degree 11 and order 720

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

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

julia> h4, emb = atlas_subgroup(info[1], 1);  h4
Permutation group of degree 11 and order 720