Group Theory Updates in 2019 - New Features in Maple 2019 - Maplesoft

What's New in Maple 2019

Group Theory Updates in 2019



Description 

  • The GroupTheory package in 2019 contains more than sixty new or updated commands, new and enhanced databases of groups, and significant performance improvements.
 

> with( GroupTheory ):
 

Computing Dessins D'enfants and Belyi maps 

  • The new FindDessins command computes all dessins d'enfants corresponding to a specified branching pattern. A dessin also represents a Belyi map, and the DecomposeDessin command finds all decompositions of the corresponding Belyi map. These are both parametrized by certain triples of permutations, called 3-constellations, with cycle structure equal to the specified branching pattern.
 

  • Consider an example of degree 24 with branching pattern [3$8], [2$12], [6$4].
 

> infolevel[ 'FindDessins' ] := 2:
 

> S := FindDessins( [ 3 $ 8 ], [ 2 $ 12 ], [ 6 $ 4 ] );
 

 

FindDessins:   Genus 1
FindDessins:       1 pairs before discarding conjugates
FindDessins:      1 dessins of degree 1/24 after .4e-2 seconds
FindDessins:       1 pairs before discarding conjugates
FindDessins:      1 dessins of degree 2/24 after .4e-2 seconds
FindDessins:       2 pairs before discarding conjugates
FindDessins:      1 dessins of degree 3/24 after .4e-2 seconds
FindDessins:     1 pairs before discarding conjugates
FindDessins:      1 dessins of degree 5/24 after .5e-2 seconds
FindDessins:       1 pairs before discarding conjugates
FindDessins:      1 dessins of degree 6/24 after .6e-2 seconds
FindDessins:   2 pairs before discarding conjugates
FindDessins:     3 pairs before discarding conjugates
FindDessins:     12 pairs before discarding conjugates
FindDessins:      3 pairs before discarding conjugates
FindDessins:      3 dessins of degree 12/24 after .15e-1 seconds
FindDessins:     4 pairs before discarding conjugates
FindDessins:     31 pairs before discarding conjugates
FindDessins:      2 pairs before discarding conjugates
FindDessins:      4 dessins of degree 18/24 after .46e-1 seconds
FindDessins:     4 pairs before discarding conjugates
FindDessins:      3 pairs before discarding conjugates
FindDessins:      3 dessins of degree 24/24 after .91e-1 seconds
S := {[Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
S := {[Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
S := {[Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
S := {[Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
S := {[Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

  • In this case, FindDessins finds 3 dessins.
 

> nops( S );
 

3
 

> d := S[ 2 ];
 

d := [Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
d := [Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> map( PermCycleType, d );
 

[[3, 3, 3, 3, 3, 3, 3, 3], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]]
 

> DecomposeDessin( d, 'L', 'gr' );
 

F = F1(deg 2) = F2(deg 2) = F3(deg 2) = F4(deg 2) = F5(deg 2) = F6(deg 2) = F7(deg 2) = F8(deg 3) = F9(deg 3) = F10(deg 3) = F11(deg 3) = F12(deg 4) = F13(deg 4) = F14(deg 4) = F15(deg 4) = F16(deg 4...
F = F1(deg 2) = F2(deg 2) = F3(deg 2) = F4(deg 2) = F5(deg 2) = F6(deg 2) = F7(deg 2) = F8(deg 3) = F9(deg 3) = F10(deg 3) = F11(deg 3) = F12(deg 4) = F13(deg 4) = F14(deg 4) = F15(deg 4) = F16(deg 4...
F = F1(deg 2) = F2(deg 2) = F3(deg 2) = F4(deg 2) = F5(deg 2) = F6(deg 2) = F7(deg 2) = F8(deg 3) = F9(deg 3) = F10(deg 3) = F11(deg 3) = F12(deg 4) = F13(deg 4) = F14(deg 4) = F15(deg 4) = F16(deg 4...
 

> L[1];
 


 

> gr;
 

Plot_2d
 

  • By iterating over all possible cycle types of a given degree (in the example below, the degree is N = 6), we can count all dessins d'enfants or, equivalently, Belyi maps up to equivalence.
 

> infolevel[ 'FindDessins' ] := 0:
 

> N := 6:
 

> P := combinat:-partition( N ):
 

> nops( P );
 

11
 

> add( add( add( nops( FindDessins( i, j, k ) ), k = P ), j = P ), i = P );
 

624
 

New GroupTheory Package Commands 

  • Many new commands have been added to the GroupTheory package in 2019. These include commands for recognizing groups with many interesting properties, new commands for constructing groups of various kinds, new commands to compute subgroups and subgroup series, as well as a suite of commands for recognizing numbers for which every group of a given order has one of a number of group-theoretic properties.
 

Frobenius Groups 

  • Maple is now able to recognize finite Frobenius groups, either as abstract groups, or as permutation groups, and to compute Frobenius kernels and complements. Consult the linked help pages for more details. See also the section on the new database of small Frobenius groups below.
 

  • The IsFrobeniusGroup command determines whether a finite permutation group G is a Frobenius group, as an abstract group.
 

> IsFrobeniusGroup( Symm( 3 ) ); # the smallest Frobenius group
 

true
 

> IsFrobeniusGroup( DihedralGroup( 5 ) );
 

true
 

> IsFrobeniusGroup( QuaternionGroup() );
 

false
 

  • The IsFrobeniusPermGroup command returns true if the permutation group G is Frobenius in its natural action.
 

> IsFrobeniusPermGroup( SmallGroup( 6, 1 ) );
 

false
 

> IsFrobeniusGroup( SmallGroup( 6, 1 ) );
 

true
 

  • If G is a Frobenius group, then the FrobeniusKernel( G ) command returns its Frobenius kernel. Likewise, the FrobeniusComplement( G ) command returns a representative Frobenius complement.
 

> FrobeniusKernel( DihedralGroup( 5 ) );
 

`<,>`(1, 5, 4, 3, 2)
 

> FrobeniusComplement( DihedralGroup( 5 ) );
 

`<,>`((1, 4)(2, 3))
 

  • If a Frobenius group is not represented as a permutation group with Frobenius action, you can use the FrobeniusPermRep( G ) command to obtain a permutation group isomorphic to G for which the action is Frobenius.
 

> P := FrobeniusPermRep( SmallGroup( 6, 1 ) );
 

P := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> IsFrobeniusPermGroup( P );
 

true
 

Hamiltonian Groups 

  • Several new commands that allow you to work with finite Hamiltonian groups have been introduced in 2019.
 

  • Use the IsHamiltonian command to check whether a permutation group is Hamiltonian (that is, a non-Abelian group with every subgroup normal). The IsDedekind command allows you to determine whether a permutation group is a Dedekind group (either Abelian or Hamiltonian).
 

> IsHamiltonian( QuaternionGroup() );
 

true
 

> IsDedekind( DihedralGroup( 4 ) );
 

false
 

> IsDedekind( ElementaryGroup( 3, 3 ) );
 

true
 

  • There are new constructors for Hamiltonian groups in this release. The HamiltonianGroup( n, k ) command returns the k-th  Hamiltonian group of order n, where n is a multiple of eight.  (All Hamiltonian groups have order equal to a multiple of eight.) The NumHamiltonianGroups command returns the number of Hamiltonian groups of a given positive integral order.
 

> NumHamiltonianGroups( 100 );
 

0
 

> NumHamiltonianGroups( 200 );
 

2
 

> G := HamiltonianGroup( 200, 2 ):
 

> IsHamiltonian( G );
 

true
 

  • The AllHamiltonianGroups command returns an expression sequence of all the Hamiltonian groups of a given order.
 

> AllHamiltonianGroups( 200 );
 

Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

  • In addition, Hamiltonian groups in the database of small groups have been identified, allowing you to use the search term hamiltonian in the SearchSmallGroups command.
 

Subgroup Series 

  • Every finite group has a composition series, a subnormal series with simple factors, and the CompositionSeries command returns a composition series for a finite permutation group.
 

> G := Group( [Perm([[1, 2, 3]]), Perm([[2, 3, 4]]), Perm([[6, 8], [7, 9], [11, 19], [12, 18], [14, 17], [16, 20]]), Perm([[6, 10, 11], [7, 15, 16], [8, 18, 9], [12, 13, 17], [14, 19, 20]]), Perm([[5, 6], [7, 12], [8, 13], [9, 14], [10, 11], [15, 19], [16, 18], [17, 20]]), Perm([[5, 7], [6, 12], [8, 17], [9, 10], [11, 14], [13, 20], [15, 16], [18, 19]]), Perm([[5, 8], [6, 13], [7, 17], [9, 18], [10, 19], [11, 15], [ 12, 20], [14, 16]]), Perm([[5, 9], [6, 14], [7, 10], [8, 18], [11, 12], [13, 16], [15, 20], [17, 19]]), Perm([[21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]])] );
 

G := ` < a permutation group on 110 letters with 9 generators > `
 

> cs := CompositionSeries( G );
 

 

  • Composition series are of type SubnormalSeries, but not (in general) of type NormalSeries.
 

> type( cs, 'SubnormalSeries' );
 

true
 

> type( cs, 'NormalSeries' );
 

false
 

> [seq]( GroupOrder( H ), H = cs );
 

[1036800, 207360, 69120, 23040, 11520, 3840, 1920, 960, 1]
 

  • The CompositionLength command returns the number of composition factors.
 

> CompositionLength( DihedralGroup( 10 ) );
 

3
 

  • For a prime number p, the lower p-central series of a finite group G can be computed by using the new LowerPCentralSeries( p, G ) command.
 

> ser := LowerPCentralSeries( 2, DihedralGroup( 8 ) );
 

ser := Typesetting:-mrow(Typesetting:-msub(Typesetting:-mi(
 

> seq( GroupOrder( H ), H = ser );
 

16, 4, 2, 1
 

  • To compute the lower Fitting series of a group use the LowerFittingSeries command. The FittingLength( G ) command returns the Fitting length of the soluble permutation group G.
 

> ser := LowerFittingSeries( DihedralGroup( 10 ) );
 

ser := Typesetting:-mrow(Typesetting:-msub(Typesetting:-mi(
 

> seq( GroupOrder( H ), H = ser );
 

20, 5, 1
 

> FittingLength( DihedralGroup( 10 ) );
 

2
 

> FittingLength( DihedralGroup( 8 ) );
 

1
 

  • Use the new FrattiniSeries( G ) command to compute the Frattini series of a permutation group G.
 

> fs := FrattiniSeries( Alt( 4 ) );
 

 

> type( fs, 'NormalSeries' );
 

true
 

  • The FrattiniLength command computes the Frattini length of a permutation group; that is, the length of its Frattini series.
 

> FrattiniLength( GL( 2, 3 ) );
 

2
 

  • A Sylow tower of a finite group G is a normal series
 

 

for which the series quotients `/`(`*`(G[k]), `*`(G[`+`(k, 1)])) are isomorphic to the Sylow subgroups of G, exactly one for each prime divisor of the order of G. A sequence gamma = p[1], p[2], () .. (), p[r] of primes is called a complexion of the Sylow tower if it contains all of the primes dividing the order of G and if the tower quotients corresponding to the prime divisors of the order of G appear in the order in which they appear in gamma. A group may or may not have a Sylow tower, and may have a Sylow tower of one complexion, but not of another, but a group with a Sylow tower of any complexion is necessarily soluble. 

  • The SylowTower( G ) command computes a Sylow tower (of some unspecified complexion) for a soluble permutation group G, if one exists.
 

> st := SylowTower( Alt( 4 ) );
 

st := Typesetting:-mrow(Typesetting:-mfenced(open =
 

> type( st, 'NormalSeries' );
 

true
 

  • The complexion for the computed Sylow tower can be retrieved by using the Complexion method.
 

> Complexion( st );
 

[2, 3]
 

  • The IsSylowTowerGroup( G ) command determines whether the group G has a Sylow tower.
 

> IsSylowTowerGroup( Alt( 4 ) );
 

true
 

> IsSylowTowerGroup( Symm( 4 ) );
 

false
 

  • A Sylow tower is called ordered if the primes corresponding to successive tower quotients occur in descending order of magnitude. The Sylow tower for the alternating group computed above is not ordered because the prime divisors 2 and 3 of the order 12 of the group do not occur in descending order.
 

  • The OrderedSylowTower( G ) command computes an ordered Sylow tower for the soluble permutation group G if one exists.
 

  • In fact, the alternating group A[4] does not have an ordered Sylow tower.
 

> OrderedSylowTower( Alt( 4 ) );
 

Error, group GroupTheory:-AlternatingGroup(4) has no ordered Sylow tower of complexion [3, 2]
 

  • However, every supersoluble group does have an ordered Sylow tower.
 

> st := OrderedSylowTower( DihedralGroup( 15 ) );
 

st := Typesetting:-mrow(Typesetting:-mfenced(open =
st := Typesetting:-mrow(Typesetting:-mfenced(open =
st := Typesetting:-mrow(Typesetting:-mfenced(open =
 

  • Notice that the prime divisors in this example do occur in descending order.
 

> Complexion( st );
 

[5, 3, 2]
 

  • Use the IsOrderedSylowTowerGroup( G ) command to determine whether the group G has an ordered Sylow tower.
 

> IsOrderedSylowTowerGroup( Alt( 4 ) );
 

false
 

> IsOrderedSylowTowerGroup( DihedralGroup( 15 ) );
 

true
 

  • More generally, the OrderedSylowTower command allows you to pre-specify any desired complexion, and computes a Sylow tower with the matching complexion, if possible.
 

> st := OrderedSylowTower( DihedralGroup( 15 ), 'complexion' = [ 3, 5, 2 ] );
 

st := Typesetting:-mrow(Typesetting:-mfenced(open =
st := Typesetting:-mrow(Typesetting:-mfenced(open =
st := Typesetting:-mrow(Typesetting:-mfenced(open =
 

> Complexion( st );
 

[3, 5, 2]
 

> st := OrderedSylowTower( DihedralGroup( 15 ), 'complexion' = [ 3, 2, 5 ] );
 

Error, group GroupTheory:-DihedralGroup(15,form = "permgroup") has no ordered Sylow tower of complexion [3, 2, 5]
 

Remak Decompositions 

  • The new DirectFactors command produces a Remak decomposition of a finite group.  This is an expression sequence of directly indecomposable subgroups of the group such that the group is the direct product of the groups in the sequence.
 

> df := DirectFactors( DihedralGroup( 10 ) );
 

df := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> AreIsomorphic( DihedralGroup( 10 ), DirectProduct( df ) );
 

true
 

  • To determine whether a group is directly indecomposable, use the new IsDirectlyIndecomposable command.
 

> IsDirectlyIndecomposable( QuaternionGroup() );
 

true
 

> DirectFactors( QuaternionGroup() );
 

Q
 

> IsDirectlyIndecomposable( SmallGroup( 4, 2 ) );
 

false
 

> DirectFactors( SmallGroup( 4, 2 ) );
 

 

New Commands for Finite Soluble Groups 

  • A finite group is soluble if, and only if, it has a Sylow basis. The SylowBasis command computes a Sylow basis for a soluble permutation group.
 

> G := DihedralGroup( 30 );
 

G := D[30]
 

> ifactor( GroupOrder( G ) );
 

`*`(`^`(``(2), 2), `*`(``(3), `*`(``(5))))
 

> B := SylowBasis( G );
 

B := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
B := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
B := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
B := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
B := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> map( GroupOrder, B );
 

[5, 3, 4]
 

> andmap( type, map( GroupOrder, B ), 'primepower' );
 

true
 

> evalb( FrobeniusProduct( B[ 1 ], B[ 2 ], G ) = FrobeniusProduct( B[ 2 ], B[ 1 ], G ) );
 

true
 

  • The HallSubgroup command computes a Hall subgroup corresponding to a set of prime divisors of the order of a soluble group.
 

> H := HallSubgroup( { 2, 5 }, DihedralGroup( 30 ) );
 

H := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
H := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
H := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
H := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> ifactor( GroupOrder( DihedralGroup( 30 ) ) );
 

`*`(`^`(``(2), 2), `*`(``(3), `*`(``(5))))
 

> ifactor( GroupOrder( H ) );
 

`*`(`^`(``(2), 2), `*`(``(5)))
 

Group Properties 

  • A number of new commands have been introduced that allow you to test whether a finite group has various properties.
 

  • Some of these, such as the new commands IsHamiltonian, IsFrobeniusGroup and IsDirectlyIndecomposable, were described above.
 

  • Several more new commands are provided to test whether a finite group belongs to one of a number of other classes of soluble groups.
 

  • Use the IsMetacyclic command to determine whether a finite group is metacyclic, and the IsMetabelian command to decide whether a finite group is metabelian. For example, the alternating group of degree 4; is metabelian, but is not metacyclic.
 

> IsMetacyclic( Alt( 4 ) );
 

false
 

> IsMetabelian( Alt( 4 ) );
 

true
 

  • The new IsCyclicSylowGroup command determines whether a finite group has the property that all of its Sylow subgroups are cyclic. (These are most commonly referred to as Z-groups.)
 

> IsCyclicSylowGroup( DihedralGroup( 5 ) );
 

true
 

  • Finite groups whose Sylow subgroups are all Abelian (often called A-groups) can be recognized by the new IsAbelianSylowGroup command.
 

> IsAbelianSylowGroup( Alt( 4 ) );
 

true
 

  • Use the new IsAlmostSimple command to determine whether a group is almost simple.
 

> IsAlmostSimple( Symm( 6 ) );
 

true
 

  • The new commands IsCNGroup, IsCAGroup and IsCCGroup are used to recognize groups based on properties of their centralizers. These commands detect, respectively, whether the centralizer of each non-trivial element of a finite group is nilpotent, Abelian or cyclic.
 

  • For example, the symmetric group of degree 4 is the smallest non-nilpotent (CN)-group that is not a (CA)-group.
 

> IsCNGroup( Symm( 4 ) );
 

true
 

> IsCAGroup( Symm( 4 ) );
 

false
 

  • The IsHallPaigeGroup command determines whether a finite group has a complete mapping in the sense of Hall and Paige.  (The Hall-Paige conjecture was recently settled.)
 

> IsHallPaigeGroup( DihedralGroup( 5 ) );
 

false
 

> IsHallPaigeGroup( DihedralGroup( 10 ) );
 

true
 

> IsHallPaigeGroup( TitsGroup() );
 

true
 

  • The IsDihedral command determines whether a permutation group is isomorphic to a dihedral group (not necessarily of the same degree).
 

> IsDihedral( Group( Perm([[1,4],[2,11]]), Perm([[111,112],[207,333]]) ) );
 

true
 

> IsDihedral( QuaternionGroup() );
 

false
 

  • Other group properties implemented for permutation groups in this release include IsSupersoluble, IsLagrangian, IsGCLTGroup and IsStemGroup.
 

  • The IsSupersoluble( G ) command determines whether the group G is supersoluble; that is, whether all of its chief factors are cyclic of prime order.
 

> IsSupersoluble( Alt( 4 ) );
 

false
 

> IsSupersoluble( DihedralGroup( 7 ) );
 

true
 

  • Use the IsLagrangian( G ) command to determine whether the group G satisfies the converse of Lagrange's Theorem; that is, whether it has a subgroup of order d for each divisor d of its order.
 

> IsLagrangian( Symm( 4 ) );
 

true
 

> IsLagrangian( Alt( 4 ) );
 

false
 

  • The IsGCLTGroup( G ) command checks whether the group G is a GCLT-group.
 

> IsGCLTGroup( Symm( 4 ) );
 

false
 

> IsGCLTGroup( QuaternionGroup() );
 

true
 

  • To determine whether a group G is a stem group, use the new IsStemGroup( G ) command.
 

> IsStemGroup( DihedralGroup( 4 ) );
 

true
 

> IsStemGroup( CyclicGroup( 10 ) );
 

false
 

  • A finite group is said to have perfect order classes if the number of elements of each order is a divisor of the order of the group. The IsPerfectOrderClassesGroup command determines whether a group has perfect order classes.
 

> IsPerfectOrderClassesGroup( Symm( 3 ) );
 

true
 

> IsPerfectOrderClassesGroup( Symm( 4 ) );
 

false
 

New and Updated Group Constructors 

  • The SmallGroup constructor can now construct groups of order `^`(p, k), for arbitrary primes p, and positive integers `<=`(k, 4).
 

> G := SmallGroup( 5^4, 3 ):
 

> GroupOrder( G );
 

625
 

> G := SmallGroup( 11^4, 11, 'form' = "fpgroup" );
 

G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo(
 

> GroupOrder( G );
 

14641
 

  • Generalizing the DerivedSubgroup constructor, the new Commutator( A, B, G ) command computes the normal closure, in the group G, of the commutators [a, b], with a in A and b in B.
 

> H := Commutator( SylowSubgroup( 2, Symm( 5 ) ), SylowSubgroup( 3, Symm( 5 ) ), Symm( 5 ) );
 

H := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> GroupOrder( H );
 

60
 

> AreIsomorphic( H, Alt( 5 ) );
 

true
 

  • The AllAbelianGroups command returns the complete set of Abelian groups of a given order.
 

> AllAbelianGroups( 4 );
 

Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo(
 

Number Theoretic Commands 

  • A selection of number-theoretic commands have been added that allow you to determine whether every group of a given order has a specific property. Here are several examples.
 

  • The IsCyclicNumber( n ) command  returns true if, and only if, every group of order n is cyclic. This, of course, includes the primes, but also includes composite numbers. In this case, there is only one group of order n.
 

> IsCyclicNumber( 11 );
 

true
 

> IsCyclicNumber( 15 );
 

true
 

> NumGroups( 15 );
 

1
 

> IsCyclicNumber( 6 );
 

false
 

> NumGroups( 6 );
 

2
 

  • Positive integers n for which every group of order n is Abelian are recognized by the IsAbelianNumber( n ) command.
 

> IsAbelianNumber( 4 );
 

true
 

> andmap( IsAbelian, AllSmallGroups( 4 ) );
 

true
 

> IsAbelianNumber( 6 );
 

false
 

> andmap( IsAbelian, AllSmallGroups( 6 ) );
 

false
 

  • To determine whether every group of order n is a nilpotent group, use the new IsNilpotentNumber( n ) command.
 

> IsNilpotentNumber( 24 );
 

false
 

> IsNilpotentNumber( 459 );
 

true
 

> NumGroups( 459 );
 

5
 

> andmap( IsNilpotent, AllSmallGroups( 459 ) );
 

true
 

  • Similarly, the IsSolubleNumber( n ) command determines whether every group of order n is soluble.
 

> andmap( IsSolubleNumber, [seq]( 1 .. 59 ) );
 

true
 

> andmap( IsSolubleNumber, [seq]( 1 .. 60 ) );
 

false
 

> Statistics:-VennDiagram( IsCyclicNumber, IsAbelianNumber, IsNilpotentNumber, IsLagrangianNumber, IsSolubleNumber, universe = {seq}(1..10000),
legend = ["Cyclic", "Abelian", "Nilpotent", "Lagrangian", "Soluble" ] );
 

Plot_2d
 

  • Since every supersoluble group has an ordered Sylow tower, every supersoluble number is an ordered Sylow tower number. Evidence for this is exhibited by this command:
 

> andmap( IsSupersolubleNumber implies IsOrderedSylowTowerNumber, [seq]( 1 .. 10000 ) );
 

true
 

  • But, the non-Abelian group of order 75 is not supersoluble, yet it has an ordered Sylow tower. Therefore, 75 is an ordered Sylow tower number, but not a supersoluble number.
 

> IsOrderedSylowTowerNumber( 75 );
 

true
 

> IsSupersolubleNumber( 75 );
 

false
 

  • The following additional number-theoretic commands are new in this release: IsIntegrableNumber, IsMetacyclicNumber, IsMetabelianNumber, IsLagrangianNumber, IsGCLTNumber.
 

Other New Commands 

  • A number of other commands in the GroupTheory package have been added, or updated, in 2019.
 

  • The NumGroups command can compute the number of groups of order n for more positive integers n.
 

> NumGroups( 837627012169834259 ); # returned FAIL in Maple 2018
 

24
 

  • The ElementPower command computes integral powers of elements of a finite group.
 

> G := CayleyTableGroup( Symm( 3 ) );
 

G := ` < a Cayley table group with 6 elements > `
 

> g := RandomElement( G ):
 

> ElementPower( g, 208374237432343274923743847385, G );
 

3
 

  • The IsTrivial and TrivialSubgroup commands are utilities for testing for a trivial subgroup, and constructing the trivial subgroup of a given group.
 

  • For permutation groups, the RandomInvolution command returns a randomly chosen element of order 2; in a group of even order.
 

> g := RandomInvolution( Alt( 8 ) );
 

g := Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> PermOrder( g );
 

2
 

  • The RandomPElement command selects an element of p-power order from a permutation group at random, and the RandomPPrimeElement command chooses at random an element with order not divisible by a specified prime p.
 

> g := RandomPElement( 3, Alt( 11 ) );
 

g := Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> ifactor( PermOrder( g ) );
 

``(3)
 

> evalb( g in Alt( 11 ) );
 

true
 

> g := RandomPPrimeElement( 3, Alt( 11 ) );
 

g := Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> ifactor( PermOrder( g ) );
 

``(11)
 

> evalb( g in Alt( 11 ) );
 

true
 

  • The new OrderClassProfile command computes the number of elements of each order in a finite group. A sorted list of element orders is returned by default, but you can request that the output be produced in the form of a MultiSet, or a list of pairs of the form [ order, multiplicity ] by using the appropriate option, as illustrated in the examples below.
 

> OrderClassProfile( Alt( 4 ) );
 

[[1, 1], [2, 3], [3, 8]]
 

> OrderClassProfile( Alt( 4 ), 'output' = "list" );
 

[1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3]
 

> OrderClassProfile( Alt( 4 ), 'output' = "multiset" );
 

{[1, 1], [2, 3], [3, 8]}
 

  • The OrderClassPolynomial command provides an encoding of the order class data in the form of a polynomial expression in an indeterminate x, in which the coefficient of the term x^k is equal to the number of elements of order k.
 

> OrderClassPolynomial( Alt( 4 ), 'x' );
 

`+`(`*`(8, `*`(`^`(x, 3))), `*`(3, `*`(`^`(x, 2))), x)
 

New and Updated Group Databases 

  • 2019 includes a new database of Frobenius groups, as well as updates to the databases of small groups, transitive groups and perfect groups.
 

New Database of Frobenius Groups 

  • 2019 also introduces a new database of Frobenius groups.
 

  • To determine the number of Frobenius groups of a given order n, use the command NumFrobeniusGroups( n ).
 

> NumFrobeniusGroups( 6 );
 

1
 

> NumFrobeniusGroups( 60 );
 

0
 

> NumFrobeniusGroups( 100 );
 

3
 

  • To access a Frobenius group in the database, similar to the other group databases in Maple, use the command FrobeniusGroup( n, k ) to access the k-th Frobenius group of order n.
 

> G := FrobeniusGroup( 100, 3 );
 

G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> GroupOrder( FrobeniusKernel( G ) );
 

25
 

> GroupOrder( FrobeniusComplement( G ) );
 

4
 

  • The AllFrobeniusGroups( n ) command returns a list of all the Frobenius groups of a given order n.
 

> L := AllFrobeniusGroups( 18 );
 

L := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
L := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> evalb( nops( L ) = NumFrobeniusGroups( 18 ) );
 

true
 

  • The IdentifyFrobeniusGroup command returns the ID of a Frobenius group that is present in the Frobenius groups database.
 

> IdentifyFrobeniusGroup( Symm( 3 ) );
 

6, 1
 

> IdentifyFrobeniusGroup( Alt( 4 ) );
 

12, 1
 

> AreIsomorphic( Alt( 4 ), FrobeniusGroup( 12, 1 ) );
 

true
 

  • The Frobenius groups database is searchable by using the SearchFrobeniusGroups command. This is similar to SearchSmallGroups and SearchTransitiveGroups. Consult the help page SearchFrobeniusGroups for a complete list and description of the pre-computed properties that can be queried using this command.
 

> SearchFrobeniusGroups( order < 50, 'cyclickernel', 'cycliccomplement' );
 

[6, 1], [10, 1], [14, 1], [18, 1], [20, 1], [21, 1], [22, 1], [26, 1], [30, 1], [34, 1], [38, 1], [39, 1], [42, 1], [42, 2], [46, 1]
[6, 1], [10, 1], [14, 1], [18, 1], [20, 1], [21, 1], [22, 1], [26, 1], [30, 1], [34, 1], [38, 1], [39, 1], [42, 1], [42, 2], [46, 1]
 

> G := FrobeniusGroup( 42, 1 );
 

G := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> IsCyclic( FrobeniusKernel( G ) );
 

true
 

> IsCyclic( FrobeniusComplement( G ) );
 

true
 

  • Let us construct one of the maximal subgroups of the exceptional group Sz(8), as follows.
 

> a, b := op( Generators( ExceptionalGroup( "Sz(8)" ) ) ):
 

> G := Group( [  (a.b)^2 . (b.a)^2 .b, (a.b^2)^(-1) . b.a.b^2 ] ):
 

  • This subgroup is a Frobenius group.
 

> IsFrobeniusGroup( G );
 

true
 

  • To compute the Frobenius kernel and complement and determine their orders, proceed as follows.
 

> K := FrobeniusKernel( G );
 

K := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
K := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
K := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> GroupOrder( K );
 

13
 

> C := FrobeniusComplement( G );
 

C := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
C := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
C := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
C := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
C := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> GroupOrder( C );
 

4
 

> IsMalnormal( C, G );
 

true
 

  • Subgroups of Frobenius complements whose order is the product of two primes are necessarily cyclic.
 

> IsCyclic( C );
 

true
 

> IdentifySmallGroup( C );
 

4, 1
 

  • However, the natural action of this group is not Frobenius.
 

> IsFrobeniusPermGroup( G );
 

false
 

  • To get an isomorphic Frobenius permutation group (via the action of G; on the cosets of the Frobenius complement), use the FrobeniusPermRep command.
 

> P := FrobeniusPermRep( G );
 

P := Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mfenced(Typesetting:-mn(
 

> IsFrobeniusPermGroup( P );
 

true
 

  • Of course, the Frobenius kernel and complement of P are isomorphic to those of G.
 

> IdentifySmallGroup( FrobeniusComplement( P ) );
 

4, 1
 

> AreIsomorphic( FrobeniusKernel( P ), K );
 

true
 

  • To locate this group in the database of Frobenius groups, use the IdentifyFrobeniusGroup command.
 

> IdentifyFrobeniusGroup( G );
 

52, 1
 

  • Or, equivalently:
 

> IdentifyFrobeniusGroup( P );
 

52, 1
 

  • Finally, as discussed below, the Frobenius (permutation) groups in the database of transitive groups have been identified, and can be used as a search term there. As well, the Frobenius (abstract) groups in the Small Groups database have been identified.
 

Updated Database of Perfect Groups 

  • The new SearchPerfectGroups command allows you to search the database of perfect group for groups satisfying various combinations of properties, including the order, center, socle, Fitting subgroup, class number and others.  Consult the help page SearchPerfectGroups for a complete list of the supported properties.
 

  • Find the perfect groups with non-trivial center, whose order is less than 1000.
 

> L := [SearchPerfectGroups]( order < 1000, center > 1, 'form' = "fpgroup" );
 

L := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo(
L := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo(
L := [Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo(
 

> map( GroupOrder, L );
 

[120, 336, 720]
 

> map( IsPerfect, L );
 

[true, true, true]
 

> map( GroupOrder @ Center @ PermutationGroup, L );
 

[2, 2, 2]
 

  • Find those perfect groups of order less than 10000 with center isomorphic to SmallGroup( 4, 2 ).
 

> SearchPerfectGroups( order < 10000, center = [ 4, 2 ] ); # SmallGroup ID for center!
 

[3840, 3], [3840, 4], [3840, 5], [3840, 7], [5376, 1]
 

  • It is important to understand that the IDs returned by SearchPerfectGroups are the IDs of groups in the database of perfect groups, while the IDs used in queries such as the one above are IDs for the small groups database.
 

Updated Databases of Small Groups and Transitive Groups 

  • Many new properties have been added to the databases of small groups and transitive groups.  Here are a few examples:
 

> SearchSmallGroups( order <= 32, compositionlength = 5, abelian );
 

[32, 1], [32, 3], [32, 16], [32, 21], [32, 36], [32, 45], [32, 51]
 

> SearchSmallGroups( hamiltonian, order = 100 .. 120 );
 

[104, 11], [112, 39], [120, 33]
 

> SearchSmallGroups( almostsimple );
 

[60, 5], [120, 34], [168, 42], [336, 208], [360, 118], [504, 156]
 

  • The TransitiveGroups database now includes some abstract group-theoretic properties.
 

  • Which soluble, but non-Abelian transitive groups have degree less than 5?
 

> SearchTransitiveGroups( degree < 5, soluble, abelian = false );
 

[3, 2], [4, 3], [4, 4], [4, 5]
 

  • The following visualization gives an indication of the relative prevalence of soluble transitive groups in the database.
 

> Statistics:-PieChart( [ "Soluble" = SearchTransitiveGroups( 'soluble', 'form' = "count" ), "Insoluble" = SearchTransitiveGroups( 'soluble' = false, 'form' = "count" ) ] );
 

Plot_2d
 

  • How many transitive groups in the database are perfect, but not simple?
 

> SearchTransitiveGroups( simple = false, perfect, form = "count" );
 

376
 

  • Importantly, the Frobenius groups in the transitive groups database have been identified.
 

> SearchTransitiveGroups( frobenius, form = count );
 

81
 

  • We know that there are two Frobenius groups of order 18.
 

> NumFrobeniusGroups( 18 );
 

2
 

  • Let's see if both also appear in the TransitiveGroups database.
 

> SearchTransitiveGroups( frobenius, order = 18 );
 

[9, 3], [9, 5]
 

> IsFrobeniusPermGroup( TransitiveGroup( 9, 3 ) );
 

true
 

> IsFrobeniusPermGroup( TransitiveGroup( 9, 5 ) );
 

true
 

  • Use IdentifyFrobeniusGroup to distinguish which transitive group corresponds to which Frobenius group from their respective databases.
 

> IdentifyFrobeniusGroup( TransitiveGroup( 9, 3 ) );
 

18, 1
 

> IdentifyFrobeniusGroup( TransitiveGroup( 9, 5 ) );
 

18, 2
 

> AreIsomorphic( TransitiveGroup( 9, 3 ), FrobeniusGroup( 18, 1 ) );
 

true
 

> AreIsomorphic( TransitiveGroup( 9, 5 ), FrobeniusGroup( 18, 2 ) );
 

true
 

Performance Improvements 

  • Arithmetic and other low-level operations for permutations have been completely re-written in compiled kernel code. In addition, the memory overhead of permutations has been considerably reduced.
 

  • For example, the following call to PermOrder took about 200 times longer in Maple 2018.
 

> p := Perm( combinat:-randperm( 10^5 ) ):
 

> PermOrder( p );
 

146023340747615338030516645152
 

  • Timing details will of course vary from one machine to another, and depend also upon the random state of the Maple session. But, reproduced here are some representative calculations run in a fresh Maple 2018 session, on a particular 64-bit Linux workstation.
 

> L := CodeTools:-Usage( [seq]( Perm( combinat:-randperm( 10^4 ) ), i = 1 .. 1000 ) ):
 

memory used=307.01MiB, alloc change=283.42MiB, cpu time=6.62s, real time=6.62s, gc time=108.00ma 

> CodeTools:-Usage( PermProduct( op( L ) ) ):
 

memory used=307.57MiB, alloc change=288.00MiB, cpu time=9.78s, real time=8.36s, gc time=1.75s 

> CodeTools:-Usage( map( PermOrder, L ) ):
 

memory used=2.54GiB, alloc change=96.00MiB, cpu time=52.62s, real time=40.96s, gc time=13.75s 

> CodeTools:-Usage( map( PermInverse, L ) ):
 

memory used=0.74GiB, alloc change=320.00MiB, cpu time=19.56s, real time=14.66s, gc time=5.71s 

> CodeTools:-Usage( map( PermCycleType, L ) ):
 

memory used=0.84MiB, alloc change=0 bytes, cpu time=152.00ms, real time=149.00ms, gc time=0ns 

> CodeTools:-Usage( map( PermPower, L, 3333 ) ):
 

memory used=4.53GiB, alloc change=2.22GiB, cpu time=3.78m, real time=2.17m, gc time=113.08s 

  • And here are the same calculations run in a fresh 2019 session on the same machine. It is apparent that both time used and memory consumption have been considerably reduced.
 

> L := CodeTools:-Usage( [seq]( Perm( combinat:-randperm( 10^4 ) ), i = 1 .. 1000 ) ):
 

memory used=77.16MiB, alloc change=59.42MiB, cpu time=1.10s, real time=1.10s, gc time=8.00ms 

> CodeTools:-Usage( PermProduct( op( L ) ) ):
 

memory used=77.85MiB, alloc change=0 bytes, cpu time=592.00ms, real time=587.00ms, gc time=24.00ms 

> CodeTools:-Usage( map( PermOrder, L ) ):
 

memory used=8.08MiB, alloc change=3.01MiB, cpu time=204.00ms, real time=203.00ms, gc time=0ns 

> CodeTools:-Usage( map( PermInverse, L ) ):
 

memory used=77.30MiB, alloc change=-1.00MiB, cpu time=568.00ms, real time=560.00ms, gc time=16.00ms 

> CodeTools:-Usage( map( PermCycleType, L ) ):
 

memory used=214.05KiB, alloc change=0 bytes, cpu time=124.00ms, real time=125.00ms, gc time=0ns 

> CodeTools:-Usage( map( PermPower, L, 3333 ) ):
 

memory used=77.81MiB, alloc change=0 bytes, cpu time=764.00ms, real time=752.00ms, gc time=36.00ms 

 



Bereit für den nächsten Schritt?

Sprechen Sie mit unseren Produktspezialisten über eine kostenlose Demoversion von Maple

*Die Maple-Evaluation ist für Schüler und Studenten bzw. die private Nutzung zurzeit nicht verfügbar.