#############################################################################
##
#A  genVhelp             CHEVIE library                                      
##
#Y  Copyright 1992--1993,  Lehrstuhl D f"ur Mathematik,    RWTH Aachen,   and
#Y                         IWR   der   Universit"at    Heidelberg,   Germany.
##
##################################################################
##
## Online help for CHEVIE
##
 
`help/text/CHEVIE`:=TEXT(
# `Information about the CHEVIE-System:`,
# `Hier noch blabla?`,
``,
`- Available procedures are:`,
`       CentOrd            CharDeg            ClassMult`,
`       Copy               CopyChar           CopyClass`,
`       GenCharTab         GreenFunTab        GreenFunctionsA`,
`       GreenFunctions2A   Norm               NrChars`,
`       NrClasses          Omega              Ortho2Norm`,
`       Ortho2Scalar       PrintCharParam     PrintClassParam`,
`       PrintInfoChar      PrintInfoClass     PrintInfoTab`,
`       PrintToTeX         PrintVal           Scalar`,
`       SpecCharParam      SpecClassParam     Status`,
`       Tensor`,
``,
`- Type ?proc or help(proc) for some help with a particular procedure proc.`,
``,
`- You find more detailed and more complete information in the manual, which`,
`  is obtained by printing the file 'chevie/doc/chevie.dvi'. (If this cannot`,
`  be printed, try 'amslatex chevie/doc/chevie' first.)`,
``,
`- All MAPLE functions are available.`
):

`help/text/GEW`:=TEXT(
``,
`CHEVIE HELP FOR: The "EW, GEW"  notation`,
` `,
`SYNOPSIS: `,
`"EW" respectively "GEW" stand for "root of unity" respectively`,
`"generic root of unity". `,
``,
`  EWi := exp( 2*Pi*I/i ), i an integer`,
``,
`GEWZi := exp( 2*Pi*I/( q^i - 1 ) ), i an integer`,
``,
`GEWYi := exp( 2*Pi*I/( q^i + 1 ) ), i an integer`,
``,
`GEWCi := exp( 2*Pi*I/( Phi_i(q) ), i an integer, `,
`                                   Phi_i := i-th cyclotomic polynomial`,
``,
`Various combinations and variants of these are used according to`,
`the following list.`,
``,
`name       which root                       pretty printed name`,
`_________________________________________________________________`,
``,
`GEWZ1      q-1                              ``\\zeta_1```,
`GEWY1      q+1                              ``\\xi_1```,
`GEW2Z1     2*(q-1)                          ``\\rho_1```,
`GEWZ2      q^2-1                            ``\\zeta_2`` `,
`GEWY2      q^2+1                            ``\\xi_2`` `,
`GEWC3      q^2+q+1                          ``\\varphi_3`` `,
`GEWC6      q^2-q+1                          ``\\varphi_6`` `,
`GEWC12     q^4-q^2+1                        ``\\varphi_{12}`` `,
`GEWC8p     q^2+sqrt(2)*q+1                  ``\\varphi_{8}\'`` `,
`GEWC8pp    q^2-sqrt(2)*q+1                  ``\\varphi_{8}\'\'`` `,
`GEWC8pZ2   (q^2+sqrt(2)*q+1)*(q^2-1)        ``\\psi_{8}\'`` `,
`GEWC8ppZ2  (q^2-sqrt(2)*q+1)*(q^2-1)        ``\\psi_{8}\'\'`` `,
`GEWC12p    q^2-sqrt(3)*q+1                  ``\\varphi_{12}\'`` `,
`GEWC12pp   q^2+sqrt(3)*q+1                  ``\\varphi_{12}\'\'`` `,
`GEWC24p    q^4+sqrt(2)*q^3+q^2+sqrt(2)*q+1  ``\\varphi_{24}\'`` `,
`GEWC24pp   q^4-sqrt(2)*q^3+q^2-sqrt(2)*q+1  ``\\varphi_{24}\'\'`` `,
`GEWZ1Y2    (q-1)*(q^2+1)                    ``\\eta_2`` `,
`GEWZ3      q^3-1                            ``\\zeta_3`` `,
`GEWY3      q^3+1                            ``\\xi_3`` `,
`GEWZ1Y3    (q-1)*(q^3+1)                    ``\\eta_3`` `,
`GEWY3Z1    (q-1)*(q^3+1)                    ``\\eta_3`` `,
`GEWY1Z3    (q+1)*(q^3-1)                    ``\\mu_3`` `,
`GEWZ3Y1    (q+1)*(q^3-1)                    ``\\mu_3`` `,
`GEWZ4      q^4-1                            ``\\zeta_4`` `,
`GEWY4      q^4+1                            ``\\xi_4```
    ):

`help/text/EW1`:=TEXT(
``,
`- see GEW`
):
 
`help/text/EW2`:=TEXT(
``,
`- see GEW`
):
 
`help/text/EW3`:=TEXT(
``,
`- see GEW`
):
 
