Group Theory - New Features in Maple 2020 - Maplesoft

# Group Theory

In Maple 2020, the Group Theory package has been extended to include new tools for classifying finite groups, more searchable properties for small groups, transitive groups, perfect groups, and Frobenius groups, and new commands for computation and analysis.

 > with( GroupTheory ):

Classification of Finite Simple Groups

• The classification of finite simple groups has been implemented in Maple via the new ClassifyFiniteSimpleGroup command, as well as the introduction of a new CFSG object that serves as a finite simple group classifier. The ClassifyFiniteSimpleGroup command serves to locate a given finite simple group within a description of the classification.

 > c := ClassifyFiniteSimpleGroup( CyclicGroup( 19 ) );

• This produces an object of type CFSG.

 > type( c, ':-CFSG' );

• You can query the CFSG object for information about the simple group and its location within  the classification. The main identifying methods are Family and Parameters. The Family( c ) command locates the given simple group classifier within one of the four main families of finite simple groups (cyclic, alternating, Lie type or sporadic). The Parameters( c ) command further identifies the group within the family.

 > Family( c );

 > Parameters( c );

 > c := ClassifyFiniteSimpleGroup( Alt( 8 ) );

 > Family( c );

 > Parameters( c );

• For groups of Lie type, and for the sporadic finite simple groups, there is also a Subfamily method that further delineates the position of the group within the classification. (For cyclic and alternating groups, the Subfamily method returns the value undefined, as there are no sub-families defined for these types of groups.)

 > c := ClassifyFiniteSimpleGroup( PSU( 3, 3 ) );

 > Family( c );

 > Subfamily( c );

• In the case of a classical group, you can also query the classical sub-family.

 > ClassicalSubfamily( c );

• The parameters for a group of Lie type are the Lie rank and the field size.

 > c := ClassifyFiniteSimpleGroup( PSp( 4, 3 ) );

 > Parameters( c );

• In the case of a classical group, you can also query the dimension of the associated linear group.

 > Dimension( c );

• There is a GroupOrder method that you can use to query the order of the group associated with the classifier.

 > GroupOrder( c );

• In the event that a group is not simple, an exception is raised.

 > ClassifyFiniteSimpleGroup( MathieuGroup( 10 ) );

 Error, (in GroupTheory:-ClassifyFiniteSimpleGroup) group is not simple

• You can use the ClassifyFiniteSimpleGroup command to identify the composition factors of a finite group.

 > G := PerfectGroup( 1920, 1 );

 > IsSimple( G );

 > cs := CompositionSeries( G );

 > inds := [seq]( Index( cs[ i ], cs[ i - 1 ] ), i = 2 .. numelems( cs ) ):

 > map( ClassifyFiniteSimpleGroup, inds );

• Because the identity of a finite simple group is often determined solely by its order (and the fact of its simplicity), you can also pass a positive integer as an argument to the ClassifyFiniteSimpleGroup command.

 > ClassifyFiniteSimpleGroup( 14!/2 );

• This is particularly useful for groups that cannot currently be constructed as such in Maple.

 > ClassifyFiniteSimpleGroup( 91091388821275796002896845335824055117112900038578882103005220458066774174756355172236381528808521951845631824767792833866989192878222394092251827671288376954168134609231184876844237947806050477334460416708128451382476800000 );

• In cases for which there are two non-isomorphic simple groups of the same order, an expression sequence of two CFSG objects is returned, one for each of the simple groups of the given order.

 > ClassifyFiniteSimpleGroup( 2211804011555567123299716393684253115102777246104915803836223275439545886426045766402326760994180464750362624000 );

• The new NumSimpleGroups( n ) command returns the number of simple groups of order n, for a positive integer n.

 > NumSimpleGroups( 1 );

 > NumSimpleGroups( 660 );

 > NumSimpleGroups( 20160 );

• The new IsSimpleNumber command tests whether a positive integer is the order of a finite non-Abelian simple group.

 > IsSimpleNumber( 72 );

 > IsSimpleNumber( 360 );

• You can use the cyclic option to cause the command to include the groups of prime order as well.

 > IsSimpleNumber( 30303030303031 );

 > IsSimpleNumber( 30303030303031, 'cyclic' );

• The new TabulateSimpleGroups command generates a list of pairs of the form [ n, L ], where n is the order of a finite non-abelian simple group, and L is a list of strings providing a brief description of the simple groups of order n, and where n falls within a specified range. A number of options controls which simple groups are considered for inclusion in the resulting list.

 > TabulateSimpleGroups( 1 .. 1000 );

 > TabulateSimpleGroups( 1 .. 10^6, 'minlierank' = 3, 'alternating' = false );

• You can use TabulateSimpleGroups to generate a lot of simple numbers.

 > L := map2( op, 1, TabulateSimpleGroups( 1 .. 10^15 ) ):

