GroupTheory/tutorials/WorkingWithSymbolicGroups - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : GroupTheory/tutorials/WorkingWithSymbolicGroups

Working with Symbolic Groups


Maple's GroupTheory package features the ability to construct symbolic groups, which are used to represent groups that may otherwise currently have no other computer implementation.

Typically, a symbolic group is used to represent a group that is too large to represent concretely, or that depend upon one or more unspecified numeric parameters.

Examples of the former situation include the larger of the sporadic finite simple groups. For the latter situation, there are symbolic group representations for many families of groups, such as symmetric or dihedral groups, depending on an (integer) parameter which you can specify symbolically.

with( GroupTheory ):

For instance, the Monster simple group 𝕄 has order equal to808017424794512875886459904961710757005754368000000000=2463205976112133171923293141475971 

But, importantly, 𝕄 cannot be represented as a permutation group on fewer than 97239461142009186000 points and the smallest dimension of a faithful linear representation over any field is 196882. Thus, computing with elements of 𝕄 is difficult, and requires bespoke techniques.

In Maple, 𝕄 is represented as a symbolic group.

G := Monster();



Maple "knows" various facts about 𝕄.

GroupOrder( G );



IsSimple( G );



MinPermRepDegree( G );



For some groups, a concrete implementation as, for instance, a permutation group is available only for small values of a parameter upon which the group depends. For instance, the group B22q is available as a permutation group only for values of q not exceeding 512. For larger values of q, a symbolic group is returned.

G := Suzuki2B2( 2048 );



While Maple knows certain facts about symbolic groups, it is not possible to perform operations that inherently require access to group elements.

GroupOrder( G );



RandomElement( G );

Error, (in GroupTheory:-RandomElement) cannot compute random elements of a symbolic group

An example of a group that can be defined by a symbolic parameter is a dihedral group.

G := DihedralGroup( n );



Notice that the degree parameter n is an unassigned symbol with no numeric value. Nevertheless, Maple can deduce various facts about such groups.

IsFinite( G );



IsSoluble( G );



With insufficient information about the parameter, Maple is unable to deduce anything in this case:

IsNilpotent( G );



However, you can supply additional information using the assume facility and, in this situation, when enough information is available, Maple can determine an outcome.

IsNilpotent( DihedralGroup( 2^(3*k + 1) ) ) assuming k :: posint;



IsNilpotent( DihedralGroup( 3 * 2^(3*k + 1) ) ) assuming k :: posint;



Symbolic groups may depend upon more than one parameter and, depending upon the group in question, one or more parameters may be specified symbolically. For example, you can construct a symbolic group representing the projective special linear group PSLn,q  as follows.

G := PSL( n, q );



The type of information that Maple knows about a symbolic group varies from one group to another.

GroupOrder( G );



G := PSU( 3, q );



GroupOrder( G );



Maple may have only partial information for some operations.

ClassNumber( PSL( 5, q ) );



ClassNumber( PSL( n, q ) );

Error, (in GroupTheory:-ClassNumber) cannot compute the class number for PSL(n,q)

In certain cases, a piecewise result may be returned for certain operations on a symbolic group.

ClassNumber( DihedralGroup( n ) );



Since a symbolic expression is normally returned for invariants that can be computed for groups depending upon one or more symbolic parameters, you can use Maple's symbolic facilities to further manipulate the results.

c := ClassNumber( DirectProduct( QuaternionGroup( 4 ), DihedralGroup( 2*k + 1 ) ) );



simplify( c ) assuming k :: posint;



In the event that a concrete implementation (such as a permutation group) is available for specific numeric values of a parameter, you can use the two-argument form of eval to instantiate the parameter. For example,

G := PSp( 4, q );



G2 := eval( G, q = 2 );



type( G2, 'PermutationGroup' );



ord := GroupOrder( G );



GroupOrder( G2 );



eval( ord, q = 2 );



For symbolic groups that depend upon more than one symbolic parameter, you can evaluate the symbolic group at just one, or at several of the parameters. If one or more parameters remain uninstantiated, then the result is another symbolic group, depending upon fewer parameters.

eval( PGU( n, q ), n = 2 );



eval( PGU( n, q ), q = 3 );



eval( PGU( n, q ), [n = 2, q = 3] );



See Also