86 Appendix -- utility functions for the CHEVIE package

The functions described below, used in various parts of the CHEVIE package, are of a general nature and should really be included in other parts of the GAP library. We include them here for the moment for the commodity of the reader.

Subsections

  1. InductionTable
  2. CharRepresentationWords
  3. PositionClass
  4. PointsAndRepresentativesOrbits
  5. DirectSumMat
  6. DecomposedMat
  7. IsDiagonalMat
  8. IsLowerTriangularMat
  9. IsNormalizing
  10. SublistUnbnd
  11. Coefficient
  12. IntListToString
  13. DoublePartitionToString

86.1 InductionTable

InductionTable( W1, W )

InductionTable computes the decomposition of the induced characters from the subgroup W1 into irreducible characters of W. The rows correspond to the characters of the parent group, the columns to those of the subgroup. What is returned is actually a record with several fields: scalar contains the induction table proper, and there is a Display method. The other fields contain labeling information taken from the character tables of W1 and W when it exists.

    gap> W := Group( [ (1,2), (2,3), (3,4) ], () );
    Group( (1,2), (2,3), (3,4) )
    gap> H:=Subgroup( W, [ (1,2), (3,4) ] );
    Subgroup( Group( (1,2), (2,3), (3,4) ), [ (1,2), (3,4) ] )
    gap> W.name := "W";; H.name := "H";; # to avoid warnings
    gap> Display( InductionTable( H, W ) );
        
tt |
 X.1 X.2 X.3 X.4
    ______________________________
    X.1 
tt |
   1   .   .   .
    X.2 
tt |
   .   .   .   1
    X.3 
tt |
   1   .   .   1
    X.4 
tt |
   .   1   1   1
    X.5 
tt | 1 1 1 .

    gap> W := CoxeterGroup( "G", 2 );;
    gap> H := ReflectionSubgroup( W, [ 1, 4 ] );
    ReflectionSubgroup(CoxeterGroup("G", 2), [ 1, 4 ])
    gap> CartanName( H );
    "A1x~A1"
    gap> t := InductionTable( H, W );       
    InductionTable( ReflectionSubgroup(CoxeterGroup("G", 2), 
    [ 1, 4 ]), CoxeterGroup("G", 2))
    gap> Display( t );
                
tt |
 11,11 11,2 2,11 2,2
    __________________________________________
    phi_{1,0}   
tt |
     .    .    .   1
    phi_{1,6}   
tt |
     1    .    .   .
    phi_{1,3}'  
tt |
     .    1    .   .
    phi_{1,3}'' 
tt |
     .    .    1   .
    phi_{2,1}   
tt |
     .    1    1   .
    phi_{2,2}   
tt | 1 . . 1

If one does not want to see the whole induction table, one can specify the characters of the subgroup and of the parent group by giving a second argument to Display. This second argument is a record with optional components charsGroup and charsSubgroup, to which one has to assign the lists of rows and columns which should be printed.

    gap> Display( t,rec( charsGroup := [5], charsSubgroup := [2,3] ) );
    Induction from A1x~A1 into G2
              
tt |
 11,2 2,11
    ______________________________
    phi_{2,1} 
tt | 1 1

86.2 CharRepresentationWords

CharRepresentationWords( rep , elts )

given a list rep of matrices corresponding to generators and a list elts of words in the generators it returns the list of traces of the corresponding representation on the elements in elts.

    gap> H := Hecke(CoxeterGroup( "F", 4 ));;
    gap> r := ChevieClassInfo( Group( H ) ).classtext;;
    gap> t := HeckeReflectionRepresentation( H );;
    gap> CharRepresentationWords( t, r );
    [ 4, -4, 0, 1, -1, 0, 1, -1, -2, 2, 0, 2, -2, -1, 1, 0, 2, -2, -1, 1, 
      0, 0, 2, -2, 0 ] 

86.3 PositionClass

PositionClass( G, c )