`help/text/EW4`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWZ1`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWZ2`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWZ3`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWY1`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWY2`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWC1`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWC2`:=TEXT(
``,
`- see GEW`
):
 
`help/text/GEWC3`:=TEXT(
``,
`- see GEW`
):

`help/text/GEWC6`:=TEXT(
``,
`- see GEW`
):

`help/text/Exceptions`:=TEXT(
``,
`CHEVIE HELP FOR: The "Possible Exceptions" message`,
` `,
`SYNOPSIS: `,
`CHEVIE does generic calculations, which may not be valid for some`,
`special values of the parameters. The possible exceptions are`,
`printed as a set of lists of the form [ expr, poly ], where`,
`expr is an expression in the parameters and poly a polynomial in q.`,
``,
`The calculations are correct for all parameter combinations (inside the`,
`allowed range of the parameters), except possibly for those, where`,
`poly divides expr.`,
``,
`EXAMPLE:`,
`Possible Exceptions:     {[uU-vV, q+1], [uU-wW, q+1], [vV-wW, q+1]}`,
``,
`The calculations leading to the above message are valid for all`,
`triples (uU,vV,wW) of parameters except possibly for those where`,
`q + 1 divides one of uU - vV or uU - wW or vV - wW.`
):

`help/text/ClassMult`:=TEXT(
``,
`CHEVIE FUNCTION: ClassMult`,
` `,
`CALLING SEQUENCE: `,
`  ClassMult( t )`,
`  ClassMult( t, l1, l2, l3 )`,
`  ClassMult( t, l1, l2 )`,
`  ClassMult( t, l1 )`,
`  ClassMult( t, i1, i2, i3 )`,
``,
`PARAMETERS:`,
`     t               -- generic character tables`,
`     l1, l2, l3      -- lists of integers`,
`     i1, i2, i3      -- integers`,
``,
`SYNOPSIS: `,
`- Calculates the (generic) class multiplication constants of the`,
`  class types of table t. `,
``,
`- A message "Possible Exceptions" informs you about those values of `,
`  the class parameters, for which the calculation is not valid.`,
`  In the message, the integer i, i = 1, 2, 3, is appended to the`,
`  class parameters of the factor i going into the computation of the`,
`  multiplication constant.`,
``,
`- The additional parameters of the function, if present, specify the `,
`  class types, for which the multiplication constants are calculated.`,
`  Omitted lists are interpreted as full lists.`,
``,
`- The first four forms of the function only print the results but return`,
`  nothing. If the last three parameters are integers i1, i2, i3, then a `,
`  list with two entries is returned. The first entry is the (generic) `,
`  class multiplication constant of the class types i1, i2, i3, the second `,
`  entry the set of possible exceptions.`,
``,
`EXAMPLE:`,
`> ClassMult(``SL2.0``,[2],[2],[3..4]);`,
`Possible Exceptions:     {[aA3, q-1]}`,
`ClassMult_SL2.0(2,2,3)=`,
`                                     q - 1`,
``,
``,
`Possible Exceptions:     {[aA3, q+1]}`,
`ClassMult_SL2.0(2,2,4)=`,
`                                     q + 1`,
``,
``,
`> c223 := ClassMult(``SL2.0``,2,2,3):`,
`> c223;`,
``,
`                            [q - 1, {[aA3, q - 1]}]`,
``,
`> c332 := ClassMult(``SL2.0``,3,3,2):`,
`> c332;`,
``,
`                [q, {[- aA2 + aA1, q - 1], [aA2 + aA1, q - 1]}]`,
``,
`SEE ALSO:`,
`Copy, CopyClass, SpecClassParam, Tensor, Exceptions, CHEVIE (for an overview)`
    ):

`help/text/CopyChar`:=TEXT(
``,
`CHEVIE FUNCTION: CopyChar`,
` `,
`CALLING SEQUENCE: `,
`  CopyChar( t1, t2 ) `,
`  CopyChar( t1, t2, l )  `,
`  CopyChar( t1, t2, i )  `,
``,
`PARAMETERS:`,
`     t1, t2          -- generic character tables or`,
`                        tables of Green functions`,
`     l               -- list of integers`,
`     i               -- integer`,
``,
`SYNOPSIS: `,
`- Appends the character types or Green functions of table t1 to table t2.`,
`  This table must be present and must have enough rows.`,
``,
`- The third parameter, if present, specifies the character `,
`  type(s) to be copied.`,
``,
`EXAMPLE:`,
`> Copy(GU3,new,[],[]);`,
`> CopyChar(GU3,new,[2,3,8]);`,
`> Status(new);`,
` `,
`Status of   new`,
` `,
`=======================================================`,
`Order                      :   q^3*(q+1)^3*(q-1)*(q^2-q+1)`,
`Number of character types  :   3`,
`Number of rows available   :   8`,
`Number of class types      :   8`,
`Number of columns available:   8`,
`> CopyChar(GU3,new);`,
`Error, (in CopyChar) Second table too small: Enlarge with "Copy"`,
``,
`SEE ALSO:`,
`Copy, CopyClass, CHEVIE (for an overview)`,
``
    ):

`help/text/CopyClass`:=TEXT(
``,
`CHEVIE FUNCTION: CopyClass`,
` `,
`CALLING SEQUENCE: `,
`  CopyClass( t1, t2 ) `,
`  CopyClass( t1, t2, l )  `,
`  CopyClass( t1, t2, i )  `,
``,
`PARAMETERS:`,
`     t1, t2          -- generic character tables or`,
`                        tables of Green functions`,
`     l               -- list of integers `,
`     i               -- integer`,
` `,
`SYNOPSIS:`,
`- Appends the class types (columns) of table t1 to table t2.`,
`  This table must be present and must have enough columns.`,
``,
`- The third parameter, if present, specifies the class `,
`  type(s) to be copied.`,
``,
`EXAMPLE:`,
`> Copy(GU3,new,[],[]); `,
`> CopyClass(GU3,new,8);`,
`> Status(new);`,
` `,
`Status of   new`,
` `,
`=======================================================`,
`Order                      :   0`,
`Number of character types  :   8`,
`Number of rows available   :   8`,
`Number of class types      :   1`,
`Number of columns available:   8`,
``,
`SEE ALSO:`,
`Copy, CopyClass, CHEVIE (for an overview)`
    ):

`help/text/Copy`:=TEXT(
``,
`CHEVIE FUNCTION: Copy`,
``,
`CALLING SEQUENCE: `,
`  Copy( ta, tn, l1, l2, 'ROWS' + n, 'COLS' + m )   `,
``,
`PARAMETERS:`,
`     ta, tn          -- generic character tables or`,
`                        tables of Green functions`,
`     l1, l2          -- integers or lists of integers`,
`     n, m            -- integers`,
``,
`SYNOPSIS: `,
`- Creates a copy tn of table ta.`,
``,
`- The last four parameters are optional. They may appear in any order.`,
``,
`- The two parameters l1, l2 specify the character types respectively `,
`  class types to be copied. If just one of these parameters is present, `,
`  it will refer to the character types. `,
`  `,
`- The remaining two parameters are used to increase the number of rows `,
`  repectively the number of columns of the table tn. If 'ROWS' + n is `,
`  present, tn will have n more rows available than ta. Similarly, the `,
`  number of columns available for tn is increased by m, if the parameter`,
`  'COLS' + m is given. The integers m and n may be negative. Then the`,
`  number of columns respectively rows is decreased.`,
``,
`- Please note the quotes in 'ROWS' + n, 'COLS' + m.`,
` `,
`EXAMPLE:`,
`> Copy(GU3,new,[],[],'ROWS' + 5);`,
`> Status(new);`,
` `,
`Status of   new`,
` `,
`=======================================================`,
`Order                      :   q^3*(q+1)^3*(q-1)*(q^2-q+1)`,
`Number of character types  :   0`,
`Number of rows available   :   13`,
`Number of class types      :   0`,
`Number of columns available:   8`,
`> Copy(GU3,new1,1,[1..4],'COLS' + 2);`,
`> Status(new1);`,
` `,
`Status of   new1`,
` `,
`=======================================================`,
`Order                      :   q^3*(q+1)^3*(q-1)*(q^2-q+1)`,
`Number of character types  :   1`,
`Number of rows available   :   8`,
`Number of class types      :   4`,
`Number of columns available:   10`,
`> PrintVal(new1);`,
``,
`clt   Value of character type    1    on class type clt`,
` `,
`1   GEWY1^(3*uU*kK)`,
`2   GEWY1^(3*uU*kK)`,
`3   GEWY1^(3*uU*kK)`,
`4   GEWY1^(2*uU*kK+lL*uU)`,
``,
`SEE ALSO:`,
`CopyChar, CopyClass, CHEVIE (for an overview)`
    ):

`help/text/GenCharTab`:=TEXT(
``,
`CHEVIE FUNCTION: GenCharTab`,
``,
`CALLING SEQUENCE:`,
`  GenCharTab( f ) `,
``,
`PARAMETERS:`,
`     f      -- file name (string)`,
``,
`SYNOPSIS:`,
`- Reads the generic character table stored on the file f. The file `,
`  name f indicates the series of groups of Lie type of which the generic `,
`  character table is stored on f. The MAPLE array containing the generic`,
`  table also has the name f.`,
``,
`- The MAPLE procedures needed to work with the generic table are also read.`,
``,
`- After reading the generic table, MAPLE assigns the array containing`,
`  the character table to the variable g. If you do not like this name, `,
`  change it by typing:`,
``,
`                        newname := f;`,
``,
`- To find out which files are available, call the function with no parameter.`,
`  `,
`EXAMPLE:`,
`> GenCharTab(``GL3``);`,
``,
`**************************************************************************`,
`*                                                                        *`,
`*                                                                        *`,
`*                   Generic Character Table of GL_3(q)                   *`,
`*                                                                        *`,
`*                                                                        *`,
`**************************************************************************`,
`                                  g := ``GL3```,
``,
`> GenCharTab();`,
`The following generic character tables are available:`,
``,
`GU3      PGU3.2   PGU3.n2  PSU3.n2  SU3.2    SU3.n2`,
`2B2  Sz`,
`2F4  Ree`,
`2G2  ree`,
`3D4.0  3D4.1`,
`GL2     GU2     PGL2.0  PGL2.1  PSL2.0  PSL2.1  PSL2.3  SL2.0   SL2.1`,
`GL3      PGL3.1   PGL3.n1  PSL3.n1  SL3.1    SL3.n1`,
`Sp4.0      uniCSp4.1`,
`CSp6.1     CSp6_1.m   Sp6.0      Sp6_0.m    uniCSp6.1  uniSp6.0`,
`uniCSpin8.1  uniSpin8.0`,
`G2.01  G2.02  G2.10  G2.11  G2.12`,
``,
`SEE ALSO:`,
`GreenFunTab, CHEVIE (for an overview)`
    ):

`help/text/GreenFunTab`:=TEXT(
``,
`CHEVIE FUNCTION: GreenFunTab`,
``,
`CALLING SEQUENCE:`,
`  GreenFunTab( f ) `,
``,
`PARAMETERS:`,
`     f      -- file name (string)`,
``,
`SYNOPSIS:`,
`- Reads the table of Green functions stored on the file f. The file`,
`  name f indicates the series of groups of Lie type, of which the Green`,
`  functions are stored on f. The MAPLE array containing the Green functions`,
`  has the name f.green. `,
``,
`- After reading the table of Green functions, MAPLE assigns the array `,
`  containing the functions to the variable g. If you do not like this name,`,
`  change it by typing:`,
``,
`                        newname := f;`,
``,
`- To find out which files are available, call the function with no parameter.`,
``,
`EXAMPLE:`,
` `,
`> GreenFunTab(``GL5``);`,
`**************************************************************************`,
`*                                                                        *`,
`*                                                                        *`,
`*                    Green Functions of GL_5(q)                          *`,
`*                                                                        *`,
`*                                                                        *`,
`**************************************************************************`,
`                                g := ``GL5green```,
``,
`SEE ALSO:`,
`GenCharTab, CHEVIE (for an overview)`
    ):

`help/text/Norm`:=TEXT(
``,
`CHEVIE FUNCTION: Norm `,
` `,
`CALLING SEQUENCE: `,
`  Norm( t )`,
`  Norm( t, l )`,
`  Norm( t, i )  `,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Calculates the (generic) norms of the character types of table t. `,
``,
`- If the second argument is a list l, only the norms of the character `,
`  types specified by l are calculated.`,
``,
`- A message "Possible Exceptions" informs you about those values of `,
`  the parameters, for which the calculation is not valid.`,
``,
`- The first two forms of the function only print the results but return`,
`  nothing. If the second parameter is an integer i, then a list with two`,
`  entries is returned. The first entry is the (generic) norm of the `,
`  character type i, the second entry the set of possible exceptions.`,
``,
`EXAMPLE:`,
`> Norm(GL3,[6]);`,
`Possible Exceptions:     {[lL-nN, q-1], [nN-mM, q-1], [lL-mM, q-1]}`,
`Norm_GL3(6)=`,
`                                       1`,
``,
``,
`> n := Norm(GL3,6):`,
`> n;`,
``,
`          [1, {[lL - nN, q - 1], [nN - mM, q - 1], [lL - mM, q - 1]}]`,
``,
``,
`SEE ALSO:`,
`Orhto2Norm, Scalar, Ortho2Scalar, Exceptions, CHEVIE (for an overview)`
    ):

