GitHub

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
 Alternating group of degree 4
 Symmetric group of degree 4

julia> all_transitive_groups(degree => 3:5, is_abelian)
4-element Vector{PermGroup}:
 Alternating group of degree 3
 Permutation group of degree 4
 Permutation group of degree 4
 Permutation group of degree 5
source
has_number_of_transitive_groups — Function
has_number_of_transitive_groups(deg::Int)

Return whether the number of transitive groups of degree deg is 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
source
has_transitive_group_identification — Function
has_transitive_group_identification(deg::Int)

Return whether identification of transitive 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_groups — Function
has_transitive_groups(deg::Int)

Return whether the transitive 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_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
[...]
source
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)
Alternating group of degree 5

julia> transitive_group(5,6)
ERROR: ArgumentError: there are only 5 transitive groups of degree 5, not 6
[...]
source
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
[...]
source

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}:
 Alternating group of degree 4
 Symmetric group of degree 4

julia> all_primitive_groups(degree => 3:5, is_abelian)
2-element Vector{PermGroup}:
 Alternating group of degree 3
 Permutation group of degree 5 and order 5
source
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
source
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
source
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
source
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
[...]
source
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
[...]
source
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
[...]
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 [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
source
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
source
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
source
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
source
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
source
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
source
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
[...]
source
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)
source

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
source
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
source
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
source
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
source
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
source
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
source
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
[...]
source

Groups with a small number of conjugacy classes

The functions in this section give access to the groups with up to 14 conjugacy classes. These groups have been classified in [V-LV-L85], [V-LV-L86], [VS07].

all_groups_with_class_number — Function
all_groups_with_class_number(n::IntegerUnion)

Return a vector of all groups (up to isomorphism) with exactly n conjugacy classes.

Examples

julia> map(describe, all_groups_with_class_number(4))
4-element Vector{String}:
 "C4"
 "C2 x C2"
 "D10"
 "A4"
source
number_of_groups_with_class_number — Function
number_of_groups_with_class_number(n::IntegerUnion)

Return the number of groups with exactly n conjugacy classes, up to isomorphism.

Examples

julia> number_of_groups_with_class_number(8)
21

julia> number_of_groups_with_class_number(50)
ERROR: ArgumentError: the number of groups with 50 classes is not available
[...]
source
group_with_class_number — Function
group_with_class_number(::Type{T}, n::IntegerUnion, i::IntegerUnion) where T
group_with_class_number(n::IntegerUnion, i::IntegerUnion)

Return the i-th group in the list of groups with exactly n conjugacy classes. 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 a solvable group that belongs to the library of small groups, otherwise it will be of type PermGroup.

Examples

julia> describe(group_with_class_number(5, 4))
"D14"

julia> describe(group_with_class_number(5, 8))
"A5"

julia> group_with_class_number(5, 12)
ERROR: ArgumentError: there are only 8 groups with 5 classes, not 12
[...]
source

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

julia> atlas_group(info[1])
Permutation group of degree 5 and order 60
source
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
source
show_atlas_info — Function
show_atlas_info()
show_atlas_info(groupnames::Vector{String})
show_atlas_info(groupname::String)

Print information concerning the group atlas about the groups given by the arguments.

If the only argument is a vector groupnames of strings then print one line about each Atlas group whose name is in groupnames, showing the available information.

If there are no arguments then the same happens as if the vector of all names of Atlas groups were entered as groupnames.

If the only argument is a string groupname, the name of an Atlas group G, then print an overview of available representations and straight line programs for G.

The overview for several groups is shown as a table with the following columns.

  • group: the name of G

  • #: the number of faithful representations stored for G

  • maxes: the number of available straight line programs for computing generators of maximal subgroups of G,

  • cl: a + sign if at least one program for computing representatives of conjugacy classes of elements of G is stored,

  • cyc: a + sign if at least one program for computing representatives of classes of maximally cyclic subgroups of G is stored,

  • out: descriptions of outer automorphisms of G for which at least one program is stored,

  • fnd: a + sign if at least one program is available for finding standard generators,

  • chk: a + sign if at least one program is available for checking whether a set of generators is a set of standard generators, and

  • prs: a + sign if at least one program is available that encodes a presentation.

The overview for a single group is shown in the form of two lists, one for available representations, one for available straight line programs.

Each available representation is described by either G <= Sym(nid) or G <= GL(nid,descr), where the former means a permutation representation of degree n and the latter means a matrix ring of dimension n over a base ring described by descr; if descr is an integer then this means a finite field with this cardinality. In both cases, id is a (perhaps empty) identifier that distinguishes different representations with the same n. If known then information about transitivity, rank, point stabillizers of permutation representations and about the character of matrix representations is shown as well.

Below the representations, the programs available for groupname are listed.

source