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=246⁢320⁢59⁢76⁢112⁢133⁢17⁢19⁢23⁢29⁢31⁢41⁢47⁢59⁢71
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();
G≔𝕄
Maple "knows" various facts about 𝕄.
GroupOrder( G );
808017424794512875886459904961710757005754368000000000
IsSimple( G );
true
MinPermRepDegree( G );
97239461142009186000
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 B22⁡q 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 );
G≔Sz2048
While Maple knows certain facts about symbolic groups, it is not possible to perform operations that inherently require access to group elements.
36011213418659840
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 );
G≔Dn
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 );
FAIL
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;
false
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 PSL⁡n,q as follows.
G := PSL( n, q );
G≔PSLn,q
The type of information that Maple knows about a symbolic group varies from one group to another.
qn2⁢∏k=1n−1⁡qk+1−1igcd⁡n,q−1
G := PSU( 3, q );
G≔PSU3,q
q3⁢q2−1⁢q3+1igcd⁡3,q+1
Maple may have only partial information for some operations.
ClassNumber( PSL( 5, q ) );
7+q4+q3+q2−8igcd⁡5,q−1
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 ) );
n2+3n::evenn2+32otherwise
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 ) ) );
c≔7⁢k+722⁢k+1::evenk+2otherwise
simplify( c ) assuming k :: posint;
7⁢k+14
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 );
G≔PSp4,q
G2 := eval( G, q = 2 );
G2≔PSp4,2
type( G2, 'PermutationGroup' );
ord := GroupOrder( G );
ord≔q4⁢q2−1⁢q4−1igcd⁡2,q−1
GroupOrder( G2 );
720
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 );
PGU2,q
eval( PGU( n, q ), q = 3 );
PGUn,3
eval( PGU( n, q ), [n = 2, q = 3] );
PGL2,3
See Also
GroupTheory
Download Help Document