`help/text/Omega`:=TEXT(
``,
`CHEVIE FUNCTION: Omega`,
` `,
`CALLING SEQUENCE: `,
`  Omega( t1, t2 )  `,
`  Omega( t1, l, t2 ) `,
`  Omega( t1, i, t2 ) `,
``,
`PARAMETERS:`,
`     t1, t2      -- generic character tables`,
`     l           -- list of integers`,
`     i           -- integer`,
``,
`SYNOPSIS: `,
`- Calculates the (generic) central characters corresponding `,
`  to the character types of t1 and writes them onto t2. `,
`  Table t2 must be present and have enough rows available.`,
``,
`- If the parameter l or i is present, then only the central `,
`  characters corresponding to the character types specified`,
`  by l or i are computed. `,
``,
`EXAMPLE:`,
`> Copy(``SL2.0``,cen,[],[]);`,
`> Omega(``SL2.0``,cen);`,
`> PrintVal(cen,[1,2]);`,
``,
`clt   Value of character type    1    on class type clt`,
``,
`1   1`,
`2   (q-1)*(q+1)`,
`3   q*(q+1)`,
`4   q*(q-1)`,
``,
`clt   Value of character type    2    on class type clt`,
``,
`1   1`,
`2   0`,
`3   q+1`,
`4   -q+1`,
``,
`SEE ALSO:`,
`Copy, CHEVIE (for an overview)`
    ):

`help/text/Ortho2Norm`:=TEXT(
``,
`CHEVIE FUNCTION: Ortho2Norm`,
` `,
`CALLING SEQUENCE: `,
`  Ortho2Norm( t )`,
`  Ortho2Norm( t, l )`,
`  Ortho2Norm( t, i )  `,
``,
`PARAMETERS: `,
`     t      -- generic character table `,
`     l      -- list of integers`,
`     i      -- integer `,
` `,
`SYNOPSIS: `,
`- Calculates the (generic) norms of the class types of table`,
`  t. If the second argument is a list l, only the norms `,
`  of the class types specified by l are calculated.`,
`  A message "Possible Exceptions" informs you about those`,
`  values of the parameters, for which the calculation is not valid.`,
``,
`- The first two forms of the function only print the results but return`,
`  nothing. If the second parameter is an integer i, then a list with two`,
`  entries is returned. The first entry is the (generic) column norm of `,
`  class type i, the second entry the set of possible exceptions.`,
``,
`EXAMPLE:`,
`> Ortho2Norm(GL3,[8]);`,
`Possible Exceptions:     {[aA*q, q^2+q+1], [aA*q+aA, q^2+q+1]}`,
`Ortho2Norm_GL3(8)=`,
`                                       1`,
``,
``,
`> o2 := Ortho2Norm(GL3,8):`,
`> o2;`,
``,
`                            2                        2`,
`               [1, {[aA q, q  + q + 1], [aA q + aA, q  + q + 1]}]`,
``,
``,
`SEE ALSO:`,
`Norm, Scalar, Ortho2Scalar, Exceptions, CHEVIE (for an overview)`
    ):

`help/text/Ortho2Scalar`:=TEXT(
``,
`CHEVIE FUNCTION: Ortho2Scalar`,
` `,
`CALLING SEQUENCE: `,
`  Ortho2Scalar( t1, t2 )`,
`  Ortho2Scalar( t1 )`,
`  Ortho2Scalar( t1, l1, t2, l2 )`,
`  Ortho2Scalar( t1, l1, t2 )`,
`  Ortho2Scalar( t1, l1 )`,
``,
`PARAMETERS:`,
`     t1, t2      -- generic character tables`,
`     l1, l2      -- integers or lists of integers`,
``,
`SYNOPSIS: `,
`- Calculates the (generic) column scalar products of the class types `,
`  of table t1 with those of table t2. If no table t2 is specified, `,
`  then t2 is set to t1.`,
``,
`- If the function is called with the single parameter t1, then only`,
`  those scalar products are computed, for which the position of the`,
`  second factor on the generic character table t1 does not exceed`,
`  the position of the first factor.`,
``,
`- A message "Possible Exceptions" informs you about those values of `,
`  the parameters, for which the calculation is not valid.  In the `,
`  message, the integer i, i = 1, 2, is appended to the class `,
`  parameters of the factor i of the column scalar product.`,
``,
`- The additional parameters, if present, specify the class types, for `,
`  which the column scalar products are calculated. `,
``,
`- Usually the function only prints the results to the screen but returns`,
`  nothing. If the second and fourth parameters are integers l1, l2, then `,
`  a list with two entries is returned. The first entry is the (generic) `,
`  column scalar product of the class types l1, l2, the second entry the `,
`  set of possible exceptions.`,
``,
`EXAMPLE:`,
`> Ortho2Scalar(GL3,[1],GL3,[1]);`,
`Possible Exceptions:     {[-3*aA2+3*aA1, q-1], [2*aA1-2*aA2, q-1]}`,
`Ortho2Scalar_GL3,GL3(1,1)=`,
`                                       0`,
``,
``,
`> o2 := Ortho2Scalar(GL3,1,GL3,1):`,
`> o2;`,
``,
`            [0, {[- 3 aA2 + 3 aA1, q - 1], [2 aA1 - 2 aA2, q - 1]}]`,
``,
`> PrintClassParam(GL3,1);`,
` `,
`clt   Parameters   Exceptions`,
` `,
`=======================================================`,
`1   [aA = 1 .. q-1]   []`,
``,
`SEE ALSO:`,
`Scalar, Orhto2Norm, Norm, Exceptions, CHEVIE (for an overview)`
    ):

`help/text/CentOrd`:=TEXT(
``,
`CHEVIE FUNCTION: CentOrd`,
` `,
`CALLING SEQUENCE: `,
`  CentOrd( t ) `,
`  CentOrd( t, l )`,
`  CentOrd( t, i )`,
``,
`PARAMETERS:`,
`     t      -- generic character table or`,
`               table of Green functions`,
`     l      -- list of integers`,
`     i      -- integer`,
` `,
`SYNOPSIS: `,
`- Prints the centralizer orders of the class types of t.`,
``,
`- If the parameter l is present, then only the centralizer orders`,
`  corresponding to the class types specified by l are printed.`,
``,
`- If the second argument is an integer i, then the centralizer order`,
`  of class type i is returned.`,
``,
`EXAMPLE:`,
`> CentOrd(GU3);`,
``,
`clt   Order of centralizer`,
``,
`=======================================================`,
`1   q^3*(q+1)^3*(q-1)*(q^2-q+1)`,
`2   q^3*(q+1)^2`,
`3   q^2*(q+1)`,
`4   q*(q+1)^3*(q-1)`,
`5   q*(q+1)^2`,
`6   (q+1)^3`,
`7   (q+1)^2*(q-1)`,
`8   (q+1)*(q^2-q+1)`,
`> c7 := CentOrd(GU3,7):`,
`> c7;`,
``,
`                                       2`,
`                                (q + 1)  (q - 1)`,
``,
``,
``,
`SEE ALSO:`,
`CharDeg, PrintInfoClass, NrClasses, CHEVIE (for an overview)`
    ):

`help/text/CharDeg`:=TEXT(
``,
`CHEVIE FUNCTION: CharDeg`,
` `,
`CALLING SEQUENCE: `,
`  CharDeg( t )`,
`  CharDeg( t, l )`,
`  CharDeg( t, i )`,
` `,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Prints the degrees of the character types of t.`,
``,
`- If the parameter l is present, then only the character degrees`,
`  corresponding to the character types specified by l are printed.`,
``,
`- If the second argument is an integer i, then the character degree`,
`  of character type i is returned.`,
` `,
`EXAMPLE:`,
`> CharDeg(GU3);`,
``,
`cht   Degree of character(s)`,
``,
`=======================================================`,
`1   1`,
`2   q*(q-1)`,
`3   q^3`,
`4   q^2-q+1`,
`5   q*(q^2-q+1)`,
`6   (q-1)*(q^2-q+1)`,
`7   (q+1)*(q^2-q+1)`,
`8   (q+1)^2*(q-1)`,
`> d5 := CharDeg(GU3,5):`,
`> d5;`,
``,
`                                     2`,
`                                 q (q  - q + 1)`,
``,
``,
`SEE ALSO:`,
`CentOrd, PrintInfoChar, NrChars, CHEVIE (for an overview)`
    ):

`help/text/NrClasses`:=TEXT(
``,
`CHEVIE FUNCTION: NrClasses`,
` `,
`CALLING SEQUENCE:               `,
`  NrClasses( t )`,
`  NrClasses( t, l )`,
`  NrClasses( t, i )`,
` `,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
``,
`SYNOPSIS:`,
`- Prints the number of conjugacy classes in the various class types of t.`,
``,
`- If the parameter l is present, then only the numbers corresponding to `,
`  the class types specified by l are printed.`,
``,
`- If the second argument is an integer i, then the number of conjugacy `,
`  classes of class type i is returned.`,
``,
`EXAMPLE:`,
`> NrClasses(GU3);`,
``,
`clt   Number of classes in this type`,
``,
`=======================================================`,
`1   q+1`,
`2   q+1`,
`3   q+1`,
`4   q*(q+1)`,
`5   q*(q+1)`,
`6   1/6*q*(q-1)*(q+1)`,
`7   1/2*(q-2)*(q+1)^2`,
`8   1/3*q*(q-1)*(q+1)`,
`> nr8 := NrClasses(GU3,8):`,
`> nr8;`,
``,
`                             1/3 q (q - 1) (q + 1)`,
``,
``,
`SEE ALSO:`,
`NrChars, CentOrd, PrintInfoClass, CHEVIE (for an overview)`,
``
    ):

`help/text/NrChars`:=TEXT(
``,
`CHEVIE FUNCTION: NrChars`,
``,
`CALLING SEQUENCE:`,
`  NrChars( t )`,
`  NrChars( t, l )`,
`  NrChars( t, i )`,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
` `,
`SYNOPSIS:`,
`- Prints the number of characters in the various character types of t.`,
` `,
`- If the parameter l is present, then only the numbers corresponding to`,
`  the character types specified by l are printed.`,
` `,
`- If the second argument is an integer i, then the number of characters`,
`  of character type i is returned.`,
` `,
`EXAMPLE:`,
`> NrChars(GU3);`,
``,
`cht   Number of characters in this type`,
``,
`=======================================================`,
`1   q+1`,
`2   q+1`,
`3   q+1`,
`4   q*(q+1)`,
`5   q*(q+1)`,
`6   1/6*q*(q-1)*(q+1)`,
`7   1/2*(q-2)*(q+1)^2`,
`8   1/3*q*(q-1)*(q+1)`,
`> nr6 := NrChars(GU3,6):`,
`> nr6;`,
``,
`                             1/6 q (q - 1) (q + 1)`,
``,
` `,
`SEE ALSO: `,
`NrClasses, CharDeg, PrintInfoChar, CHEVIE (for an overview) `,
``
    ):

`help/text/PrintCharParam`:=TEXT(
``,
`CHEVIE FUNCTION: PrintCharParam`,
` `,
`CALLING SEQUENCE: `,
`  PrintCharParam( t )`,
`  PrintCharParam( t, l )  `,
`  PrintCharParam( t, i )  `,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Prints the name(s) of the parameter(s) which distinguish the irreducible`,
`  characters inside a character type. The range of the parameter(s) is `,
`  indicated in form of a table with two or three columns, the first for `,
`  the list of parameters, the second for the list of exceptions. If some `,
`  of the parameters have been substituted with the function SpecCharParam,`,
`  then the table of paramters contains a third column with the list of`,
`  substitutions.`,
``,
`- The list of parameters is of the form:`,
`  [ p_1 = 1 .. n_1, p_2 = 1 .. n_2, ... ].`,
`  Here, p_j is the name of the parameter, which is an element of `,
`  the integers modulo n_j.`,
``,
`- The list of exceptions is of the form:`,
`  [ [ expr_1, m_1 ], [ expr_2, m_2 ], ... ].`,
`  Here, expr_j is an expression in the parameters, and m_j an integer. `,
`  Those parameters have to be excluded, for which m_j divides expr_j.`,
``,
`- The list of substitutions is of the form:`,
`  [ { set_1 }, { set_2 }, ... ].`,
`  Here, { set_j } contains the set of substitutions from the j-th call`,
`  of the function SpecCharParam.`,
`  `,
`- If the parameter l or i is present, the information is given only for`,
`  the character types specified by l or i.`,
``,
`EXAMPLE:`,
`> PrintCharParam(GL3,5);`,
``,
`cht   Parameters   Exceptions`,
``,
`=======================================================`,
`5   [nN = 1 .. q-1, mM = 1 .. q-1]   [[nN-mM, q-1]]`,
`> SpecCharParam(GL3,5,mM = - nN);`,
`Substituted`,
`      {mM = -nN}`,
`in character type 5.`,
`> PrintCharParam(GL3,5);         `,
``,
`cht   Parameters   Exceptions   Substitutions`,
``,
`=======================================================`,
`5   [nN = 1 .. q-1, mM = 1 .. q-1]   [[nN-mM, q-1]]   [{mM = -nN}]`,
`> SpecCharParam(GL3,5,nN = 1);`,
`Substituted`,
`      {nN = 1}`,
`in character type 5.`,
`> PrintCharParam(GL3,5);         `,
``,
`cht   Parameters   Exceptions   Substitutions`,
``,
`=======================================================`,
`5   [nN = 1 .. q-1, mM = 1 .. q-1]   [[nN-mM, q-1]]   [{mM = -nN}, {nN = 1}]`,
``,
`SEE ALSO:`,
`PrintClassParam, SpecCharParam, CHEVIE (for an overview)`
    ):

`help/text/PrintClassParam`:=TEXT(
``,
`CHEVIE FUNCTION: PrintClassParam`,
` `,
`CALLING SEQUENCE: `,
`  PrintClassParam( t )`,
`  PrintClassParam( t, l )  `,
`  PrintClassParam( t, i )  `,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     l      -- list of integers`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Prints the name(s) of the parameter(s) which distinguish the conjugacy`,
`  classes inside a class type. The range of the parameter(s) is indicated `,
`  in form of a table with two or three columns, the first for the list of `,
`  parameters, the second for the list of exceptions. If some of the `,
`  parameters have been substituted with the function SpecClassParam,`,
`  then the table of paramters contains a third column with the list of`,
`  substitutions.`,
` `,
`- The list of parameters is of the form:`,
`  [ p_1 = 1 .. n_1, p_2 = 1 .. n_2, ... ].`,
`  Here, p_j is the name of the parameter, which is an element of`,
`  the integers modulo n_j.`,
` `,
`- The list of exceptions is of the form:`,
`  [ [ expr_1, m_1 ], [ expr_2, m_2 ], ... ].`,
`  Here, expr_j is an expression in the parameters, and m_j an integer. `,
`  Those parameters have to be excluded, for which m_j divides expr_j.`,
` `,
`- The list of substitutions is of the form:`,
`  [ { set_1 }, { set_2 }, ... ].`,
`  Here, { set_j } contains the set of substitutions from the j-th call`,
`  of the function SpecClassParam.`,
``,
`- If the parameter l or i is present, the information is given only for`,
`  the class types specified by l or i.`,
` `,
`EXAMPLE:`,
`> PrintClassParam(GL2);`,
` `,
`clt   Parameters   Exceptions`,
` `,
`=======================================================`,
`1   [iI = 1 .. q-1]   []`,
`2   [iI = 1 .. q-1]   []`,
`3   [iI = 1 .. q-1, jJ = 1 .. q-1]   [[iI-jJ, q-1]]`,
`4   [iI = 1 .. q^2-1]   [[iI, q+1]]`,
``,
`> SpecClassParam(GL2,3,iI=1,jJ=2);`,
`Substituted`,
`      {jJ = 2, iI = 1}`,
`in class type 3.`,
`> PrintClassParam(GL2,3);`,
` `,
`clt   Parameters   Exceptions   Substitutions`,
` `,
`=======================================================`,
`3   [iI = 1 .. q-1, jJ = 1 .. q-1]   [[iI-jJ, q-1]]   [{jJ = 2, iI = 1}]`,
``,
`SEE ALSO:`,
`PrintCharParam, SpecClassParam, CHEVIE (for an overview)`
    ):

`help/text/PrintInfoChar`:=TEXT(
``,
`CHEVIE FUNCTION: PrintInfoChar`,
` `,
`CALLING SEQUENCE: `,
`  PrintInfoChar ( t ) `,
`  PrintInfoChar ( t, l ) `,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
`     l           -- integer or list of integers`,
``,
`SYNOPSIS: `,
`- Prints information about the character types respectively Green functions`,
`  of table t.`,
` `,
`- If the parameter l is present, only the information for the character`,
`  types specified by l is printed.`,
``,
`- The information corresponding to character type i of table t is stored`,
`  in position [i,-1] of the MAPLE array containing t. It is given in form `,
`  of a list, called information list in the following.`,
` `,
`- If t is a table of Green functions, the information list contains exactly`,
`  one entry: A symbol for the F-conjugacy class of the Weyl group which`,
`  corresponds to the i-th Green function on t.`,
``,
`- If t is a generic character table, the information list contains a varying`,
`  number of entries.`,
``,
`- Position 1 of the information list contains miscellaneous information`,
`  ranging from the empty string to the names of the factors, if the i-th`,
`  character type of table t happens to be a tensor product.`,
``,
`- Position 2 of the information list contains a list [a, b]. The`,
`  integer a numbers the semisimple character types of t, beginning with 1`,
`  for the character type containing the trivial character.`,
`  The integer b numbers the unipotent characters of the centralizer of the `,
`  semisimple class type corresponding to a in the dual group, beginning `,
`  with 0 for the trivial character.`,
`  Thus [1, b] denotes the (b-1)st unipotent character, and [a, 0] the a-th `,
`  semisimple character type of the group.`,
` `,
`- Position 3 of the information list contains a list [s, p] which`,
`  corresponds to [a, b].`,
`  The string s indicates the Dynkin diagram, including automorphism, of`,
`  the semisimple part of the centralizer of the semisimple class type `,
`  corresponding to a in the dual group (if t is the character table of`,
`  a generic group with a connected centre; otherwise this description`,
`  has to be adjusted).`,
`  The entry p informs about the (b-1)st unipotent character of this`,
`  centralizer.`,
`  The data type of p depends on the group. For classical groups p will `,
`  usually be a partition, a pair of partitions or a symbol. A partition is `,
`  given as a list of its parts in non-increasing order.`,
` `,
`- Other positions of the information list may contain additional information`,
`  such as for example different notations for the characters.  To find `,
`  out about additional information use the function PrintInfoTab.`,
` `,
`EXAMPLE:`,
`> PrintInfoChar(``Sp4.0``);`,
``,
`cht   Information`,
``,
`======================================================`,
`1   [, [1, 0], B_2, theta0]`,
`2   [, [1, 1], B_2, theta1]`,
`3   [, [1, 2], B_2, theta2]`,
`4   [, [1, 3], B_2, theta3]`,
`5   [, [1, 4], B_2, theta5]`,
`6   [, [1, 5], B_2, theta4]`,
`7   [, [2, 0], A_1, chi6]`,
`8   [, [2, 1], A_1, chi10]`,
`9   [, [3, 0], A_1, chi8]`,
`10   [, [3, 1], A_1, chi12]`,
`11   [, [4, 0], A_1, chi7]`,
`12   [, [4, 1], A_1, chi11]`,
`13   [, [5, 0], A_1, chi9]`,
`14   [, [5, 1], A_1, chi13]`,
`15   [, [6, 0], A_0, chi1]`,
`16   [, [7, 0], A_0, chi3]`,
`17   [, [8, 0], A_0, chi2]`,
`18   [, [9, 0], A_0, chi5]`,
`19   [, [10, 0], A_0, chi4]`,
`> Copy(``Sp4.0``,h,[],[]);`,
`> Tensor(``Sp4.0``,2,``Sp4.0``,[4,3,2],h);`,
`> PrintInfoChar(h);`,
``,
`cht   Information`,
``,
`======================================================`,
`1   [Tensor(Sp4.0,2,Sp4.0,4)]`,
`2   [Tensor(Sp4.0,2,Sp4.0,3)]`,
`3   [Tensor(Sp4.0,2,Sp4.0,2)]`,
``,
`SEE ALSO:`,
`PrintInfoClass, PrintInfoTab, PrintVal, PrintToTeX, CHEVIE (for an overview)`
    ):

`help/text/PrintInfoClass`:=TEXT(
``,
`CHEVIE FUNCTION: PrintInfoClass`,
` `,
`CALLING SEQUENCE: `,
`  PrintInfoClass ( t ) `,
`  PrintInfoClass ( t, l ) `,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
`     l           -- integer or list of integers`,
``,
`SYNOPSIS: `,
`- Prints information about the class types of table t. `,
``,
`- If the parameter l is present, only the information for the class`,
`  types specified by l is printed.`,
` `,
`- The information corresponding to class type i of table t is stored`,
`  in position [-1,i] of the MAPLE array containing t. It is given in`,
`  form of a list, called information list in the following. `,
``,
`- If t is a table of Green functions, the information list contains exactly`,
`  one entry: A symbol for the i-th unipotent conjugacy class.`,
` `,
`- If t is a generic character table, the information list contains a varying`,
`  number of entries.`,
` `,
`- Position 1 of the information list contains miscellaneous information.`,
` `,
`- Position 2 of the information list contains a list [a, b]. The `,
`  integer a numbers the semisimple class types of t, beginning with 1`,
`  for the class type containing the unit. `,
`  The integer b numbers the unipotent conjugacy classes of the `,
`  centralizer of the semisimple class type a, beginning with 0 for the `,
`  unipotent class containing the unit. `,
`  Thus [1, b] denotes the (b-1)st unipotent conjugacy class, and [a, 0] `,
`  the a-th semisimple class type of the group.`,
``,
`- Position 3 of the information list contains a list [s, p] which `,
`  corresponds to [a, b]. `,
`  The string s indicates the Dynkin diagram, including automorphism, of `,
`  the semisimple part of the centralizer of the semisimple class type a. `,
`  The entry p informs about the (b-1)st unipotent conjugacy class of this `,
`  centralizer.`,
`  The data type of p depends on the group. For classical groups p will be`,
`  a partition or a pair of partitions. A partition is given as a list of`,
`  its parts in non-increasing order.`,
``,
`- Other positions of the information list may contain additional information`,
`  such as for example different notations for the conjugacy classes.`,
`  To find out about additional information use the function PrintInfoTab.`,
``,
`EXAMPLE:`,
`> PrintInfoClass(``Sp4.0``);`,
``,
`clt   Information`,
``,
`======================================================`,
`1   [, [1, 0], C_2, A1]`,
`2   [, [1, 1], C_2, A2]`,
`3   [, [1, 2], C_2, A31]`,
`4   [, [1, 3], C_2, A32]`,
`5   [, [1, 4], C_2, A41]`,
`6   [, [1, 5], C_2, A42]`,
`7   [, [4, 0], A_1, C1]`,
`8   [, [4, 1], A_1, D1]`,
`9   [, [5, 0], A_1, C3]`,
`10   [, [5, 1], A_1, D3]`,
`11   [, [6, 0], A_1, C2]`,
`12   [, [6, 1], A_1, D2]`,
`13   [, [7, 0], A_1, C4]`,
`14   [, [7, 1], A_1, D4]`,
`15   [, [8, 0], A_0, B1]`,
`16   [, [9, 0], A_0, B2]`,
`17   [, [10, 0], A_0, B3]`,
`18   [, [11, 0], A_0, B5]`,
`19   [, [12, 0], A_0, B4]`,
`> PrintInfoTab(``Sp4.0``);`,
`Information about the generic character table of $Sp_4(q)$, $q$ even`,
``,
`- CHEVIE-name of the table: ``Sp4.0```,
``,
`- The table was first computed in:`,
`  {\\sc H.Enomoto}, The characters of the finite symplectic group`,
`  $Sp(4,q)$, $q=2^f$, {\\em Osaka J. Math.} {\\bf 9} (1972), 75--94.`,
``,
`- The table in the cited paper contains a lot of misprints.`,
`  The table in the CHEVIE-library was recomputed by F.Luebeck`,
`  (using Deligne--Lusztig theory).`,
``,
`- The names for the class (resp. character) types used in the`,
`  paper of Enomoto can be found as 4th component of the lists`,
`  in the (-1)st row (resp. column) of the table. Example:`,
`> ``Sp4.0``[-1,3][4];`,
``,
`                                      A31`,
``,
`  shows, that the class type of the third column of the table`,
`  is called A31 by Enomoto.`,
``,
`SEE ALSO:`,
`PrintInfoChar, PrintInfoTab, PrintVal, PrintToTeX, CHEVIE (for an overview)`
    ):

`help/text/PrintInfoTab`:=TEXT(
``,
`CHEVIE FUNCTION: PrintInfoTab`,
` `,
`CALLING SEQUENCE: `,
`  PrintInfoTab ( t ) `,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
``,
`SYNOPSIS: `,
`- Prints useful information about the generic character table t. `,
`  It gives a reference to the author(s) of the table and possibly`,
`  some additional relevant information.`,
``,
`EXAMPLE:`,
`> PrintInfoTab(``Sp4.0``);`,
`Information about the generic character table of $Sp_4(q)$, $q$ even`,
``,
`- CHEVIE-name of the table: ``Sp4.0```,
``,
`- The table was first computed in:`,
`  {\\sc H.Enomoto}, The characters of the finite symplectic group`,
`  $Sp(4,q)$, $q=2^f$, {\\em Osaka J. Math.} {\\bf 9} (1972), 75--94.`,
``,
`- The table in the cited paper contains a lot of misprints.`,
`  The table in the CHEVIE-library was recomputed by F.Luebeck`,
`  (using Deligne--Lusztig theory).`,
``,
`- The names for the class (resp. character) types used in the`,
`  paper of Enomoto can be found as 4th component of the lists`,
`  in the (-1)st row (resp. column) of the table. Example:`,
`> ``Sp4.0``[-1,3][4];`,
``,
`                                      A31`,
``,
`  shows, that the class type of the third column of the table`,
`  is called A31 by Enomoto.`,
``,
`SEE ALSO:`,
`PrintInfoChar, PrintInfoClass, PrintVal, PrintToTeX, CHEVIE (for an overview)`
    ):

`help/text/PrintToTeX`:=TEXT(
``,
`CHEVIE FUNCTION: PrintToTeX`,
` `,
`CALLING SEQUENCE: `,
`  PrintToTeX ( t )`,
`  PrintToTeX ( t, l1 ) `,
`  PrintToTeX ( t, l1, l2 ) `,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
`     l1, l2      -- integers or lists of integers`,
``,
`SYNOPSIS: `,
`- Prints the values of the characters  or Green functions of table t`,
`  onto a TeX file tempptt.tex and runs LaTeX on tempptt.tex.`,
``,
`- The function can take an additional parameter s, a MAPLE string, in`,
`  which case the TeX file is called s.tex.`,
``,
`- If a non-empty string ``preview_prog`` is assigned to the global MAPLE `,
`  variable PREVIEWNAME, then the TeX-preview program preview_prog is `,
`  called with the file tempptt.tex respectively s.tex. The default value `,
`  of PREVIEWNAME is 'texsun -ns 3'. It can be changed upon installing`,
`  CHEVIE (cf. the installation guide).`,
` `,
`- If the parameter l1 is present, only the values of the character types `,
`  specified by l1 are printed.`,
``,
`- The additional parameter l2 specifies the class types whose values are `,
`  to be printed.`,
``,
`EXAMPLE:`,
`> PREVIEWNAME;`,
``,
``,
``,
`> PrintToTeX(``SL2.0``);`,
`This is TeX, C Version 3.14t3`,
`(t3`,
`ILaTeX Version 2.09 <14 January 1991>`,
`(/usr/local/lib/tex/inputs/ILaTeX/article.sty`,
`Document Style ``article' <16 Mar 88>, international version <17 Oct 89>.`,
`(/usr/local/lib/tex/inputs/ILaTeX/art10.sty))`,
`No file t3.aux.`,
`[1] (t3.aux) )`,
`Output written on t3.dvi (1 page, 956 bytes).`,
`Transcript written on t3.log.`,
``,
`SEE ALSO:`,
`PrintVal, PrintInfoTab, PrintInfoChar, PrintInfoClass, CHEVIE (for an overview)`
    ):