• Consider the first digits of these numbers.

 > F := map( n -> iquo( n, 10^(length(n) - 1) ), L ):

• We compute the frequency of each leading digit.

 > A := evalf( [seq]( numboccur( F, i ), i = 1  .. 9 ) / nops( F ) ):

• Now we can compare these frequencies with the distribution of Benford's Law.

 > B := [seq]( log10( 1.0 + 1/i ), i = 1 .. 9 ):

 > use Statistics in   ColumnGraph( [ A, B ], 'legend' = [ "Simple Numbers", "Benford" ], 'offset' = 5/8 ) end use;

• The plot above does suggest that the orders of non-abelian finite simple groups do not follow Benford's Law. We use a -test to verify this, as follows.

 > Statistics:-ChiSquareSuitableModelTest( F, EmpiricalDistribution( [seq](1 .. 9), 'probabilities' = B ), 'bins' = 9, 'summarize' = 'embed' ):

Null Hypothesis:

Sample was drawn from specified probability distribution

Alternative Hypothesis:

Sample was not drawn from specified probability distribution

 Bins Degrees of Freedom Distribution Computed Statistic Computed p-value Critical Value

Result:

Rejected: This statistical test provides evidence that the null hypothesis is false.

• Several new searchable properties have been added to the databases of small groups, transitive groups, perfect groups and Frobenius groups.

• The small groups database now includes the following numeric (integer) properties: frattinilength, orderclassnumber, elementordersum and maxelementorder. The boolean properties homocyclic and elementary have been added as well. You can access these properties by using the SearchSmallGroups command.

• Find the groups of order at most which have precisely two order classes and which are not elementary abelian.

 > L := [SearchSmallGroups]( 'orderclassnumber' = 2, 'elementary' = false );

• Check that they are all groups of prime power order.

 > andmap( IsPGroup @ SmallGroup, L );

• Find the abelian groups in the database with exactly three order classes.

 > L := [SearchSmallGroups]( 'orderclassnumber' = 3, 'abelian' );

• Determine which among them is homocyclic.

 > select( IsHomocyclic @ SmallGroup, L );

• The database of perfect groups has been augmented with the following new properties: compositionlength, maxelementorder, elementordersum, frobenius and perfectorderclasses.

• Use the SearchPerfectGroups command to query the database for groups satisfying combinations of these and other properties.

• The composition lengths of the groups in the database of perfect groups vary. To gain an understanding of how they are distributed, use the form = "count" option together with a visualisation.

 > L := [seq]( i = SearchPerfectGroups( 'compositionlength' = i, 'form' = "count" ), i = 1 .. 12 );

 > Statistics:-PieChart( L );

• Another way to visualise the distribution of groups within the database with respect to a property is to use an accumulated total.

 > A := Array([]):

 > i := 0: do t := SearchPerfectGroups( 'maxelementorder' > ++i, form = "count" ); A ,= t; until t = 0:

 > numelems( A );

 > plots:-pointplot( A );

• You can access additional examples of non-soluble Frobenius groups by locating them in the perfect groups database.

 > SearchPerfectGroups( 'frobenius' );

• Observe that the group with perfect group ID [14520, 1] has a different ID in the database of Frobenius groups.

 > G := PerfectGroup( 14520, 1 ):

 > IdentifyFrobeniusGroup( G );

• The larger Frobenius groups in the perfect groups database do not appear in the database of Frobenius groups, which is currently limited to groups of order at most .

• The database of Frobenius groups, first introduced in Maple 2019, has been augmented to include the following new properties: orderclassnumber, maxelementorder, elementordersum, rank, transitivity, primitive, elementarykernel, homocyclickernel.

• As for the other databases, there is a search command SearchFrobeniusGroups that you can use to query the database for groups with these properties.

• How many Frobenius groups in the database are primitive?

 > SearchFrobeniusGroups( 'primitive', 'form' = "count" );

• Of those, how many have a non-abelian Frobenius complement?

 > SearchFrobeniusGroups( 'primitive', 'abeliancomplement' = false, 'form' = "count" );

 > L := [SearchFrobeniusGroups]( 'transitivity' > 1 ):

 > map( Transitivity @ FrobeniusGroup, L );

New and Updated Commands

• The IsHomocyclic command determines whether a finite permutation group is homocyclic (that is, a direct power of a cyclic group).

 > IsHomocyclic( CyclicGroup( 12 ) );

 > IsHomocyclic( Group( [ Perm( [[1,2]]), Perm([[3,4]]) ] ) );

 > IsHomocyclic( SmallGroup( 144, 2 ) );

 > IsHomocyclic( SmallGroup( 144, 3 ) );