G must be a domain for which ConjugacyClasses is defined and c must be an element of G. This functions returns a positive integer i such that c in ConjugacyClasses( G )[i].

    gap> G := Group( (1,2)(3,4), (1,2,3,4,5) );;
    gap> ConjugacyClasses( G );
    [ ConjugacyClass( Group( (1,2)(3,4), (1,2,3,4,5) ), () ), 
      ConjugacyClass( Group( (1,2)(3,4), (1,2,3,4,5) ), (3,4,5) ), 
      ConjugacyClass( Group( (1,2)(3,4), (1,2,3,4,5) ), (2,3)(4,5) ), 
      ConjugacyClass( Group( (1,2)(3,4), (1,2,3,4,5) ), (1,2,3,4,5) ), 
      ConjugacyClass( Group( (1,2)(3,4), (1,2,3,4,5) ), (1,2,3,5,4) ) ]
    gap>  g := Random( G );
    (1,2,5,4,3)
    gap> PositionClass( G, g );
    5 

86.4 PointsAndRepresentativesOrbits

PointsAndRepresentativesOrbits( G[, m] )

returns a pair [orb, rep] where orb is a list of the orbits of the permutation group G on [ 1..LargestMovedPoint( G ) ] and rep is a list of list of elements of G such that rep[i][j] applied to orb[i][1] yields orb[i][j] for all i,j. If the optional argument m is given, then LargestMovedPoint( G ) is replaced by the integer m.

    gap> G := Group( (1,7)(2,3)(5,6)(8,9)(11,12), 
    >                (1,5)(2,8)(3,4)(7,11)(9,10) );;
    gap> PointsAndRepresentativesOrbits( G );
    [ [ [ 1, 7, 5, 11, 6, 12 ], [ 2, 3, 8, 4, 9, 10 ] ], 
      [ [ (), ( 1, 7)( 2, 3)( 5, 6)( 8, 9)(11,12), 
              ( 1, 5)( 2, 8)( 3, 4)( 7,11)( 9,10), 
              ( 1,11,12, 7, 5, 6)( 2, 4, 3, 8,10, 9), 
              ( 1, 6, 5, 7,12,11)( 2, 9,10, 8, 3, 4), 
              ( 1,12)( 2, 4)( 3, 9)( 6, 7)( 8,10) ], 
          [ (), ( 1, 7)( 2, 3)( 5, 6)( 8, 9)(11,12), 
              ( 1, 5)( 2, 8)( 3, 4)( 7,11)( 9,10), 
              ( 1,11,12, 7, 5, 6)( 2, 4, 3, 8,10, 9), 
              ( 1, 6, 5, 7,12,11)( 2, 9,10, 8, 3, 4), 
              ( 1, 6)( 2,10)( 4, 8)( 5,11)( 7,12) ] ] ] 

86.5 DirectSumMat

DirectSumMat( mat1, ... , matn )

returns the block diagonal direct sum of the matrices mat1, ldots, matn.

    gap> C1 := [ [   2,  -1,   0,   0 ],
    >            [  -1,   2,  -1,   0 ],
    >            [   0,  -1,   2,  -1 ],
    >            [   0,   0,  -1,   2 ] ];;
    gap> C2 := [ [   2,   0,  -1,   0 ],
    >            [   0,   2,  -1,   0 ],
    >            [  -1,  -1,   2,  -1 ],
    >            [   0,   0,  -1,   2 ] ];;
    gap> d := DirectSumMat( C1, C2 );;
    gap> PrintArray( d );
    [ [   2,  -1,   0,   0,   0,   0,   0,   0 ],
      [  -1,   2,  -1,   0,   0,   0,   0,   0 ],
      [   0,  -1,   2,  -1,   0,   0,   0,   0 ],
      [   0,   0,  -1,   2,   0,   0,   0,   0 ],
      [   0,   0,   0,   0,   2,   0,  -1,   0 ],
      [   0,   0,   0,   0,   0,   2,  -1,   0 ],
      [   0,   0,   0,   0,  -1,  -1,   2,  -1 ],
      [   0,   0,   0,   0,   0,   0,  -1,   2 ] ] 

One can also use a computed list of matrices as an argument; the function call then reads ApplyFunc(DirectSumMat, [mat1, ... , matn] ).

86.6 DecomposedMat

DecomposedMat( mat )

finds if the square matrix mat admits a block decomposition. Define a graph G with vertices [1..Length(mat)] and with an edge between i and j if either mat[i][j] or mat[j][i] is non-zero. DecomposedMat return a list of lists l such that l[1],l[2], etc.. are the vertices in each connected component of G. In other words, the matrices mat{l[1]}{l[1]},mat{l[2]}{l[2]}, etc... are blocks of the matrix mat.

    gap> m := [ [  0,  0,  0,  1 ],
    >           [  0,  0,  1,  0 ],
    >           [  0,  1,  0,  0 ],
    >           [  1,  0,  0,  0 ] ];;
    gap> DecomposedMat( m );
    [ [ 1, 4 ], [ 2, 3 ] ]
    gap> PrintArray( m{[ 1, 4 ]}{[ 1, 4 ]});
    [ [  0,  1 ],
      [  1,  0 ] ] 

86.7 IsDiagonalMat

IsDiagonalMat( mat )

mat must be a matrix. This function returns true if all entries mat[i][j] with i<j are equal to 0*mat[i][j] and false otherwise.

    gap> a := [ [ 1, 2 ], [ 3, 1 ] ];;
    gap> IsDiagonalMat( a );
    false 

86.8 IsLowerTriangularMat

IsLowerTriangularMat( mat )

mat must be a matrix. This function returns true if all entries mat[i][j] with ji are equal to 0*mat[i][j] and false otherwise.

    gap> a := [ [ 1, 2 ], [ 3, 1 ] ];;
    gap> IsLowerTriangularMat( a );
    false
    gap> a[1][2] := 0;;
    gap> IsLowerTriangularMat( a );
    true 

86.9 IsNormalizing

IsNormalizing( lst, mat )

returns true or false according to whether the matrix mat leaves the vectors in lst as a set invariant, i.e., Set(l * M) = Set( l ).

    gap> a := [ [ 1, 2 ], [ 3, 1 ] ];;
    gap> l := [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ], [ 0, 0 ] ];;
    gap> l * a;
    [ [ 1, 2 ], [ 3, 1 ], [ 4, 3 ], [ 0, 0 ] ]
    gap> IsNormalizing( l, a );
    false 

86.10 SublistUnbnd

SublistUnbnd( l, ind )

Sublist of a list with possibly unbound entries. The writing of this function was prompted by the fact that if l has some unbound entries, l{ind} returns an error message instead of doing what is expected (which is what this routine does).

    gap> l := [ 1, , 2, , , 3 ];;
    gap> SublistUnbnd( l, [ 1..4 ] );
    [ 1,, 2 ] 

If you use l{[ 1..4 ]}, you get an error message.

86.11 Coefficient

Coefficient( a, b )

generic routine which looks if a has a Coefficient method in its operations record and then returns a.operations.Coefficient(a,b).

86.12 IntListToString

IntListToString( part, [brackets] )

part must be a list of positive integers. If all of them are smaller than 10 then a string of digits corresponding to the entries of part is returned. If an entry is geq 10 then the elements of part are converted to strings, concatenated with separating commas and the result surrounded by brackets. By default () brackets are used. This may be changed by giving as second argument a length two string specifying another kind of brackets.

    gap> IntListToString( [ 4, 2, 2, 1, 1 ] );
    "42211"
    gap> IntListToString( [ 14, 2, 2, 1, 1 ] );
    "(14,2,2,1,1)"
    gap> IntListToString( [ 14, 2, 2, 1, 1 ], "{}" );
    "{14,2,2,1,1}" 

86.13 DoublePartitionToString

DoublePartitionToString( pair )

converts the double partition pair to a string where the two partitions are separated by a point.

    gap> d := DoublePartitions( 3 );
    [ [ [ 1 ], [ 1, 1 ] ], [ [ 1 ], [ 2 ] ], [ [ 1, 1 ], [ 1 ] ], 
      [ [ 1, 1, 1 ], [  ] ], [ [ 2 ], [ 1 ] ], [ [ 2, 1 ], [  ] ], 
      [ [ 3 ], [  ] ], [ [  ], [ 1, 1, 1 ] ], [ [  ], [ 2, 1 ] ], 
      [ [  ], [ 3 ] ] ]
    gap> for i in d do 
    >      Print( DoublePartitionToString( i ),"   "); 
    > od; Print("\n");
    1.11   1.2   11.1   111.   2.1   21.   3.   .111   .21   .3   

Previous Up Next
Index

GAP 3.4.4
April 1997