`help/text/PrintVal`:=TEXT(
``,
`CHEVIE FUNCTION: PrintVal`,
` `,
`CALLING SEQUENCE: `,
`  PrintVal ( t ) `,
`  PrintVal ( t, l1 ) `,
`  PrintVal ( t, l1, l2 ) `,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
`     l1, l2      -- integers or lists of integers`,
``,
`SYNOPSIS: `,
`- Prints the values of the characters or Green functions of table t.`,
` `,
`- If the parameter l1 is present, only the values of the character types `,
`  specified by l1 are printed.`,
``,
`- The additional parameter l2 specifies the class types whose values are `,
`  to be printed.`,
``,
`EXAMPLE:`,
`> PrintVal(``SL2.0``);`,
``,
`clt   Value of character type    1    on class type clt`,
``,
`1   1`,
`2   1`,
`3   1`,
`4   1`,
``,
`clt   Value of character type    2    on class type clt`,
``,
`1   q`,
`2   0`,
`3   1`,
`4   -1`,
``,
`clt   Value of character type    3    on class type clt`,
``,
`1   q+1`,
`2   1`,
`3   GEWZ1^(nN*aA)+GEWZ1^(-nN*aA)`,
`4   0`,
``,
`clt   Value of character type    4    on class type clt`,
``,
`1   q-1`,
`2   -1`,
`3   0`,
`4   -GEWY1^(nN*aA)-GEWY1^(-nN*aA)`,
`> PrintVal(``SL2.0``,[2..4],3);`,
``,
`clt   Value of character type    2    on class type clt`,
``,
`3   1`,
``,
`clt   Value of character type    3    on class type clt`,
``,
`3   GEWZ1^(nN*aA)+GEWZ1^(-nN*aA)`,
``,
`clt   Value of character type    4    on class type clt`,
``,
`3   0`,
``,
`SEE ALSO:`,
`GEW, PrintToTeX, CHEVIE (for an overview)`
    ):

`help/text/Scalar`:=TEXT(
``,
`CHEVIE FUNCTION: Scalar`,
` `,
`CALLING SEQUENCE: `,
`  Scalar( t1, t2 )`,
`  Scalar( t1 )`,
`  Scalar( t1, l1, t2, l2 )`,
`  Scalar( t1, l1, t2 )`,
`  Scalar( t1, l1 )`,
``,
`PARAMETERS:`,
`     t1, t2      -- generic character tables`,
`     l1, l2      -- integers or lists of integers`,
``,
`SYNOPSIS: `,
`- Calculates the (generic) scalar products of the character types `,
`  of table t1 with those of table t2. If no table t2 is specified, `,
`  then t2 is set to t1. `,
``,
`- If the function is called with the single parameter t1, then only`,
`  those scalar products are computed, for which the position of the`,
`  second factor on the generic character table t1 does not exceed`,
`  the position of the first factor.`,
``,
`- A message "Possible Exceptions" informs you about those values of `,
`  the parameters, for which the calculation is not valid.`,
``,
`- In this message, the integer i, i = 1, 2, is appended to the `,
`  character parameters of the factor i of the scalar product.`,
`  This does not apply to factors which have been constructed with`,
`  the "Tensor" function (since the parameters of those have already been`,
`  supplied with a suffix).`,
``,
`- The additional parameters, if present, specify the character`,
`  types, for which the scalar products are calculated. `,
``,
`- Usually the function only prints the results to the screen but returns`,
`  nothing. If the second and fourth parameters are integers l1, l2, then `,
`  a list with two entries is returned. The first entry is the (generic) `,
`  scalar product of the character types l1, l2, the second entry the set `,
`  of possible exceptions.`,
``,
`EXAMPLE:`,
`> Scalar(GL3,[1],GL3,[2]);`,
`Possible Exceptions:     {[3*nN2-3*nN1, q-1], [2*nN2-2*nN1, q-1]}`,
`Scalar_GL3,GL3(1,2)=`,
`                                       0`,
``,
``,
`> s12 := Scalar(GL3,1,GL3,2):`,
`> s12;`,
``,
`             [0, {[3 nN2 - 3 nN1, q - 1], [2 nN2 - 2 nN1, q - 1]}]`,
``,
`> PrintCharParam(GL3,[1,2]);`,
``,
`cht   Parameters   Exceptions`,
``,
`=======================================================`,
`1   [nN = 1 .. q-1]   []`,
`2   [nN = 1 .. q-1]   []`,
``,
`SEE ALSO:`,
`Ortho2Scalar, Orhto2Norm, Norm, Exceptions, Tensor, CHEVIE (for an overview)`
    ):