• The new PermGroupRank command computes the rank (number of sub-orbits) of a transitive permutation group.

 > PermGroupRank( Alt( 5 ) );

 > G := DihedralGroup( 5 ):

 > PermGroupRank( G );

 > S := Stabilizer( 1, G ):

 > nops( Orbits( S ) );

• The new GruenbergKegelGraph command computes the Gruenberg-Kegel graph (or prime graph) of a finite group. The vertices of the graph are the prime divisors of the order of the group, and two primes and are adjacent if the group has an element of order .

• Here are the Gruenberg-Kegel graphs for all the sporadic finite simple groups, and the Tits group.

 > Spor := [ MathieuGroup(11), MathieuGroup(12),    MathieuGroup(22), MathieuGroup(23),    MathieuGroup(24), JankoGroup( 1 ),    JankoGroup( 2 ), JankoGroup( 3 ),    JankoGroup( 4 ), ConwayGroup( 1 ),    ConwayGroup( 2 ), ConwayGroup( 3 ),    FischerGroup( 22 ), FischerGroup( 23 ),    FischerGroup( 24 ), HigmanSimsGroup(),    McLaughlinGroup(), HeldGroup(),    RudvalisGroup(), SuzukiGroup(),    ONanGroup(), HaradaNortonGroup(),    LyonsGroup(), ThompsonGroup(),    BabyMonster(), Monster(), TitsGroup() ]:

 > SporNames := map(print_preprocess,Spor):

 > GK := map( GruenbergKegelGraph, Spor ):

 > use GraphTheory in    for G in GK do        HighlightVertex( G, SelfLoops( G ), 'stylesheet' = [ 'shape' = "pentagon", 'color' = "red" ] );        HighlightVertex( G, map( op, select( c -> nops(c)=1, ConnectedComponents( G ) ) ),            'stylesheet' = [ 'shape' = "7gon", 'color' = "green" ] )    end do end use:

 > GK := [seq]( GraphTheory:-DrawGraph( GK[ i ], 'title' = SporNames[ i ] ), i = 1 .. nops( Spor ) ):

 > GK := Matrix( 9, 3, GK ):

 > plots:-display( GK );

• Several new commands related to orders of elements in finite groups have been introduced.

• The OrderClassNumber command returns the number of order classes of a finite group.

 > OrderClassNumber( Symm( 5 ) );

• The MaximumElementOrder command returns the largest order of an element in a finite group.

 > MaximumElementOrder( Alt( 4 ) );

• The ElementOrderSum command returns the sum of the orders of the elements of a finite group.

 > ElementOrderSum( Alt( 4 ) );

• The Suzuki2B2 command constructs a permutation group isomorphic to the Suzuki group , where is an odd power of at most .

 > G := Suzuki2B2( 2 );

 > IsSimple( G );

 > IsFrobeniusGroup( G );

 > IdentifyFrobeniusGroup( G );

 > IsSimple( Suzuki2B2( 128 ) );

• Commands applying to permutations introduced in this release are PermAltSplit, PermRestrict and PermShift.

• The PermShift command replaces each point acted on by a permutation by a point shifted by the indicated amount.

 > p := Perm( [[1,2,3],[4,6]] );

 > PermShift( p, 3 );

• The PermRestrict command returns the restriction of a given permutation to an invariant subset of its domain.

 > PermRestrict( p, {1,2,3} );

• The PermAltSplit command returns true if the conjugacy class of a permutation in a containing symmetric group splits into two classes in the corresponding alternating group.

 > Perm( [[1,2,3]] ) in Alt( 4 );

 > PermAltSplit( Perm( [[1,2,3]] ) );

 > numelems( ConjugacyClass( Perm( [[1,2,3]] ), Symm( 4 ) ) );

 > numelems( ConjugacyClass( Perm( [[1,2,3]] ), Alt( 4 ) ) );

 > Perm( [[1,2],[3,4]] ) in Alt( 4 );

 > PermAltSplit( Perm( [[1,2],[3,4]] ) );

 > numelems( ConjugacyClass( Perm( [[1,2],[3,4]] ), Symm( 4 ) ) );

 > numelems( ConjugacyClass( Perm( [[1,2],[3,4]] ), Alt( 4 ) ) );

• The PerfectGroup constructor and the FrobeniusGroup constructors now accept an argument ID in the form [ order, index ] as well as passing the order and index as separate arguments.

 > G := FrobeniusGroup( [ 4032, 2 ] ):

 > IsElementary( FrobeniusKernel( G ) );

 > PGroupPrime( FrobeniusKernel( G ) );

 > PerfectGroup( [ 60, 1 ], 'form' = "fpgroup" );

Prêt(e) pour l'étape suivante ?

*Ce programme d'évaluation n'est proposé actuellement ni aux étudiants ni aux particuliers.

Achetez: