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.

- InductionTable
- CharRepresentationWords
- PositionClass
- PointsAndRepresentativesOrbits
- DirectSumMat
- DecomposedMat
- IsDiagonalMat
- IsLowerTriangularMat
- IsNormalizing
- SublistUnbnd
- Coefficient
- IntListToString
- DoublePartitionToString

`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.1tt |

1 . . . X.2tt |

. . . 1 X.3tt |

1 . . 1 X.4tt |

. 1 1 1 X.5tt |

` 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 G2tt |

11,2 2,11 ______________________________ phi_{2,1}tt |

` 1 1 `

`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 ]

`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

`PointsAndRepresentativesOrbits( `

`G`[, `m`] )

returns a pair `[orb, rep]` where `orb` is a list of the orbits of the
permutation group `G` on `[ 1..LargestMovedPoint( `

and `G` ) ]`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( `

is replaced by the integer
`G` )`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) ] ] ]

`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`] )

`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 ] ]

`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

`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

`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

`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.

`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)`

.

`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}"

`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

GAP 3.4.4

April 1997