`help/text/SpecCharParam`:=TEXT(
``,
`CHEVIE FUNCTION: SpecCharParam`,
` `,
`CALLING SEQUENCE: `,
`  SpecCharParam( t, i, param_1 = expr_1, param_2 = expr_2, ... ) `,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Substitutes in character type i of table t the parameters param_k `,
`  by the expressions expr_k, k = 1, 2, ... `,
``,
`EXAMPLE:`,
`> Copy(GL3,new,3);`,
`> PrintVal(new);`,
``,
`clt   Value of character type    1    on class type clt`,
``,
`1   q^3*GEWZ1^(3*nN*aA)`,
`2   0`,
`3   0`,
`4   q*GEWZ1^(2*nN*aA+nN*bB)`,
`5   0`,
`6   GEWZ1^(nN*aA+nN*bB+nN*cC)`,
`7   -GEWZ1^(nN*aA+nN*bB)`,
`8   GEWZ1^(nN*aA)`,
`> PrintCharParam(new);`,
``,
`cht   Parameters   Exceptions`,
``,
`=======================================================`,
`1   [nN = 1 .. q-1]   []`,
`> SpecCharParam(new,1,nN=q-1);`,
`Substituted`,
`      {nN = q-1}`,
`in character type 1.`,
`> PrintVal(new);`,
``,
`clt   Value of character type    1    on class type clt`,
``,
`1   q^3`,
`2   0`,
`3   0`,
`4   q`,
`5   0`,
`6   1`,
`7   -1`,
`8   1`,
``,
`SEE ALSO:`,
`SpecClassParam, Copy, CopyChar, CopyClass, PrintCharParam,`,
`CHEVIE (for an overview)`
    ):

`help/text/SpecClassParam`:=TEXT(
``,
`CHEVIE FUNCTION: SpecClassParam`,
` `,
`CALLING SEQUENCE: `,
`  SpecClassParam( t, i, param_1 = expr_1, param_2 = expr_2, ... ) `,
``,
`PARAMETERS:`,
`     t      -- generic character table`,
`     i      -- integer`,
``,
`SYNOPSIS: `,
`- Substitutes in class type i of table t the parameters param_k `,
`  by the expressions expr_k, k = 1, 2, ... `,
``,
`EXAMPLE:`,
`> Copy(GL3,new,[1..8],3);`,
`> PrintClassParam(new);`,
` `,
`clt   Parameters   Exceptions`,
` `,
`=======================================================`,
`1   [aA = 1 .. q-1]   []`,
`> SpecClassParam(new,1,aA=q-1);`,
`Substituted`,
`      {aA = q-1}`,
`in class type 1.`,
``,
`SEE ALSO:`,
`SpecCharParam, Copy, CopyChar, CopyClass, PrintClassParam,`,
`CHEVIE (for an overview)`
    ):

`help/text/Status`:=TEXT(
``,
`CHEVIE FUNCTION: Status`,
``,
`CALLING SEQUENCE:`,
`  Status( t )`,
``,
`PARAMETERS:`,
`     t           -- generic character table or`,
`                    table of Green functions`,
``,
`SYNOPSIS:`,
`- Prints information about the generic table t.`,
``,
`- The following information is printed:`,
``,
`    The "Order" of the group.                      `,
`    The "Number of character types" stored on t.  `,
`    The "Number of rows available" on the MAPLE array containing t.   `,
`    The "Number of class types" stored on t.`,
`    The "Number of columns available" on the MAPLE array containing t.`,
``,
`EXAMPLE:`,
``,
`> Status(GL3);      `,
` `,
`Status of   GL3`,
` `,
`=======================================================`,
`Order                      :   q^3*(q-1)^3*(q+1)*(q^2+q+1)`,
`Number of character types  :   8`,
`Number of rows available   :   8`,
`Number of class types      :   8`,
`Number of columns available:   8`,
``,
`SEE ALSO:`,
`CHEVIE (for an overview)`
    ):

`help/text/Tensor`:=TEXT(
``,
`CHEVIE FUNCTION: Tensor`,
` `,
`CALLING SEQUENCE: `,
`  Tensor( t1, t2, t3 ) `,
`  Tensor( t1, t3 ) `,
`  Tensor( t1, l1, t2, l2, t3 ) `,
`  Tensor( t1, l1, t3 ) `,
``,
`PARAMETERS:`,
`     t1, t2, t3      -- generic character table`,
`     l1, l2          -- integers or lists of integers`,
``,
`SYNOPSIS: `,
`- Computes the tensor products of the character types of table t1 `,
`  with the character types of table t2 and writes them onto table t3. `,
`  Table t3 must be present and have enough rows available.`,
``,
`- The character parameters of the tensor product are obtained from the`,
`  parameters of its i-th factors by appending t.i, i = 1, 2. `,
``,
`- You can find out about the factors of the tensor products stored on `,
`  table t2 with the function PrintInfoTab.`,
``,
`- The second form of the function does the same as the first for t2 = t1.`,
``,
`- The parameter l1, if present, specifies the characters types of t1`,
`  to be tensored with the character types of t2, specified by l2. `,
``,
`- The fourth form of the function does the same as the third for t2 = t1`,
`  and l2 = l1.`,
``,
`EXAMPLE:`,
`> Copy(GL3,new,[],[],'ROWS' + 10);`,
`> Tensor(GL3,2,GL3,2,new);`,
`> PrintVal(new);`,
``,
`clt   Value of character type    1    on class type clt`,
``,
`1   q^2*(q+1)^2*GEWZ1^(3*nNt1*aA+3*nNt2*aA)`,
`2   q^2*GEWZ1^(3*nNt1*aA+3*nNt2*aA)`,
`3   0`,
`4   (q+1)^2*GEWZ1^(2*nNt1*aA+nNt1*bB+2*nNt2*aA+nNt2*bB)`,
`5   GEWZ1^(2*nNt1*aA+nNt1*bB+2*nNt2*aA+nNt2*bB)`,
`6   4*GEWZ1^(nNt1*aA+nNt2*cC+nNt1*bB+nNt1*cC+nNt2*aA+nNt2*bB)`,
`7   0`,
`8   GEWZ1^(nNt1*aA+nNt2*aA)`,
`> PrintCharParam(new);`,
``,
`cht   Parameters   Exceptions`,
``,
`=======================================================`,
`1   [nNt1 = 1 .. q-1, nNt2 = 1 .. q-1]   []`,
`> PrintCharParam(GL3,2);`,
``,
`cht   Parameters   Exceptions`,
``,
`=======================================================`,
`2   [nN = 1 .. q-1]   []`,
`> PrintInfoChar(new);`,
``,
`cht   Information`,
``,
`======================================================`,
`1   Tensor(GL3,2,GL3,2)`,
``,
`>  Copy(GL3,new,[],[],'ROWS' + 10);`,
`> Tensor(GL3,2,new); `,
`> PrintInfoChar(new);`,
``,
`cht   Information`,
``,
`======================================================`,
`1   Tensor(GL3,2,GL3,1)`,
`2   Tensor(GL3,2,GL3,2)`,
`3   Tensor(GL3,2,GL3,3)`,
`4   Tensor(GL3,2,GL3,4)`,
`5   Tensor(GL3,2,GL3,5)`,
`6   Tensor(GL3,2,GL3,6)`,
`7   Tensor(GL3,2,GL3,7)`,
`8   Tensor(GL3,2,GL3,8)`,
``,
`SEE ALSO:`,
`Copy, CopyChar, SpecCharParam, PrintInfoChar, CHEVIE (for an overview)`,
``
    ):

`help/text/GreenFunctionsA`:=TEXT(
``,
`CHEVIE FUNCTION: GreenFunctionsA`,
``,
`CALLING SEQUENCE:`,
`  GreenFunctionsA( i )`,
`  GreenFunctionsA( i, f )`,
``,
`PARAMETERS:`,
`     i               -- non-negative integer`,
`     f               -- file name (string)`,
``,
`SYNOPSIS:`,
`- Computes the Green functions for groups of type A_i. The result is  `,
`  returned as a list with two entries. The first entry of this list is  `,
`  the array of Green functions, whose rows and columns are parametrized  `,
`  by partitions of i+1. The second entry of the list contains the list `,
`  of these partitions. (It works up to i=12, i.e., GL_{13}.)`,
``,
`- If the second parameter f is present, the result is written onto `,
`  the file f in CHEVIE format.`,
``,
`EXAMPLE:`,
`> GreenFunctionsA(2);`,
`Number of conjugacy classes:   3`,
`Foulkes polynomials computed.`,
`Now twisting to Green functions.`,
`        [            2                       ]`,
`        [  (q + 1) (q  + q + 1)   2 q + 1  1 ]`,
`        [                                    ]`,
`        [             2                      ]`,
`       [[ - (q - 1) (q  + q + 1)     1     1 ], [[1, 1, 1], [2, 1], [3]]]`,
`        [                                    ]`,
`        [                   2                ]`,
`        [    (q + 1) (q - 1)      - q + 1  1 ]`,
``,
``,
`SEE ALSO:`,
`GreenFunctions2A, GreenFunTab, CHEVIE (for an overview)`,
``
    ):

`help/text/GreenFunctions2A`:=TEXT(
` `,
`CHEVIE FUNCTION: GreenFunctions2A`,
` `,
`CALLING SEQUENCE:`,
`  GreenFunctions2A( i )`,
`  GreenFunctions2A( i, f )`,
` `,
`PARAMETERS:`,
`     i               -- non-negative integer`,
`     f               -- file name (string)`,
` `,
`SYNOPSIS:`,
`- Computes the Green functions for groups of type ^2A_i. The result is `,
`  returned as a list with two entries. The first entry of this list is `,
`  the array of Green functions, whose rows and columns are parametrized `,
`  by partitions of i+1. The second entry of the list contains the list`,
`  of these partitions. (It works up to i=12, i.e., GU_{13}.)`,
` `,
`- If the second parameter f is present, the result is written onto the `,
`  file f in CHEVIE format.`,
` `,
`EXAMPLE:`,
`> GreenFunctions2A(2);`,
`Number of conjugacy classes:   3`,
`Foulkes polynomials computed.`,
`Now twisting to Green functions.`,
`       [             2                        ]`,
`       [ - (q - 1) (q  - q + 1)  - 2 q + 1  1 ]`,
`       [                                      ]`,
`       [            2                         ]`,
`      [[  (q + 1) (q  - q + 1)       1      1 ], [[1, 1, 1], [2, 1], [3]]]`,
`       [                                      ]`,
`       [                    2                 ]`,
`       [   - (q - 1) (q + 1)       q + 1    1 ]`,
``,
`SEE ALSO:`,
`GreenFunctionsA, GreenFunTab, CHEVIE (for an overview)`
    ):

