home *** CD-ROM | disk | FTP | other *** search
/ Math Solutions 1995 October / Math_Solutions_CD-ROM_Walnut_Creek_October_1995.iso / pc / mac / discrete / doc / characte.tex < prev    next >
Encoding:
Text File  |  1993-05-05  |  69.2 KB  |  1,684 lines
  1. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2. %%
  3. %A  characte.tex                GAP documentation               Thomas Breuer
  4. %A                                                              & Ansgar Kaup
  5. %A                                                           & Goetz Pfeiffer
  6. %%
  7. %A  @(#)$Id: characte.tex,v 3.20 1993/02/19 10:48:42 gap Exp $
  8. %%
  9. %Y  Copyright 1990-1992,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
  10. %%
  11. %H  $Log: characte.tex,v $
  12. %H  Revision 3.20  1993/02/19  10:48:42  gap
  13. %H  adjustments in line length and spelling
  14. %H
  15. %H  Revision 3.19  1993/02/15  08:34:24  felsch
  16. %H  examples fixed
  17. %H
  18. %H  Revision 3.18  1993/02/13  10:29:37  felsch
  19. %H  some examples fixed
  20. %H
  21. %H  Revision 3.17  1992/11/16  16:42:06  sam
  22. %H  generalized 'PermCharInfo'
  23. %H
  24. %H  Revision 3.16  1992/10/08  10:20:32  sam
  25. %H  added 'ATLAS' component in 'PermCharInfo'
  26. %H
  27. %H  Revision 3.15  1992/08/07  08:02:49  sam
  28. %H  extended description of 'Indicator'
  29. %H
  30. %H  Revision 3.14  1992/07/03  10:11:14  sam
  31. %H  changed the author line,
  32. %H  added 'PermCharInfo'
  33. %H
  34. %H  Revision 3.13  1992/06/19  11:40:35  sam
  35. %H  added description of 'LLLReducedGramMat', 'OrthogonalEmbeddings',
  36. %H  'Extract', 'Decreased', and 'DnLattice'
  37. %H
  38. %H  Revision 3.12  1992/05/26  16:57:17  sam
  39. %H  added description of 'Subroutines of Decomposition'
  40. %H
  41. %H  Revision 3.11  1992/04/07  23:05:55  martin
  42. %H  changed the author line
  43. %H
  44. %H  Revision 3.10  1992/03/26  13:37:18  sam
  45. %H  changed arguments of 'Reduced'
  46. %H
  47. %H  Revision 3.9  1992/03/13  18:20:01  goetz
  48. %H  changed section 'PermChars'.
  49. %H
  50. %H  Revision 3.8  1992/02/14  13:32:54  sam
  51. %H  added documentation of 'Eigenvalues'
  52. %H
  53. %H  Revision 3.7  1992/02/03  17:18:51  sam
  54. %H  changed 'LLL' description, reformatted file (now at most 73 chars)
  55. %H
  56. %H  Revision 3.6  1992/01/23  11:25:06  sam
  57. %H  changed description of 'OrthogonalComponents', 'SymplecticComponents',
  58. %H  changed usage of 'MatScalarProducts'
  59. %H
  60. %H  Revision 3.5  1992/01/17  09:25:18  sam
  61. %H  changed usage of 'Tensored', 'Symmetrisations' and
  62. %H  'MurnaghanComponents'
  63. %H
  64. %H  Revision 3.4  1992/01/14  14:13:15  martin
  65. %H  changed two more citations
  66. %H
  67. %H  Revision 3.3  1992/01/14  13:55:23  sam
  68. %H  adjusted citations
  69. %H
  70. %H  Revision 3.2  1991/12/30  09:37:59  sam
  71. %H  corrected a word
  72. %H
  73. %H  Revision 3.1  1991/12/30  08:05:12  sam
  74. %H  initial revision under RCS
  75. %H
  76. %%
  77. \Chapter{Characters}
  78.  
  79. The functions described in this chapter are used to handle characters
  80. (see Chapter "Character Tables"). For this, in many cases one needs maps
  81. (see Chapter "Maps and Parametrized Maps").
  82.  
  83. There are four kinds of functions\:
  84.  
  85. First, those which get informations about characters; they compute the
  86. scalar product of characters (see "ScalarProduct", "MatScalarProducts"),
  87. decomposition matrices (see "Decomposition",
  88. "Subroutines of Decomposition"),
  89. the kernel of a character (see "KernelChar"), $p$-blocks
  90. (see "PrimeBlocks"), Frobenius-Schur indicators (see "Indicator") and
  91. eigenvalues of the corresponding representations (see "Eigenvalues"),
  92. and decide if a character might be a permutation character candidate
  93. (see "Permutation Character Candidates").
  94.  
  95. Second, those which construct characters or virtual characters, that is,
  96. differences of characters; these functions compute reduced characters
  97. (see "Reduced", "ReducedOrdinary"), tensor products (see "Tensored"),
  98. symmetrisations (see "Symmetrisations", "SymmetricParts",
  99. "AntiSymmetricParts", "MinusCharacter", "OrthogonalComponents",
  100. "SymplecticComponents"), and irreducibles differences of virtual
  101. characters (see "IrreducibleDifferences").
  102. Further, one can compute restricted (see "Restricted"), inflated
  103. (see "Inflated"), induced (see "Induced", "InducedCyclic") characters
  104. and permutation character candidates (see "Permutation Character
  105. Candidates", "PermChars").
  106.  
  107. Third, functions which use general methods for lattices.  These are
  108. the LLL algorithm to compute a lattice base consisting of short vectors
  109. (see "LLL-Algorithm"), functions to compute all orthogonal embeddings of
  110. a lattice (see "OrthogonalEmbeddings"), and one for the special case
  111. of $D_n$ lattices (see "DnLattice").  A backtrack search for
  112. irreducible characters in the span of proper characters is performed
  113. by "Extract".
  114.  
  115. Last, those which find special elements of parametrized characters (see
  116. "More about Maps and Parametrized Maps");
  117. they compute the set of contained virtual characters (see
  118. "ContainedDecomposables") or characters (see "ContainedCharacters"),
  119. the set of contained vectors which possibly are virtual characters (see
  120. "ContainedSpecialVectors", "ContainedPossibleVirtualCharacters") or
  121. characters (see "ContainedPossibleCharacters").
  122.  
  123. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  124. \Section{ScalarProduct}\index{characters!scalar product of}
  125.  
  126. 'ScalarProduct( <tbl>, <character1>, <character2> )'
  127.  
  128. returns the scalar product of <character1> and <character2>, regarded as
  129. characters of the character table <tbl>.
  130.  
  131. |    gap> t:= CharTable( "A5" );;
  132.     gap> ScalarProduct( t, t.irreducibles[1], [ 5, 1, 2, 0, 0 ] );
  133.     1
  134.     gap> ScalarProduct( t, [ 4, 0, 1, -1, -1 ], [ 5, -1, 1, 0, 0 ] );
  135.     2/3|
  136.  
  137. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  138. \Section{MatScalarProducts}\index{characters!scalar product of}
  139.  
  140. 'MatScalarProducts( <tbl>, <chars1>, <chars2> )'\\
  141. 'MatScalarProducts( <tbl>, <chars> )'
  142.  
  143. For a character table <tbl> and two lists <chars1>, <chars2> of
  144. characters, the first version returns the matrix of scalar products
  145. (see "ScalarProduct"); we have
  146.  
  147. $'MatScalarProducts( <tbl>, <chars1>, <chars2> )[i][j]' =
  148.  'ScalarProduct( <tbl>, <chars1>[j], <chars2>[i] )'$,
  149.  
  150. i.e., row 'i' contains the scalar products of '<chars2>[i]' with all
  151. characters in <chars1>.
  152.  
  153. The second form returns a lower triangular matrix of scalar products\:
  154.  
  155. $'MatScalarProducts( <tbl>, <chars> )[i][j]' =
  156.  'ScalarProduct( <tbl>, <chars>[j], <chars>[i] )'$
  157.  
  158. for $'j' \leq 'i'$.
  159.  
  160. |    gap> t:= CharTable( "A5" );;
  161.     gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;
  162.     gap> chars:= Set( Tensored( chars, chars ) );;
  163.     gap> MatScalarProducts( t, chars );
  164.     [ [ 2 ], [ 1, 3 ], [ 1, 2, 3 ], [ 2, 2, 1, 3 ], [ 2, 1, 2, 2, 3 ], 
  165.       [ 2, 3, 3, 3, 3, 5 ] ]|
  166.  
  167. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  168. \Section{Decomposition}\index{decomposition matrix}\index{DEC}
  169.  
  170. 'Decomposition( <A>, <B>, <depth> )'\\
  171. 'Decomposition( <A>, <B>, \"nonnegative\" )'
  172.  
  173. For a $m \times n$ matrix <A> of cyclotomics that has rank $m \leq n$,
  174. and a list <B> of cyclotomic vectors, each of dimension $n$,
  175. 'Decomposition' tries to find integral solutions <x> of the linear
  176. equation systems '<x> \* <A> = <B>[i]' by computing the $p$--adic
  177. series of hypothetical solutions.
  178.  
  179. \vspace{5mm}
  180. 'Decomposition( <A>, <B>, <depth> )', where <depth> is a nonnegative
  181. integer, computes for every vector '<B>[i]' the initial part
  182. $\sum_{k=0}^{<depth>} x_k p^k$ (all $x_k$ integer vectors with entries
  183. bounded by $\pm\frac{p-1}{2}$).  The prime $p$ is 83 first; if the
  184. reduction of <A> modulo $p$ is singular, the next prime is chosen
  185. automatically.
  186.  
  187. A list <X> is returned. If the computed initial part really *is* a
  188. solution of '<x> \* <A> = <B>[i]', we have '<X>[i] = <x>', otherwise
  189. '<X>[i] = false'.
  190.  
  191. \vspace{5mm}
  192. 'Decomposition( <A>, <B>, \"nonnegative\" )' assumes that the solutions
  193. have only nonnegative entries, and that the first column of <A> consists
  194. of positive integers.  In this case the necessary number <depth> of
  195. iterations is computed; the 'i'-th entry of the returned list is 'false'
  196. if there *exists* no nonnegative integral solution of the system
  197. '<x> \* <A> = <B>[i]', and it is the solution otherwise.
  198.  
  199. If <A> is singular, an error is signalled.
  200.  
  201. |    gap> a5:= CharTable( "A5" );; a5m3:= CharTable( "A5mod3" );;
  202.     gap> a5m3.irreducibles;
  203.     [ [ 1, 1, 1, 1 ], [ 3, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  204.       [ 3, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, -1, -1 ] ]
  205.     gap> reg:= CharTableRegular( a5, 3 );;
  206.     gap> chars:= Restricted( a5, reg, a5.irreducibles );
  207.     [ [ 1, 1, 1, 1 ], [ 3, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  208.       [ 3, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, -1, -1 ],
  209.       [ 5, 1, 0, 0 ] ]
  210.     gap> Decomposition( a5m3.irreducibles, chars, "nonnegative" );
  211.     [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ], 
  212.       [ 1, 0, 0, 1 ] ]
  213.     gap> last * a5m3.irreducibles = chars;
  214.     true|
  215.  
  216. For the subroutines of 'Decomposition', see "Subroutines of
  217. Decomposition".
  218.  
  219. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  220. \Section{Subroutines of Decomposition}\index{PadicCoefficients}
  221. \index{InverseMatMod}\index{LinearIndependentColumns}
  222. \index{IntegralizedMat}
  223.  
  224. Let $A$ be a square integral matrix, $p$ an odd prime.  The reduction of
  225. $A$ modulo $p$ is $\overline{A}$, its entries are chosen in the interval
  226. $[-\frac{p-1}{2}, \frac{p-1}{2}]$.  If $\overline{A}$ is regular over the
  227. field with $p$ elements, we can form $A^{\prime} = \overline{A}^{-1}$.
  228. Now consider the integral linear equation system $x A = b$, i.e., we look
  229. for an integral solution $x$.  Define $b_0 = b$, and then iteratively
  230. compute
  231.  
  232. \[ x_i = (b_i A^{\prime}) \bmod p,\ \ b_{i+1} = \frac{1}{p} (b_i - x_i A) 
  233.    \mbox{\rm\ for} i = 0, 1, 2, \ldots \ . \]
  234.  
  235. By induction, we get
  236.  
  237. \[ p^{i+1} b_{i+1} + ( \sum_{j=0}^{i} p^j x_j ) A = b . \]
  238.  
  239. If there is an integral solution $x$, it is unique, and there is an index
  240. $l$ such that $b_{l+1}$ is zero and $x = \sum_{j=0}^{l} p^j x_j$.
  241.  
  242. There are two useful generalizations.  First, $A$ need not be square;
  243. it is only necessary that there is a square regular matrix
  244. formed by a subset of columns.  Second, $A$ does not need to be integral;
  245. the entries may be cyclotomic integers as well, in this case one has to
  246. replace each column of <A> by the columns formed by the coefficients
  247. (which are integers).
  248. Note that this preprocessing must be performed compatibly for <A> and <b>.
  249.  
  250. And these are the subroutines called by 'Decomposition'\:
  251.  
  252. \vspace{5mm}
  253. 'LinearIndependentColumns( <A> )'
  254.  
  255. returns for a matrix <A> a maximal list <lic> of positions such that the
  256. rank of 'List( <A>, x -> Sublist( x, <lic> ) )' is the same as the rank
  257. of <A>.
  258.  
  259. \vspace{5mm}
  260. 'InverseMatMod( <A>, <p> )'
  261.  
  262. returns for a square integral matrix <A> and a prime <p> a matrix
  263. $A^{\prime}$ with the property that $A^{\prime} A$ is congruent to the
  264. identity matrix modulo <p>; if <A> is singular modulo <p>, 'false' is
  265. returned.
  266.  
  267. \vspace{5mm}
  268. 'PadicCoefficients( <A>, <Amodpinv>, <b>, <p>, <depth> )'
  269.  
  270. returns the list $[ x_0, x_1, \ldots, x_l, b_{l+1} ]$ where $l = <depth>$
  271. or $l$ is minimal with the property that $b_{l+1} = 0$.
  272.  
  273. \vspace{5mm}
  274. 'IntegralizedMat( <A> )'\\
  275. 'IntegralizedMat( <A>, <inforec> )'
  276.  
  277. return for a matrix <A> of cyclotomics a record <intmat> with components
  278. 'mat' and 'inforec'.  Each family of galois conjugate columns of <A> is
  279. encoded in a set of columns of the rational matrix '<intmat>.mat' by
  280. replacing cyclotomics by their coefficients.  '<intmat>.inforec' is a
  281. record containing the information how to encode the columns.
  282.  
  283. If the only argument is <A>, the component 'inforec' is computed that
  284. can be entered as second argument <inforec> in a later call of
  285. 'IntegralizedMat' with a matrix <B> that shall be encoded compatible
  286. with <A>.
  287.  
  288. \vspace{5mm}
  289. 'DecompositionInt( <A>, <B>, <depth> )'
  290.  
  291. does the same as 'Decomposition' (see "Decomposition"), but only for
  292. integral matrices <A>, <B>, and nonnegative integers <depth>.
  293.  
  294. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  295. \Section{KernelChar}
  296.  
  297. 'KernelChar( <char> )'
  298.  
  299. returns the set of classes which form the kernel of the character <char>,
  300. i.e. the set of positions $i$ with $<char>[i] = <char>[1]$.
  301.  
  302. For a factor fusion map <fus>, 'KernelChar( <fus> )' is the kernel of the
  303. epimorphism.
  304.  
  305. |    gap> s4:= CharTable( "Symmetric", 4 );;
  306.     gap> s4.irreducibles;
  307.     [ [ 1, -1, 1, 1, -1 ], [ 3, -1, -1, 0, 1 ], [ 2, 0, 2, -1, 0 ], 
  308.       [ 3, 1, -1, 0, -1 ], [ 1, 1, 1, 1, 1 ] ]
  309.     gap> List( last, KernelChar );
  310.     [ [ 1, 3, 4 ], [ 1 ], [ 1, 3 ], [ 1 ], [ 1, 2, 3, 4, 5 ] ]|
  311.  
  312. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  313. \Section{PrimeBlocks}
  314.  
  315. 'PrimeBlocks( <tbl>, <prime> )'\\
  316. 'PrimeBlocks( <tbl>, <chars>, <prime> )'
  317.  
  318. For a character table <tbl> and a prime <prime>,
  319. 'PrimeBlocks( <tbl>, <chars>, <prime> )' returns a record with fields
  320.  
  321. 'block':\\
  322.      a list of positive integers which has the same length as the list
  323.      <chars> of characters,
  324.      the entry <n> at position <i> in that list means that '<chars>[<i>]'
  325.      belongs to the <n>-th <prime>-block
  326.  
  327. 'defect':\\
  328.      a list of nonnegative integers, the value at position <i> is the
  329.      defect of the <i>--th block.
  330.  
  331. 'PrimeBlocks( <tbl>, <prime> )' does the same for
  332. '<chars> = <tbl>.irreducibles', and additionally the result is stored
  333. in the 'irredinfo' field of <tbl>.
  334.  
  335. |    gap> t:= CharTable( "A5" );;
  336.     gap> PrimeBlocks( t, 2 ); PrimeBlocks( t, 3 ); PrimeBlocks( t, 5 );
  337.     rec(
  338.       block := [ 1, 1, 1, 2, 1 ],
  339.       defect := [ 2, 0 ] )
  340.     rec(
  341.       block := [ 1, 2, 3, 1, 1 ],
  342.       defect := [ 1, 0, 0 ] )
  343.     rec(
  344.       block := [ 1, 1, 1, 1, 2 ],
  345.       defect := [ 1, 0 ] )
  346.     gap> InverseMap( last.block ); # distribution of characters to blocks
  347.     [ [ 1, 2, 3, 4 ], 5 ]|
  348.  
  349. If 'InfoCharTable2 = Print', the defects of the blocks and the heights of
  350. the contained characters are printed.
  351.  
  352. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  353. \Section{Indicator}\index{Frobenius Schur indicator}
  354.  
  355. 'Indicator( <tbl>, <n> )'\\
  356. 'Indicator( <tbl>, <chars>, <n> )'\\
  357. 'Indicator( <modtbl>, 2 )'
  358.  
  359. For a character table <tbl>, 'Indicator( <tbl>, <chars>, <n> )' returns
  360. the list of <n>-th Frobenius Schur indicators for the list <chars> of
  361. characters.
  362.  
  363. 'Indicator( <tbl>, <n> )' does the same for
  364. '<chars> = <tbl>.irreducibles', and additionally the result is stored
  365. in the field 'irredinfo' of <tbl>.
  366.  
  367. 'Indicator( <modtbl>, 2 )' returns the list of 2nd indicators for the
  368. irreducible characters of the Brauer character table <modtbl> and stores
  369. the indicators in the 'irredinfo' component of <modtbl>; this does not
  370. work for tables in characteristic 2.
  371.  
  372. |    gap> t:= CharTable( "M11" );; Indicator( t, t.irreducibles, 2 );
  373.     [ 1, 1, 0, 0, 1, 0, 0, 1, 1, 1 ]|
  374.  
  375. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  376. \Section{Eigenvalues}
  377.  
  378. 'Eigenvalues( <tbl>, <char>, <class> )'
  379.  
  380. Let $M$ be a matrix of a representation with character <char> which is
  381. a character of the table <tbl>, for an element in the conjugacy class
  382. <class>.
  383. 'Eigenvalues( <tbl>, <char>, <class> )' returns a list of length
  384. '$n$ = <tbl>.orders[ <class> ]' where at position 'i' the multiplicity
  385. of 'E(n)\^i = $e^{\frac{2\pi i}{n}}$' as eigenvalue of $M$ is stored.
  386.  
  387. |    gap> t:= CharTable( "A5" );;
  388.     gap> chi:= t.irreducibles[2];
  389.     [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ]
  390.     gap> List( [ 1 .. 5 ], i -> Eigenvalues( t, chi, i ) );
  391.     [ [ 3 ], [ 2, 1 ], [ 1, 1, 1 ], [ 0, 1, 1, 0, 1 ], [ 1, 0, 0, 1, 1 ] ]|
  392.  
  393. 'List( [1..<n>], i -> E(n)\^i) \*\ Eigenvalues(<tbl>,<char>,<class>) )'
  394. is equal to '<char>[ <class> ]'.
  395.  
  396. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  397. \Section{Reduced}\index{characters!reduced}
  398.  
  399. 'Reduced( <tbl>, <constituents>, <reducibles> )'\\
  400. 'Reduced( <tbl>, <reducibles> )'
  401.  
  402. returns a record with fields 'remainders' and 'irreducibles', both
  403. lists\:\ 
  404. Let 'rems' be the set of nonzero characters obtained from <reducibles>
  405. by subtraction of
  406.  
  407. \[ \sum_{\chi\in 'constituents'}
  408.    \frac{'ScalarProduct( <tbl>, \chi, <reducibles>[i] )'}
  409.         {'ScalarProduct( <tbl>, \chi, <constituents>[j] )'}
  410.    \cdot \chi \]
  411.  
  412. from '<reducibles>[i]' in the first case or subtraction of
  413.  
  414. \[ \sum_{j \leq i}
  415.    \frac{'ScalarProduct( <tbl>, <reducibles>[j], <reducibles>[i] )'}
  416.         {'ScalarProduct( <tbl>, <reducibles>[j], <reducibles>[j] )'}
  417.    \cdot <reducibles>[j] \]
  418.  
  419. in the second case.
  420.  
  421. Let 'irrs' be the list of irreducible characters in 'rems'.  'rems' is
  422. reduced with 'irrs' and all found irreducibles until no new irreducibles
  423. are found. Then 'irreducibles' is the set of all found irreducible
  424. characters, 'remainders' is the set of all nonzero remainders.
  425.  
  426. If one knows that <reducibles> are ordinary characters of <tbl> and 
  427. <constituents> are irreducible ones, "ReducedOrdinary" 'ReducedOrdinary'
  428. may be faster.
  429.  
  430. Note that elements of 'remainders' may be only virtual characters even if
  431. <reducibles> are ordinary characters.
  432.  
  433. |    gap> t:= CharTable( "A5" );;
  434.     gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;
  435.     gap> chars:= Set( Tensored( chars, chars ) );;
  436.     gap> Reduced( t, chars );
  437.     rec(
  438.       remainders := [  ],
  439.       irreducibles := 
  440.        [ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  441.           [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ], 
  442.           [ 5, 1, -1, 0, 0 ] ] )|
  443.  
  444. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  445. \Section{ReducedOrdinary}\index{characters!reduced}
  446.  
  447. 'ReducedOrdinary( <tbl>, <constituents>, <reducibles> )'
  448.  
  449. works like "Reduced" 'Reduced', but assumes that the elements of
  450. <constituents> and <reducibles> are ordinary characters of the character
  451. table <tbl>.
  452. So scalar products are calculated only for those pairs of characters
  453. where the degree of the constituent is smaller than the degree of the
  454. reducible.
  455.  
  456. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  457. \Section{Tensored}\index{characters!tensor products of}
  458.  
  459. 'Tensored( <chars1>, <chars2> )'
  460.  
  461. returns the list of tensor products (i.e. pointwise products) of all
  462. characters in the list <chars1> with all characters in the list <chars2>.
  463.  
  464. |    gap> t:= CharTable( "A5" );;
  465.     gap> chars1:= Sublist( t.irreducibles, [ 1 .. 3 ] );;
  466.     gap> chars2:= Sublist( t.irreducibles, [ 2 .. 3 ] );;
  467.     gap> Tensored( chars1, chars2 );
  468.     [ [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  469.       [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], 
  470.       [ 9, 1, 0, -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4,
  471.           -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4 ], [ 9, 1, 0, -1, -1 ],
  472.       [ 9, 1, 0, -1, -1 ],
  473.       [ 9, 1, 0, -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4, -2*E(5)-E(5)^2-E(5)^3
  474.              -2*E(5)^4 ] ]|
  475.  
  476. *Note* that duplicate tensor products are not deleted; the tensor product
  477. of '<chars1>[<i>]' with '<chars2>[<j>]' is stored at position
  478. $(i-1) 'Length( <chars1> )' + j$.
  479.  
  480. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  481. \Section{Symmetrisations}\index{characters!symmetrisations of}
  482.  
  483. 'Symmetrisations( <tbl>, <chars>, <Sn> )'\\
  484. 'Symmetrisations( <tbl>, <chars>, <n> )'
  485.  
  486. returns the list of nonzero symmetrisations of the characters <chars>,
  487. regarded as characters of the character table <tbl>, with the ordinary
  488. characters of the symmetric group of degree <n>; alternatively, the table
  489. of the symmetric group can be entered as <Sn>.
  490.  
  491. The symmetrisation $\chi^{[\lambda]}$ of the character $\chi$ of <tbl>
  492. with the character $\lambda$ of the symmetric group $S_n$ of degree $n$
  493. is defined by
  494. \[ \chi^{[\lambda]}(g) = \frac{1}{n!} \sum_{\rho \in S_n}
  495.                 \lambda(\rho) \prod_{k=1}^{n} \chi(g^k)^{a_k(\rho)}, \]
  496. where $a_k(\rho)$ is the number of cycles of length $k$ in $\rho$.
  497.  
  498. For special symmetrisations, see "SymmetricParts", "AntiSymmetricParts",
  499. "MinusCharacter" and "OrthogonalComponents", "SymplecticComponents".
  500.  
  501. |    gap> t:= CharTable( "A5" );;
  502.     gap> chars:= Sublist( t.irreducibles, [ 1 .. 3 ] );;
  503.     gap> Symmetrisations( t, chars, 3 );
  504.     [ [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ],
  505.       [ 1, 1, 1, 1, 1 ], [ 8, 0, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],
  506.       [ 10, -2, 1, 0, 0 ], [ 1, 1, 1, 1, 1 ],
  507.       [ 8, 0, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 10, -2, 1, 0, 0 ] ]|
  508.  
  509. *Note* that the returned list may contain zero characters, and duplicate
  510. characters are not deleted.
  511.  
  512. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  513. \Section{SymmetricParts}\index{characters!symmetrisations of}
  514.  
  515. 'SymmetricParts( <tbl>, <chars>, <n> )'
  516.  
  517. returns the list of symmetrisations of the characters <chars>,
  518. regarded as characters of the character table <tbl>, with the trivial
  519. character of the symmetric group of degree <n> (see "Symmetrisations").
  520.  
  521. |    gap> t:= CharTable( "A5" );;
  522.     gap> SymmetricParts( t, t.irreducibles, 3 );
  523.     [ [ 1, 1, 1, 1, 1 ], [ 10, -2, 1, 0, 0 ], [ 10, -2, 1, 0, 0 ], 
  524.       [ 20, 0, 2, 0, 0 ], [ 35, 3, 2, 0, 0 ] ]|
  525.  
  526. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  527. \Section{AntiSymmetricParts}\index{characters!symmetrisations of}
  528.  
  529. 'AntiSymmetricParts( <tbl>, <chars>, <n> )'
  530.  
  531. returns the list of symmetrisations of the characters <chars>,
  532. regarded as characters of the character table <tbl>, with the alternating
  533. character of the symmetric group of degree <n> (see "Symmetrisations").
  534.  
  535. |    gap> t:= CharTable( "A5" );;
  536.     gap> AntiSymmetricParts( t, t.irreducibles, 3 );
  537.     [ [ 0, 0, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 1 ], 
  538.       [ 4, 0, 1, -1, -1 ], [ 10, -2, 1, 0, 0 ] ]|
  539.  
  540. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  541. \Section{MinusCharacter}\index{characters!symmetrisations of}
  542.  
  543. 'MinusCharacter( <char>, <prime\_powermap>, <prime> )'
  544.  
  545. returns the (possibly parametrized, see chapter "Maps and Parametrized
  546. Maps") character $\chi^{p-}$ for the character $\chi = <char>$ and a
  547. prime $p = <prime>$, where $\chi^{p-}$ is defined by
  548. $\chi^{p-}(g) = ( \chi(g)^p - \chi(g^p) ) / p$, and
  549. <prime\_powermap> is the (possibly parametrized) $p$-th powermap.
  550.  
  551. |    gap> t:= CharTable( "S7" );; pow:= InitPowermap( t, 2 );;
  552.     gap> Congruences( t, t.irreducibles, pow, 2 );; pow;
  553.     [ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, 4, 6,
  554.       [ 7, 12 ] ]
  555.     gap> chars:= Sublist( t.irreducibles, [ 2 .. 5 ] );;
  556.     gap> List( chars, x-> MinusCharacter( x, pow, 2 ) );
  557.     [ [ 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, [ 0, 1 ] ],
  558.       [ 15, -1, 3, 0, [ -2, -1, 0 ], 0, -1, 1, 5, -3, [ 0, 1, 2 ], -1, 0,
  559.           0, [ 0, 1 ] ], 
  560.       [ 15, -1, 3, 0, [ -1, 0, 2 ], 0, -1, 1, 5, -3, [ 1, 2, 4 ], -1, 0,
  561.           0, 1 ],
  562.       [ 190, -2, 1, 1, [ 0, 2 ], 0, 1, 1, -10, -10, [ 0, 2 ], -1, -1, 0,
  563.           [ -1, 0 ] ] ]|
  564.  
  565. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  566. \Section{OrthogonalComponents}\index{symmetrizations!orthogonal}%
  567. \index{Frame}\index{Murnaghan components}
  568.  
  569. 'OrthogonalComponents( <tbl>, <chars>, <m> )'
  570.  
  571. If $\chi$ is a (nonlinear) character with indicator $+1$, a splitting
  572. of the tensor power $\chi^m$ is given by the so-called Murnaghan
  573. functions (see~\cite{Mur58}).  These components in general have fewer
  574. irreducible constituents than the symmetrizations with the symmetric
  575. group of degree <m> (see "Symmetrisations").
  576.  
  577. 'OrthogonalComponents' returns the set of orthogonal symmetrisations of
  578. the characters of the character table <tbl> in the list <chars>, up to
  579. the power <m>, where the integer <m> is one of $\{ 2, 3, 4, 5, 6 \}$.
  580.  
  581. *Note*\:\ It is not checked if all characters in <chars> do really have
  582. indicator $+1$; if there are characters with indicator 0 or $-1$, the
  583. result might contain virtual characters, see also "SymplecticComponents".
  584.  
  585. The Murnaghan functions are implemented as in~\cite{Fra82}.
  586.  
  587. |    gap> t:= CharTable( "A8" );; chi:= t.irreducibles[2];
  588.     [ 7, -1, 3, 4, 1, -1, 1, 2, 0, -1, 0, 0, -1, -1 ]
  589.     gap> OrthogonalComponents( t, [ chi ], 4 );
  590.     [ [ 21, -3, 1, 6, 0, 1, -1, 1, -2, 0, 0, 0, 1, 1 ], 
  591.       [ 27, 3, 7, 9, 0, -1, 1, 2, 1, 0, -1, -1, -1, -1 ], 
  592.       [ 105, 1, 5, 15, -3, 1, -1, 0, -1, 1, 0, 0, 0, 0 ], 
  593.       [ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ], 
  594.       [ 77, -3, 13, 17, 2, 1, 1, 2, 1, 0, 0, 0, 2, 2 ], 
  595.       [ 189, -3, -11, 9, 0, 1, 1, -1, 1, 0, 0, 0, -1, -1 ], 
  596.       [ 330, -6, 10, 30, 0, -2, -2, 0, -2, 0, 1, 1, 0, 0 ], 
  597.       [ 168, 8, 8, 6, -3, 0, 0, -2, 2, -1, 0, 0, 1, 1 ], 
  598.       [ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ], 
  599.       [ 182, 6, 22, 29, 2, 2, 2, 2, 1, 0, 0, 0, -1, -1 ] ]|
  600.  
  601. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  602. \Section{SymplecticComponents}\index{symmetrizations!symplectic}%
  603. \index{Murnaghan components}
  604.  
  605. 'SymplecticComponents( <tbl>, <chars>, <m> )'
  606.  
  607. If $\chi$ is a (nonlinear) character with indicator $-1$, a splitting
  608. of the tensor power $\chi^m$ is given in terms of the so-called
  609. Murnaghan functions (see~\cite{Mur58}).  These components in general
  610. have fewer irreducible constituents than the symmetrizations with the
  611. symmetric group of degree <m> (see "Symmetrisations").
  612.  
  613. 'SymplecticComponents' returns the set of symplectic symmetrisations of
  614. the characters of the character table <tbl> in the list <chars>, up to
  615. the power <m>, where the integer <m> is one of $\{ 2, 3, 4, 5 \}$.
  616.  
  617. *Note*\:\ It is not checked if all characters in <chars> do really have
  618. indicator $-1$; if there are characters with indicator 0 or $+1$, the
  619. result might contain virtual characters, see also "OrthogonalComponents".
  620.  
  621. |    gap> t:= CharTable( "U3(3)" );; chi:= t.irreducibles[2];
  622.     [ 6, -2, -3, 0, -2, -2, 2, 1, -1, -1, 0, 0, 1, 1 ]
  623.     gap> SymplecticComponents( t, [ chi ], 4 );
  624.     [ [ 14, -2, 5, -1, 2, 2, 2, 1, 0, 0, 0, 0, -1, -1 ], 
  625.       [ 21, 5, 3, 0, 1, 1, 1, -1, 0, 0, -1, -1, 1, 1 ], 
  626.       [ 64, 0, -8, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 ], 
  627.       [ 14, 6, -4, 2, -2, -2, 2, 0, 0, 0, 0, 0, -2, -2 ], 
  628.       [ 56, -8, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ], 
  629.       [ 70, -10, 7, 1, 2, 2, 2, -1, 0, 0, 0, 0, -1, -1 ], 
  630.       [ 189, -3, 0, 0, -3, -3, -3, 0, 0, 0, 1, 1, 0, 0 ], 
  631.       [ 90, 10, 9, 0, -2, -2, -2, 1, -1, -1, 0, 0, 1, 1 ], 
  632.       [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 
  633.       [ 126, 14, -9, 0, 2, 2, 2, -1, 0, 0, 0, 0, -1, -1 ] ]|
  634.  
  635. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  636. \Section{IrreducibleDifferences}
  637. \index{characters!irreducible differences of}
  638.  
  639. 'IrreducibleDifferences( <tbl>, <chars1>, <chars2> )'\\
  640. 'IrreducibleDifferences( <tbl>, <chars1>, <chars2>, <scprmat> )'\\
  641. 'IrreducibleDifferences( <tbl>, <chars>, \"triangle\" )'\\
  642. 'IrreducibleDifferences( <tbl>, <chars>, \"triangle\", <scprmat> )'
  643.  
  644. returns the list of irreducible characters which occur as difference of
  645. two elements of <chars> (if '\"triangle\"' is specified) or of an
  646. element of <chars1> and an element of <chars2>; if <scprmat> is not
  647. specified it will be computed (see "MatScalarProducts"), otherwise we
  648. must have
  649. \[ '<scprmat>[i][j] = ScalarProduct( <tbl>, <chars>[i], <chars>[j] )'
  650. \] resp. \[
  651.    '<scprmat>[i][j] = ScalarProduct( <tbl>, <chars1>[i], <chars2>[j] )'
  652. \].
  653.  
  654. |    gap> t:= CharTable( "A5" );;
  655.     gap> chars:= Sublist( t.irreducibles, [ 2 .. 4 ] );;
  656.     gap> chars:= Set( Tensored( chars, chars ) );;
  657.     gap> IrreducibleDifferences( t, chars, "triangle" );
  658.     [ [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  659.       [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ]|
  660.  
  661. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  662. \Section{Restricted}\index{characters!restricted}
  663.  
  664. 'Restricted( <tbl>, <subtbl>, <chars> )'\\
  665. 'Restricted( <tbl>, <subtbl>, <chars>, <specification> )'\\
  666. 'Restricted( <chars>, <fusionmap> )'
  667.  
  668. returns the restrictions, i.e. the indirections, of the characters in the
  669. list <chars> by a subgroup fusion map.
  670. This map can either be entered directly as <fusionmap>, or it must be
  671. stored on the character table <subtbl> and must have destination <tbl>;
  672. in the latter case the value of the 'specification' field of the desired
  673. fusion may be specified as <specification> (see "GetFusionMap").
  674. If no such fusion is stored, 'false' is returned.
  675.  
  676. The fusion map may be a parametrized map
  677. (see "More about Maps and Parametrized Maps");
  678. any value that is not uniquely determined in a restricted character is
  679. set to an unknown (see "Unknown"); for parametrized indirection of
  680. characters, see "CompositionMaps".
  681.  
  682. Restriction and inflation are the same procedures, so 'Restricted'
  683. and 'Inflated' are identical, see "Inflated".
  684.  
  685. |    gap> s5:= CharTable( "A5.2" );; a5:= CharTable( "A5" );;
  686.     gap> Restricted( s5, a5, s5.irreducibles );
  687.     [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 1, 1, 1 ], [ 6, -2, 0, 1, 1 ], 
  688.       [ 4, 0, 1, -1, -1 ], [ 4, 0, 1, -1, -1 ], [ 5, 1, -1, 0, 0 ], 
  689.       [ 5, 1, -1, 0, 0 ] ]
  690.     gap> Restricted( s5.irreducibles, [ 1, 6, 2, 6 ] );
  691.                         # restrictions to the cyclic group of order 4
  692.     [ [ 1, 1, 1, 1 ], [ 1, -1, 1, -1 ], [ 6, 0, -2, 0 ], [ 4, 0, 0, 0 ], 
  693.       [ 4, 0, 0, 0 ], [ 5, -1, 1, -1 ], [ 5, 1, 1, 1 ] ]|
  694.  
  695. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  696. \Section{Inflated}\index{characters!inflate}
  697.  
  698. 'Inflated( <factortbl>, <tbl>, <chars> )'\\
  699. 'Inflated( <factortbl>, <tbl>, <chars>, <specification> )'\\
  700. 'Inflated( <chars>, <fusionmap> )'
  701.  
  702. returns the inflations, i.e. the indirections of <chars> by a factor
  703. fusion map.  This map can either be entered directly as <fusionmap>, or
  704. it must be stored on the character table <tbl> and must have destination
  705. <factortbl>; in the latter case the value of the 'specification' field
  706. of the desired fusion may be specified as <specification> (see
  707. "GetFusionMap").  If no such fusion is stored, 'false' is returned.
  708.  
  709. The fusion map may be a parametrized map (see "More about Maps and
  710. Parametrized Maps"); any value that is not uniquely determined in an
  711. inflated character is set to an unknown (see "Unknown"); for parametrized
  712. indirection of characters, see "CompositionMaps".
  713.  
  714. Restriction and inflation are the same procedures, so 'Restricted'
  715. and 'Inflated' are identical, see "Restricted".
  716.  
  717. |    gap> s4:= CharTable( "Symmetric", 4 );;
  718.     gap> s3:= CharTableFactorGroup( s4, [3] );;
  719.     gap> s3.irreducibles;
  720.     [ [ 1, -1, 1 ], [ 2, 0, -1 ], [ 1, 1, 1 ] ]
  721.     gap> s4.fusions;
  722.     [ rec(
  723.           map := [ 1, 2, 1, 3, 2 ],
  724.           type := "factor",
  725.           name := "S4modulo[ 3 ]" ) ]
  726.     gap> Inflated( s3, s4, s3.irreducibles );
  727.     [ [ 1, -1, 1, 1, -1 ], [ 2, 0, 2, -1, 0 ], [ 1, 1, 1, 1, 1 ] ]|
  728.  
  729. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  730. \Section{Induced}\index{characters!induced}
  731.  
  732. 'Induced( <subtbl>, <tbl>, <chars> )'\\
  733. 'Induced( <subtbl>, <tbl>, <chars>, <specification> )'\\
  734. 'Induced( <subtbl>, <tbl>, <chars>, <fusionmap> )'
  735.  
  736. returns a set of characters induced from <subtbl> to <tbl>; the elements
  737. of the list <chars> will be induced. The subgroup fusion map can either
  738. be entered directly as <fusionmap>, or it must be stored on the table
  739. <subtbl> and must have destination <tbl>; in the latter case the value
  740. of the 'specification' field may be specified by <specification>
  741. (see "GetFusionMap"). If no such fusion is stored, 'false' is returned.
  742.  
  743. The fusion map may be a parametrized map
  744. (see "More about Maps and Parametrized Maps");
  745. any value that is not uniquely determined in an induced character is set
  746. to an unknown (see "Unknown").
  747.  
  748. |    gap> Induced( a5, s5, a5.irreducibles );
  749.     [ [ 2, 2, 2, 2, 0, 0, 0 ], [ 6, -2, 0, 1, 0, 0, 0 ],
  750.       [ 6, -2, 0, 1, 0, 0, 0 ], [ 8, 0, 2, -2, 0, 0, 0 ],
  751.       [ 10, 2, -2, 0, 0, 0, 0 ] ]|
  752.  
  753. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  754. \Section{InducedCyclic}\index{characters!induce from cyclic subgroups}
  755. 'InducedCyclic( <tbl> )'\\
  756. 'InducedCyclic( <tbl>, \"all\" )'\\
  757. 'InducedCyclic( <tbl>, <classes> )'\\
  758. 'InducedCyclic( <tbl>, <classes>, \"all\" )'
  759.  
  760. returns a set of characters of the character table <tbl>. They are
  761. characters induced from cyclic subgroups of <tbl>.
  762. If '\"all\"' is specified, all irreducible characters
  763. of those subgroups are induced, otherwise only the permutation characters
  764. are computed. If a list <classes> is specified, only those cyclic
  765. subgroups generated by these classes are considered, otherwise all
  766. classes of <tbl> are considered.
  767.  
  768. Note that the powermaps for primes dividing '<tbl>.order' must be stored
  769. on <tbl>; if any powermap for a prime not dividing '<tbl>.order' that is
  770. smaller than the maximal representative order is not stored, this map
  771. will be computed (see "Powermap") and stored afterwards.
  772.  
  773. The powermaps may be parametrized maps
  774. (see "More about Maps and Parametrized Maps");
  775. any value that is not uniquely determined in an induced character is set
  776. to an unknown (see "Unknown").
  777. The representative orders of the classes to induce from must not be
  778. parametrized (see "More about Maps and Parametrized Maps").
  779.  
  780. |    gap> t:= CharTable( "A5" );; InducedCyclic( t, "all" );
  781.     [ [ 12, 0, 0, 2, 2 ], [ 12, 0, 0, E(5)^2+E(5)^3, E(5)+E(5)^4 ], 
  782.       [ 12, 0, 0, E(5)+E(5)^4, E(5)^2+E(5)^3 ], [ 20, 0, -1, 0, 0 ], 
  783.       [ 20, 0, 2, 0, 0 ], [ 30, -2, 0, 0, 0 ], [ 30, 2, 0, 0, 0 ], 
  784.       [ 60, 0, 0, 0, 0 ] ]|
  785.  
  786. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  787. \Section{CollapsedMat}\index{classes!collapse}
  788.  
  789. 'CollapsedMat( <mat>, <maps> )'
  790.  
  791. returns a record with fields 'mat' and 'fusion'\:\ 
  792. The 'fusion' field contains the fusion that collapses the columns of
  793. <mat> that are identical also for all maps in the list <maps>, the 'mat'
  794. field contains the image of <mat> under that fusion.
  795.  
  796. |    gap> t.irreducibles;
  797.     [ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
  798.       [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ], 
  799.       [ 5, 1, -1, 0, 0 ] ]
  800.     gap> t:= CharTable( "A5" );; RationalizedMat( t.irreducibles );
  801.     [ [ 1, 1, 1, 1, 1 ], [ 6, -2, 0, 1, 1 ], [ 4, 0, 1, -1, -1 ], 
  802.       [ 5, 1, -1, 0, 0 ] ]
  803.     gap> CollapsedMat( last, [] );
  804.     rec(
  805.       mat := [ [ 1, 1, 1, 1 ], [ 6, -2, 0, 1 ], [ 4, 0, 1, -1 ], 
  806.           [ 5, 1, -1, 0 ] ],
  807.       fusion := [ 1, 2, 3, 4, 4 ] )
  808.     gap> Restricted( last.mat, last.fusion );
  809.     [ [ 1, 1, 1, 1, 1 ], [ 6, -2, 0, 1, 1 ], [ 4, 0, 1, -1, -1 ], 
  810.       [ 5, 1, -1, 0, 0 ] ]|
  811.  
  812. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  813. \Section{Power}
  814.  
  815. 'Power( <powermap>, <chars>, <n> )'
  816.  
  817. returns the list of indirections of the characters <chars> by the <n>-th
  818. powermap; for a character $\chi$ in <chars>, this indirection is often
  819. called $\chi^{(n)}$.  The powermap is calculated from the (necessarily
  820. stored) powermaps of the prime divisors of <n> if it is not stored in
  821. <powermap> (see "Powmap").
  822.  
  823. *Note* that $\chi^{(n)}$ is in general only a virtual characters.
  824.  
  825.  
  826. |    gap> t:= CharTable( "A5" );; Power( t.powermap, t.irreducibles, 2 );
  827.     [ [ 1, 1, 1, 1, 1 ], [ 3, 3, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], 
  828.       [ 3, 3, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], [ 4, 4, 1, -1, -1 ], 
  829.       [ 5, 5, -1, 0, 0 ] ]
  830.     gap> MatScalarProducts( t, t.irreducibles, last );
  831.     [ [ 1, 0, 0, 0, 0 ], [ 1, -1, 0, 0, 1 ], [ 1, 0, -1, 0, 1 ], 
  832.       [ 1, -1, -1, 1, 1 ], [ 1, -1, -1, 0, 2 ] ]|
  833.  
  834. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  835. \Section{Permutation Character Candidates}\index{characters!permutation}%
  836. \index{candidates!for permutation characters}%
  837. \index{permutation characters!candidates for}
  838.  
  839. For groups $H, G$ with $H\leq G$, the induced character $(1_G)^H$ is
  840. called the *permutation character* of the operation of $G$ on the right
  841. cosets of $H$.  If only the character table of $G$ is known, one can try
  842. to get informations about possible subgroups of $G$ by inspection of
  843. those characters $\pi$ which might be permutation characters, using that
  844. such a character must have at least the following properties\:
  845.  
  846. :$\pi(1)$ divides $\|G\|$,
  847.  
  848. :$[\pi,\psi]\leq\psi(1)$ for each character $\psi$ of $G$,
  849.  
  850. :$[\pi,1_G]=1$,
  851.  
  852. :$\pi(g)$ is a nonnegative integer for $g \in G$,
  853.  
  854. :$\pi(g)$ is smaller than the centralizer order of $g$ for
  855.       $1\not= g\in G$,
  856.  
  857. :$\pi(g)\leq\pi(g^m)$ for $g\in G$ and any integer $m$,
  858.  
  859. :$\pi(g)=0$ for every $\|g\|$ not diving $\frac{\|G\|}{\pi(1)}$,
  860.  
  861. :$\pi(1) \|N_G(g)\|$ divides $\|G\| \pi(g)$, where $\|N_G(g)\|$ denotes
  862.       the normalizer order of $\langle g \rangle$.
  863.  
  864. Any character with these properties will be called a
  865. *permutation character candidate* from now on.
  866.  
  867. {\GAP} provides some algorithms to compute permutation character
  868. candidates, see "PermChars".  Some information about the subgroup
  869. can computed from a permutation character using "PermCharInfo".
  870.  
  871. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  872. \Section{IsPermChar}\index{characters!permutation}%
  873. \index{candidates!for permutation characters}%
  874. \index{permutation characters!candidates for}
  875.  
  876. 'IsPermChar( <tbl>, <pi> )'
  877.  
  878. *missing, like tests* 'TestPerm1', 'TestPerm2', 'TestPerm3'
  879.  
  880. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  881. \Section{PermCharInfo}\index{subgroup and permutation character}
  882.  
  883. 'PermCharInfo( <tbl>, <permchars> )'
  884.  
  885. Let <tbl> be the character table of the group $G$, and <permchars> the
  886. permutation character $(1_U)^G$ for a subgroup $U$ of $G$, or a list
  887. of such characters.
  888. 'PermCharInfo' returns a record with components
  889.  
  890. 'contained':\\
  891.   a list containing for each character in <permchars> a list containing
  892.   at position <i> the number of elements of $U$ that are contained in
  893.   class <i> of <tbl>, this is equal to
  894.   $'permchar[<i>]' \|U\| / 'tbl.centralizers[<i>]'$,
  895.   
  896. 'bound':\\
  897.   Let '<permchars>[k]' be the permutation character $(1_U)^G$.  Then the
  898.   class length in $U$ of an element in class <i> of <tbl> must be a
  899.   multiple of the value
  900.   $'bound[<k>][<i>]' = \|U\| / \gcd( \|U\|, '<tbl>.centralizers[<i>]' )$,
  901.  
  902. 'display':\\
  903.   a record that can be used as second argument of 'DisplayCharTable'
  904.   to display the permutation characters and the corresponding components
  905.   'contained' and 'bound', for the classes where at least one character
  906.   of <permchars> is nonzero,
  907.  
  908. 'ATLAS':\\
  909.   list of strings containing for each character in <permchars> the
  910.   decomposition into '<tbl>.irreducibles' in {\ATLAS} notation.
  911.  
  912. |    gap> t:= CharTable("A6");;
  913.     gap> PermCharInfo( t, [ 15, 3, 0, 3, 1, 0, 0 ] );
  914.     rec(
  915.       contained := [ [ 1, 9, 0, 8, 6, 0, 0 ] ],
  916.       bound := [ [ 1, 3, 8, 8, 6, 24, 24 ] ],
  917.       display := rec(
  918.           classes := [ 1, 2, 4, 5 ],
  919.           chars := [ [ 15, 3, 0, 3, 1, 0, 0 ], [ 1, 9, 0, 8, 6, 0, 0 ],
  920.               [ 1, 3, 8, 8, 6, 24, 24 ] ],
  921.           letter := "I" ),
  922.       ATLAS := [ "1a+5b+9a" ] )
  923.     gap> DisplayCharTable( t, last.display );
  924.     A6
  925.     
  926.        2  3  3  .  2
  927.        3  2  .  2  .
  928.        5  1  .  .  .
  929.     
  930.          1a 2a 3b 4a
  931.       2P 1a 1a 3b 2a
  932.       3P 1a 2a 1a 4a
  933.       5P 1a 2a 3b 4a
  934.     
  935.     I.1  15  3  3  1
  936.     I.2   1  9  8  6
  937.     I.3   1  3  8  6|
  938.  
  939. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  940. \Section{Inequalities}
  941.  
  942. 'Inequalities( <tbl> )'
  943.  
  944. The condition $\pi(g) \geq 0$ for every permutation character candidate
  945. $\pi$ places restrictions on the multiplicities $a_i$ of the irreducible
  946. constituents $\chi_i$ of $\pi = \sum_{i=1}^r a_i \chi_i$.
  947. For every group element $g$ holds $\sum_{i=1}^r a_i \chi_i(g) \geq 0$.
  948. The power map provides even stronger conditions.
  949.  
  950. This system of inequalities is kind of diagonalized, resulting in a
  951. system of inequalities restricting $a_i$ in terms of $a_j, j \< i$.
  952. These inequalities are used to construct characters with nonnegative
  953. values (see "PermChars").
  954. 'PermChars' either calls 'Inequalities' or takes this information from
  955. the record field 'ineq' of its argument record.
  956.  
  957. The number of inequalities arising in the process of diagonalization may
  958. grow very strong. 
  959.  
  960. There are two strategies to perform this diagonalization. The default is
  961. to simply eliminate one unknown $a_i$ after the other with decreasing
  962. $i$.  In some cases it turns out to be better first to look which choice
  963. for the next unknown will yield the fewest new inequalities.
  964.  
  965. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  966. \Section{PermBounds}
  967.  
  968. 'PermBounds( <tbl> )'
  969.  
  970. All characters $\pi$ satisfying $\pi(g) > 0$ and $\pi(1) = d$ for a given
  971. degree $d$ lie in a simplex described by these conditions. 'PermBounds'
  972. computes the boundary points of this simplex for $d = 0$, from which the
  973. boundary points for any other $d$ are easily derived.
  974. Some conditions from the powermap are also involved.
  975.  
  976. For this purpose a matrix similar to the rationalized character table
  977. has to be inverted.
  978.  
  979. These boundary points are used by 'PermChars' (see "PermChars") to 
  980. construct all permutation character candidates of a given degree.
  981. 'PermChars' either calls 'PermBounds' or takes this information from
  982. the record field 'bounds' of its argument record.
  983.  
  984. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  985. \Section{PermChars} \index{permutation characters}
  986.  
  987. 'PermChars( <tbl> )' \\
  988. 'PermChars( <tbl>, <degree> )' \\
  989. 'PermChars( <tbl>, <arec> )'
  990.  
  991. {\GAP} provides  several  algorithms to  determine  permutation character
  992. candidates from a given  character table.  The algorithm is selected from
  993. the  choice of the  record fields of the optional argument record <arec>.
  994. The  user is  encouraged to  try different approaches  especially  if one
  995. choice fails to come to an end.
  996.  
  997. Regardless of the algorithm used in a special case, 'PermChars' returns a
  998. list of *all* permutation character candidates with  the properties given
  999. in <arec>.  There is no guarantee  that  a character of this  list  is in
  1000. fact a  permutation character. But an empty list always means there is no
  1001. permutation character with these properties (e.g.\ of a certain degree).
  1002.  
  1003. In  the  first  form  'PermChars(  <tbl>  )'  returns  the  list  of  all
  1004. permutation characters of the group with character table <tbl>. This list
  1005. might be  rather long  for big groups, and it might take  much time.  The
  1006. algorithm depends on a preprocessing step, where the inequalities arising
  1007. from the  condition  $\pi(g)  \leq  0$ are transformed  into  a system of
  1008. inequalities that guides the search (see "Inequalities").
  1009.  
  1010. |    gap> m11:= CharTable("M11");;
  1011.     gap> PermChars(m11);;     # will return the list of 39 permutation
  1012.                               # character candidates of $M11$. |
  1013.  
  1014. There are two different search strategies for  this algorithm. One simply
  1015. constructs all characters with nonnegative values and then tests for each
  1016. such character whether its degree is a divisor of the order of the group.
  1017. This is the default.  The other strategy uses the inequalities to predict
  1018. if  it  is  possible  to find  a character of  a  certain degree  in  the
  1019. currently  searched part of the search tree. To choose this strategy set
  1020. the field 'mode' of <arec> to '\"preview\"' and the field 'degree' to the
  1021. degree (or a list of degrees  which might be all divisors of the order of
  1022. the group) you want to look for.  The  record field  'ineq' can  take the
  1023. inequalities from 'Inequalities' if they are needed more than once.
  1024.  
  1025. In the second form 'PermChars( <tbl>, <degree> )' returns the list of all
  1026. permutation  characters  of  degree  <degree>.    For   that  purpose   a
  1027. preprocessing  step  is  performed  where  essentially  the  rationalized
  1028. character table is inverted in order to determine boundary points for the
  1029. simplex in which  the permutation character candidates of a given  degree
  1030. must lie (see  "PermBounds").   Note that inverting big  integer matrices
  1031. needs  a  lot of time and space.  So this preprocessing is  restricted to
  1032. groups with less than 100 classes, say.
  1033.  
  1034. |    gap> PermChars(m11, 220);                                           
  1035.     [ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ], 
  1036.       [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ], 
  1037.       [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ] |
  1038.  
  1039. In the third form 'PermChars( <tbl>, <arec>  )' returns  the list of  all
  1040. permutation  characters which have the properties given  in  the argument
  1041. record  <arec>. If <arec> contains a  degree in the record field 'degree'
  1042. then 'PermChars' will behave exactly as in the second form.
  1043.  
  1044. |    gap> PermChars(m11, rec(degree:= 220));                             
  1045.     [ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ], 
  1046.       [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ], 
  1047.       [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ] |
  1048.  
  1049. Alternatively <arec> may  have the  record  fields 'chars'  and  'torso'.
  1050. <arec>.'chars' is  a list  of (in most cases  all) *rational* irreducible
  1051. characters   of  <tbl>  which  might  be  constituents  of  the  required
  1052. characters, and <arec>.'torso' is a list that  contains some known values
  1053. of the required characters at the right positions.
  1054.  
  1055. *Note*\:\ At least the degree '<arec>.torso[1]'  must be an integer.   If
  1056. <arec>.'chars' does not contain  all  rational irreducible characters  of
  1057. $G$,  it may happen  that any scalar  product of  $\pi$ with  an  omitted
  1058. character is negative; there should be nontrivial reasons for excluding a
  1059. character that is known to be not a constituent of $\pi$.
  1060.  
  1061. |    gap> rat:= RationalizedMat(m11.irreducibles);;
  1062.     gap> PermChars(m11, rec(torso:= [220], chars:= rat));          
  1063.     [ [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ], 
  1064.       [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ], 
  1065.       [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ] 
  1066.     gap> PermChars(m11, rec(torso:= [220,,,,,2], chars:= rat));
  1067.     [ [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ] |
  1068.  
  1069. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1070. \Section{Faithful Permutation Characters}
  1071. \index{permutation characters!faithful candidates for}
  1072.  
  1073. 'PermChars( <tbl>, <arec> )'
  1074.  
  1075. 'PermChars' may as  well  determine faithful candidates  for  permutation
  1076. characters. In  that  case  <arec>  requires the  fields  'normalsubgrp',
  1077. 'nonfaithful', 'chars', 'lower', 'upper', and 'torso'.
  1078.  
  1079. Let <tbl> be the character table  of the group $G$, <arec>.'normalsubgrp'
  1080. a   list   of  classes   forming   a   normal   subgroup   $N$  of   $G$.
  1081. <arec>.'nonfaithful'   is   a   permutation   character   candidate  (see
  1082. "Permutation   Character   Candidates")   of   $G$   with   kernel   $N$.
  1083. <arec>.'chars' is a  list  of (in  most cases  all)  rational irreducible
  1084. characters of <tbl>.
  1085.  
  1086. 'PermChars' computes  all those  permutation character  candidates  $\pi$
  1087. having following properties\:
  1088.  
  1089. :  <arec>.'chars'  contains  every  rational  irreducible  constituent of
  1090. $\pi$.
  1091.  
  1092. :  $\pi[i] \geq  <arec>.'lower'[i]$ for  all integer  values of the  list
  1093. <arec>.'lower'.
  1094.  
  1095. :  $\pi[i] \leq <arec>.'upper'[i]$  for  all integer values  of  the list
  1096. <arec>.'upper'.
  1097.  
  1098. :  $\pi[i]  =  <arec>.'torso'[i]$  for  all  integer  values  of the list
  1099. <arec>.'torso'.
  1100.  
  1101. : No irreducible constituent of $\pi-<arec>.'nonfaithful'$ has $N$ in its
  1102. kernel.
  1103.  
  1104. If  there exists a subgroup $V$ of $G$, $V \geq N$, with $<nonfaithful> =
  1105. (1_V)^G$, the last condition means that the candidates for those possible
  1106. subgroups $U$ with $V = UN$ are constructed.
  1107.  
  1108. *Note*\:  At  least  the degree  $<torso>[1]$ must  be  an  integer.   If
  1109. <chars> does  not contain all  rational irreducible characters of $G$, it
  1110. may  happen that any scalar product of $\pi$ with an omitted character is
  1111. negative;  there should be nontrivial  reasons  for excluding a character
  1112. that is known to be not a constituent of $\pi$.
  1113.  
  1114. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1115. \Section{LLL-Algorithm}\index{lll}%
  1116. \index{short vectors spanning a lattice}\index{LLLReducedGramMat}
  1117.  
  1118. 'LLL( <lattice>, <vectors> [, <c>] [, \"sort\"] [, \"linearcomb\"] )'
  1119.  
  1120. The LLL-Algorithm by Lenstra, Lenstra and Lov{\accent19 a}sz
  1121. (see~\cite{LLL82}, \cite{Poh87}) reduces a given set <vectors> of vectors
  1122. in order to find shorter ones spanning the same lattice; more precisely,
  1123. given a generating set <vectors> of a lattice, 'LLL' computes a base for
  1124. the lattice.  <lattice> must be a record with
  1125. '<lattice>.operations.ScalarProduct' denoting the scalar product of the
  1126. lattice.
  1127.  
  1128. Character theory is a special case; the usage is described by
  1129.  
  1130. 'LLL( <tbl>, <reducibles> [, <c>] [, \"sort\"] [, \"linearcomb\"] )'
  1131.  
  1132. where <reducibles> is a set of reducible characters of the character
  1133. table <tbl> (see "ScalarProduct").  By finding shorter vectors, i.e.
  1134. virtual characters of smaller norm, in some cases 'LLL' is able to find
  1135. irreducibles.
  1136.  
  1137. 'LLL' returns a record with at least fields 'irreducibles' (the set of
  1138. found irreducible
  1139. characters), 'remainders' (a set of reducible virtual characters) and
  1140. 'norms' (the list of norms of 'remainders'); the lattice is spanned by
  1141. 'irreducibles' together with 'remainders'.
  1142.  
  1143. There are some optional parameters\:
  1144.  
  1145. <c>:\\ controls the sensitivity of the algorithm; the value of <c> must
  1146.        be between $1/4$ and 1, the default value is $3/4$.
  1147.  
  1148. '\"sort\"':\\
  1149.        'LLL' sorts the given characters by degree and also sorts
  1150.        the remaining characters.
  1151.  
  1152. '\"linearcomb\"':\\ The returned record contains fields 'irreddecomp' and
  1153.        'reddecomp' which are decomposition matrices of 'irreducibles' and
  1154.        'remainders', with respect to <reducibles>.
  1155.  
  1156. |    gap> s4:= CharTable( "Symmetric", 4 );;
  1157.     gap> chars:= [ [ 8, 0, 0, -1, 0 ], [ 6, 0, 2, 0, 2 ],
  1158.     >     [ 12, 0, -4, 0, 0 ], [ 6, 0, -2, 0, 0 ], [ 24, 0, 0, 0, 0 ],
  1159.     >     [ 12, 0, 4, 0, 0 ], [ 6, 0, 2, 0, -2 ], [ 12, -2, 0, 0, 0 ],
  1160.     >     [ 8, 0, 0, 2, 0 ], [ 12, 2, 0, 0, 0 ], [ 1, 1, 1, 1, 1 ] ];;
  1161.     gap> LLL( s4, chars );
  1162.     rec(
  1163.       irreducibles :=
  1164.        [ [ 2, 0, 2, -1, 0 ], [ 1, 1, 1, 1, 1 ], [ 3, 1, -1, 0, -1 ], 
  1165.           [ 3, -1, -1, 0, 1 ], [ 1, -1, 1, 1, -1 ] ],
  1166.       remainders := [  ],
  1167.       norms := [  ] )|
  1168.  
  1169. \vspace{5mm}
  1170. 'LLLReducedGramMat( <G> )'
  1171.  
  1172. If the lattice is given implicitly by its Gram matrix $G$, the LLL
  1173. algorithm can be applied to $G$, yielding the Gram matrix $R$ of the
  1174. LLL reduced lattice.  If $G$ is singular, $R$ may contain some lines
  1175. consisting of zeros; the regular part of $R$ can then be used to
  1176. compute orthogonal embeddings of the lattice (see "OrthogonalEmbeddings").
  1177. 'LLLReducedGramMat' returns a record with components
  1178.  
  1179. 'remainder':      the matrix $R$,
  1180.  
  1181. 'transformation': a matrix $T$ with $T^{tr}GT=R$,
  1182.  
  1183. 'scalarproducts' and 'bsnorms': some information used e.g. by 
  1184.                                 "ShortestVectors" 'ShortestVectors'
  1185.  
  1186. For more information see~\cite{LLL82}.
  1187.  
  1188. |    gap> g:= [ [ 4, 6, 5, 2, 2 ], [ 6, 13, 7, 4, 4 ],
  1189.     >    [ 5, 7, 11, 2, 0 ], [ 2, 4, 2, 8, 4 ], [ 2, 4, 0, 4, 8 ] ];;
  1190.     gap> LLLReducedGramMat( g );
  1191.     rec(
  1192.       remainder :=
  1193.        [ [ 4, 2, 1, 2, 2 ], [ 2, 5, 0, 2, 2 ], [ 1, 0, 5, 0, -2 ], 
  1194.           [ 2, 2, 0, 8, 4 ], [ 2, 2, -2, 4, 8 ] ],
  1195.       transformation := 
  1196.        [ [ 1, 0, 0, 0, 0 ], [ -1, 1, 0, 0, 0 ], [ -1, 0, 1, 0, 0 ], 
  1197.           [ 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 1 ] ],
  1198.       scalarproducts := 
  1199.        [ [ 1, 0, 0, 0, 0 ], [ 1/2, 1, 0, 0, 0 ], [ 1/4, -1/8, 1, 0, 0 ], 
  1200.           [ 1/2, 1/4, -2/25, 1, 0 ], [ 1/2, 1/4, -38/75, 8/21, 1 ] ],
  1201.       bsnorms := [ 4, 4, 75/16, 168/25, 32/7 ] )|
  1202.  
  1203. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1204. \Section{OrthogonalEmbeddings}\index{embeddings of lattices}
  1205. \index{OrthogonalEmbeddingsSpecialDimension}
  1206.  
  1207. 'OrthogonalEmbeddings( <G> [, \"positive\" ] [, <maxdim> ] )'
  1208.  
  1209. computes all possible orthogonal embeddings of a lattice given by its
  1210. Gram matrix $G$ which must be a regular matrix (see "LLL-Algorithm").
  1211. In other words, all solutions $X$ of the problem 
  1212.  
  1213. \[ X^{tr} X = G \]
  1214.  
  1215. are calculated (see~\cite{Ple90}).  Usually there are many solutions $X$
  1216. but all their rows are chosen from a small set of vectors, so
  1217. 'OrthogonalEmbeddings' returns the solutions in an encoded form, namely
  1218. as a record with components
  1219.  
  1220. 'vectors':\\ the list $[ x_1, x_2, \ldots, x_n ]$ of vectors that may
  1221.              be rows of a solution; these are exactly those vectors
  1222.              that fulfill the condition $x_i G^{-1} x_{i}^{tr} \leq 1$
  1223.              (see "ShortestVectors"), and we have
  1224.              $G = \sum^n_{i=1} x_i^{tr} x_i$,
  1225.  
  1226. 'norms':     the list of values $x_i G^{-1}x_i^{tr}$, and
  1227.  
  1228. 'solutions':\\ a list <S> of lists; the $i$--th solution matrix is
  1229.               'Sublist( <L>, <S>[<i>] )', so the dimension of the
  1230.               $i$--th solution is the length of '<S>[<i>]'.
  1231.  
  1232. The optional argument '\"positive\"' will cause 'OrthogonalEmbeddings'
  1233. to compute only vectors $x_i$ with nonnegative entries.  In the context
  1234. of characters this is allowed (and useful) if $G$ is the matrix of
  1235. scalar products of ordinary characters.
  1236.  
  1237. When 'OrthogonalEmbeddings' is called with the optional argument
  1238. <maxdim> (a positive integer), it computes only solutions up to
  1239. dimension <maxdim>; this will accelerate the algorithm in some cases.
  1240.  
  1241. $G$ may be the matrix of scalar products of some virtual characters.
  1242. From the characters and the embedding given by the matrix $X$, 
  1243. 'Decreased' (see "Decreased") may be able to compute irreducibles.
  1244.  
  1245. |    gap> b := [ [  3, -1, -1 ], [ -1,  3, -1 ], [ -1, -1,  3 ] ];;
  1246.     gap> c:=OrthogonalEmbeddings(b);
  1247.     rec(
  1248.       vectors :=
  1249.        [ [ -1, 1, 1 ], [ 1, -1, 1 ], [ -1, -1, 1 ], [ -1, 1, 0 ],
  1250.           [ -1, 0, 1 ], [ 1, 0, 0 ], [ 0, -1, 1 ], [ 0, 1, 0 ], 
  1251.           [ 0, 0, 1 ] ],
  1252.       norms := [ 1, 1, 1, 1/2, 1/2, 1/2, 1/2, 1/2, 1/2 ],
  1253.       solutions := [ [ 1, 2, 3 ], [ 1, 6, 6, 7, 7 ], [ 2, 5, 5, 8, 8 ],
  1254.           [ 3, 4, 4, 9, 9 ], [ 4, 5, 6, 7, 8, 9 ] ] )
  1255.     gap> Sublist( c.vectors, c.solutions[1] );
  1256.     [ [ -1, 1, 1 ], [ 1, -1, 1 ], [ -1, -1, 1 ] ]|
  1257.  
  1258. \vspace{5mm}
  1259. 'OrthogonalEmbeddingsSpecialDimension'\\
  1260. |          |'( <tbl>, <reducibles>, <grammat> [, \"positive\" ], <dim> )'
  1261.  
  1262. This form can be used if you want to find irreducible characters of the
  1263. table <tbl>, where <reducibles> is a list of virtual characters,
  1264. <grammat> is the matrix of their scalar products, and <dim> is the
  1265. maximal dimension of an embedding.
  1266. First all solutions up to <dim> are compute, and then "Decreased"
  1267. 'Decreased' is called in order to find irreducible characters of <tab>.
  1268.  
  1269. If <reducibles> consists of ordinary characters only, you should enter
  1270. the optional argument '\"positive\"'; this imposes some conditions on
  1271. the possible embeddings (see the description of 'OrthogonalEmbeddings').
  1272.  
  1273. 'OrthogonalEmbeddingsSpecialDimension' returns a record with components
  1274.  
  1275. 'irreducibles':  a list of found irreducibles, the intersection of all
  1276.                  lists of irreducibles found by 'Decreased', for all
  1277.                  possible embeddings, and
  1278.  
  1279. 'remainders':    a list of remaining reducible virtual characters
  1280.  
  1281.  
  1282. |    gap> s6:= CharTable( "Symmetric", 6 );;
  1283.     gap> b:= InducedCyclic( s6, "all" );;
  1284.     gap> Add( b, [1,1,1,1,1,1,1,1,1,1,1] );
  1285.     gap> c:= LLL( s6, b ).remainders;;
  1286.     gap> g:= MatScalarProducts( s6, c, c );;
  1287.     gap> d:= OrthogonalEmbeddingsSpecialDimension( s6, c, g, 8 );
  1288.     rec(
  1289.       irreducibles := 
  1290.        [ [ 5, -3, 1, 1, 2, 0, -1, -1, -1, 0, 1 ], [ 5, 1, 1, -3, -1, 1,
  1291.               2, -1, -1, 0, 0 ], [ 10, -2, -2, 2, 1, 1, 1, 0, 0, 0, -1 ], 
  1292.           [ 10, 2, -2, -2, 1, -1, 1, 0, 0, 0, 1 ] ],
  1293.       remainders := 
  1294.        [ [ 0, 4, 0, -4, 3, 1, -3, 0, 0, 0, -1 ], [ 4, 0, 0, 4, -2, 0, 1,
  1295.               -2, 2, -1, 1 ], [ 6, 2, 2, -2, 3, -1, 0, 0, 0, 1, -2 ], 
  1296.           [ 14, 6, 2, 2, 2, 0, -1, 0, 0, -1, -1 ] ] )|
  1297.  
  1298. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1299. \Section{ShortestVectors}
  1300.  
  1301. 'ShortestVectors( <G>, <m> )'\\
  1302. 'ShortestVectors( <G>, <m>, \"positive\" )'
  1303.  
  1304. computes all vectors $x$ with $x G x^{tr} \leq m$, where $G$ is a matrix of
  1305. a symmetric bilinear form, and $m$ is a nonnegative integer.
  1306. If the optional argument '\"positive\"' is entered, only those vectors $x$
  1307. with nonnegative entries are computed.
  1308.  
  1309. 'ShortestVectors' returns a record with components
  1310.  
  1311. 'vectors':  the list of vectors $x$, and
  1312.  
  1313. 'norms':    the list of their norms according to the Gram matrix $G$.
  1314.  
  1315. |    gap> g:= [ [ 2, 1, 1 ], [ 1, 2, 1 ], [ 1, 1, 2 ] ];;
  1316.     gap> ShortestVectors(g,4);
  1317.     rec(
  1318.       vectors := [ [ -1, 1, 1 ], [ 0, 0, 1 ], [ -1, 0, 1 ], [ 1, -1, 1 ], 
  1319.           [ 0, -1, 1 ], [ -1, -1, 1 ], [ 0, 1, 0 ], [ -1, 1, 0 ], 
  1320.           [ 1, 0, 0 ] ],
  1321.       norms := [ 4, 2, 2, 4, 2, 4, 2, 2, 2 ] )|
  1322.  
  1323. This algorithm is used in "OrthogonalEmbeddings" 'OrthogonalEmbeddings'.
  1324.  
  1325. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1326. \Section{Extract}
  1327.  
  1328. 'Extract( <tbl>, <reducibles>, <grammat> )'\\
  1329. 'Extract( <tbl>, <reducibles>, <grammat>, <missing> )'
  1330.  
  1331. tries to find irreducible characters by drawing conclusions out of a
  1332. given matrix <grammat> of scalar products of the reducible characters in
  1333. the list <reducibles>, which are characters of the table <tbl>.
  1334. 'Extract' uses combinatorial and backtrack means.
  1335.  
  1336. *Note\:\ 'Extract' works only with ordinary characters!*
  1337.  
  1338. <missing>: number of characters missing to complete the <tbl>
  1339.            perhaps 'Extract' may be accelerated by the specification of 
  1340.            <missing>.
  1341.  
  1342. 'Extract' returns a record <extr> with components 'solution' and 'choice'
  1343. where 'solution' is a list $[ M_1, \ldots, M_n ]$ of decomposition
  1344. matrices that satisfy the equation
  1345. \[ M_i^{tr} \cdot X = 'Sublist( <reducibles>, <extr>.choice[i] )'\ , \]
  1346. for a matrix $X$ of irreducible characters, and 'choice' is a list of
  1347. length $n$ whose entries are lists of indices.
  1348.  
  1349. So each column stands for one of the reducible input characters, and
  1350. each row stands for an irreducible character.  You can use
  1351. "Decreased" 'Decreased' to examine the solution for computable
  1352. irreducibles.
  1353.  
  1354. |    gap> s4 := CharTable( "Symmetric", 4 );;
  1355.     gap> y := [ [ 5, 1, 5, 2, 1 ], [ 2, 0, 2, 2, 0 ], [ 3, -1, 3, 0, -1 ], 
  1356.     >  [ 6, 0, -2, 0, 0 ], [ 4, 0, 0, 1, 2 ] ];;
  1357.     gap> g := MatScalarProducts( s4, y, y );
  1358.     [ [ 6, 3, 2, 0, 2 ], [ 3, 2, 1, 0, 1 ], [ 2, 1, 2, 0, 0 ],        
  1359.       [ 0, 0, 0, 2, 1 ], [ 2, 1, 0, 1, 2 ] ]
  1360.     gap> e:= Extract( s4, y, g, 5 );
  1361.     rec( 
  1362.       solution :=
  1363.        [ [ [ 1, 1, 0, 0, 2 ], [ 1, 0, 1, 0, 1 ], [ 0, 1, 0, 1, 0 ], 
  1364.               [ 0, 0, 1, 0, 1 ], [ 0, 0, 0, 1, 0 ] ] ],
  1365.       choice := [ [ 2, 5, 3, 4, 1 ] ] )
  1366.     # continued in 'Decreased' ( see "Decreased" )|
  1367.  
  1368. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1369. \Section{Decreased}
  1370.  
  1371. 'Decreased( <tbl>, <reducibles>, <mat> )'\\
  1372. 'Decreased( <tbl>, <reducibles>, <mat>, <choice> )'
  1373.  
  1374. tries to solve the output of "OrthogonalEmbeddings"
  1375. 'OrthogonalEmbeddings' or "Extract" 'Extract' in order to find
  1376. irreducible characters.  <tbl> must be a character table, <reducibles>
  1377. the list of characters used for the call of 'OrtgogonalEmbeddings' or
  1378. 'Extract', <mat> one solution, and in the case of a solution returned
  1379. by 'Extract', 'choice' must be the corresponding 'choice' component.
  1380.  
  1381. 'Decreased' returns a record with components
  1382.  
  1383. 'irreducibles':\\
  1384.       the list of found irreducible characters,
  1385.  
  1386. 'remainders':\\
  1387.       the remaining reducible characters, and
  1388.  
  1389. 'matrix':\\
  1390.       the decomposition matrix of the characters in the 'remainders'
  1391.       component, which could not be solved.
  1392.  
  1393. |    # see example in "Extract" 'Extract'
  1394.     gap> d := Decreased( s4, y, e.solution[1], e.choice[1] );
  1395.     rec( 
  1396.       irreducibles :=
  1397.        [ [ 1, 1, 1, 1, 1 ], [ 3, -1, -1, 0, 1 ], [ 1, -1, 1, 1, -1 ], 
  1398.           [ 3, 1, -1, 0, -1 ], [ 2, 0, 2, -1, 0 ] ],
  1399.       remainders := [  ], 
  1400.       matrix := [  ] )|
  1401.  
  1402. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1403. \Section{DnLattice}\index{DnLatticeIterative}\index{$D_n$ lattices}
  1404.  
  1405. 'DnLattice( <tbl>, <grammat>, <reducibles> )'
  1406.  
  1407. tries to find sublattices isomorphic to root lattices of type $D_n$
  1408. (for $n \geq 5$ or $n = 4$) in a lattice that is generated by the norm 2
  1409. characters <reducibles>, which must be characters of the table <tbl>.
  1410. <grammat> must be the matrix of scalar products of <reducibles>, i.e.,
  1411. the Gram matrix of the lattice.
  1412.  
  1413. 'DnLattice' is able to find irreducible characters if there is a lattice
  1414. with $n>4$.  In the case $n = 4$ 'DnLattice' only in some cases finds
  1415. irreducibles.
  1416.  
  1417. 'DnLattice' returns a record with components
  1418.  
  1419. 'irreducibles':\\
  1420.        the list of found irreducible characters,
  1421.  
  1422. 'remainders':\\
  1423.        the list of remaining reducible characters, and
  1424.  
  1425. 'gram':\\
  1426.        the Gram matrix of the characters in 'remainders'.
  1427.  
  1428. The remaining  reducible characters  are  transformed into  a  normalized
  1429. form, so that the lattice-structure is cleared  up for further treatment.
  1430. So  'DnLattice' might be  useful  even  if it  fails to  find irreducible
  1431. characters.
  1432.  
  1433. |    gap> tbl:= CharTable( "Symmetric", 4 );;
  1434.     gap> y1:=[ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ], [ 5, -1, 1, -1, 1 ],
  1435.     >          [ -1, 1, 3, -1, -1 ] ];;
  1436.     gap> g1:= MatScalarProducts( tbl, y1, y1 );
  1437.     [ [ 2, 1, 0, 0 ], [ 1, 2, 1, -1 ], [ 0, 1, 2, 0 ], [ 0, -1, 0, 2 ] ]
  1438.     gap> e:= DnLattice( tbl, g1, y1 );
  1439.     rec( 
  1440.       gram := [  ], 
  1441.       remainders := [  ], 
  1442.       irreducibles := 
  1443.        [ [ 2, 0, 2, -1, 0 ], [ 1, -1, 1, 1, -1 ], [ 1, 1, 1, 1, 1 ], 
  1444.           [ 3, -1, -1, 0, 1 ] ] )|
  1445.  
  1446. \vspace{5mm}
  1447. 'DnLatticeIterative( <tbl>, <arec> )'
  1448.  
  1449. was made for iterative use of 'DnLattice'. <arec> must be either a list
  1450. of characters of the table <tbl>, or a record with components
  1451.  
  1452. 'remainders':\\
  1453.        a list of characters of the character table <tbl>, and
  1454.  
  1455. 'norms':\\
  1456.        the norms of the characters in 'remainders',
  1457.  
  1458. e.g., a record returned by "LLL-Algorithm" 'LLL'.  'DnLatticeIterative'
  1459. will select the characters of norm 2, call 'DnLattice', reduce the
  1460. characters with found irreducibles, call 'DnLattice' for the
  1461. remaining characters, and so on, until no new irreducibles are found.
  1462.  
  1463. 'DnLatticeIterative' returns (like "LLL-Algorithm" 'LLL') a record with
  1464. components
  1465.  
  1466. 'irreducibles':\\
  1467.      the list of found irreducible characters,
  1468.  
  1469. 'remainders':\\
  1470.      the list of remaining reducible characters, and
  1471.  
  1472. 'norms':\\
  1473.      the list of norms of the characters in 'remainders'.
  1474.  
  1475. |    gap> tbl:= CharTable( "Symmetric", 4 );;
  1476.     gap> y1:= [ [ 2, 0, 2, 2, 0 ], [ 4, 0, 0, 1, 2 ], 
  1477.     >   [ 5, -1, 1, -1, 1 ], [ -1, 1, 3, -1, -1 ], [ 6, -2, 2, 0, 0 ] ];;
  1478.     gap> DnLatticeIterative( tbl, y1);
  1479.     rec(
  1480.       irreducibles := 
  1481.        [ [ 2, 0, 2, -1, 0 ], [ 1, -1, 1, 1, -1 ], [ 1, 1, 1, 1, 1 ], 
  1482.           [ 3, -1, -1, 0, 1 ] ],
  1483.       remainders := [  ],
  1484.       norms := [  ] )|
  1485.  
  1486. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1487. \Section{ContainedDecomposables}
  1488.  
  1489. 'ContainedDecomposables( <constituents>, <moduls>, <parachar>, <func> )'
  1490.  
  1491. For a list of *rational* characters <constituents> and a parametrized
  1492. rational character <parachar>
  1493. (see "More about Maps and Parametrized Maps"),
  1494. the set of all elements $\chi$ of <parachar> is returned
  1495. that satisfy $<func>( \chi )$ (i.e., for that 'true' is returned)
  1496. and that ``modulo <moduls> lie in the lattice
  1497. spanned by <constituents>\'\'. This means they lie in the lattice spanned
  1498. by <constituents> and the set $\{ <moduls>[i]\cdot e_i; 1\leq i\leq n\}$,
  1499. where $n$ is the length of <parachar> and $e_i$ is the $i$-th vector
  1500. of the standard base.
  1501.  
  1502. |    gap> hs:= CharTable("HS");; s:= CharTable("HSM12");; s.name;
  1503.     "5:4xa5"
  1504.     gap> rat:= RationalizedMat(s.irreducibles);;
  1505.     gap> fus:= InitFusion( s, hs );
  1506.     [ 1, [ 2, 3 ], [ 2, 3 ], [ 2, 3 ], 4, 5, 5, [ 5, 6, 7 ], [ 5, 6, 7 ],
  1507.       9, [ 8, 9 ], [ 8, 9 ], [ 8, 9, 10 ], [ 8, 9, 10 ], [ 11, 12 ], 
  1508.       [ 17, 18 ], [ 17, 18 ], [ 17, 18 ], 21, 21, 22, [ 23, 24 ],
  1509.       [ 23, 24 ], [ 23, 24 ], [ 23, 24 ] ]
  1510.     # restrict a rational character of 'hs' by 'fus',
  1511.     # see chapter "Maps and Parametrized Maps"\:
  1512.     gap> rest:= CompositionMaps( hs.irreducibles[8], fus );
  1513.     [ 231, [ -9, 7 ], [ -9, 7 ], [ -9, 7 ], 6, 15, 15, [ -1, 15 ],
  1514.       [ -1, 15 ], 1, [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ 1, 6 ], [ -2, 0 ],
  1515.       [ 1, 2 ], [ 1, 2 ], [ 1, 2 ], 0, 0, 1, 0, 0, 0, 0 ]
  1516.     # all vectors in the lattice\:
  1517.     gap> ContainedDecomposables( rat, s.centralizers, rest, x -> true );
  1518.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1519.           0, 1, 0, 0, 0, 0 ], 
  1520.       [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1521.           0, 1, 0, 0, 0, 0 ], 
  1522.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1523.           0, 1, 0, 0, 0, 0 ], 
  1524.       [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1525.           0, 1, 0, 0, 0, 0 ] ]
  1526.     # better filter, only characters (see "ContainedCharacters")\:
  1527.     gap> ContainedDecomposables( rat, s.centralizers, rest,
  1528.     >                  x->NonnegIntScalarProducts(s,s.irreducibles,x) );
  1529.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1530.           0, 1, 0, 0, 0, 0 ], 
  1531.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1532.           0, 1, 0, 0, 0, 0 ] ]|
  1533.  
  1534. An application of 'ContainedDecomposables' is "ContainedCharacters"
  1535. 'ContainedCharacters'.
  1536.  
  1537. For another strategy that works also for irrational characters,
  1538. see "ContainedSpecialVectors".
  1539.  
  1540. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1541. \Section{ContainedCharacters}
  1542.  
  1543. 'ContainedCharacters( <tbl>, <constituents>, <parachar> )'
  1544.  
  1545. returns the set of all characters contained in the parametrized rational
  1546. character <parachar> (see "More about Maps and Parametrized Maps"),
  1547. that modulo centralizer orders lie in the linear span of the *rational*
  1548. characters <constituents> of the character table <tbl> and that have
  1549. nonnegative integral scalar products with all elements of <constituents>.
  1550.  
  1551. *Note*\:\ This does not imply that an element of the returned list is
  1552. necessary a linear combination of <constituents>.
  1553.  
  1554. |    gap> s:= CharTable( "HSM12" );; hs:= CharTable( "HS" );;
  1555.     gap> rat:= RationalizedMat( s.irreducibles );;
  1556.     gap> fus:= InitFusion( s, hs );;
  1557.     gap> rest:= CompositionMaps( hs.irreducibles[8], fus );;
  1558.     gap> ContainedCharacters( s, rat, rest );
  1559.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1560.           0, 1, 0, 0, 0, 0 ], 
  1561.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1562.           0, 1, 0, 0, 0, 0 ] ]|
  1563.  
  1564. 'ContainedCharacters' calls "ContainedDecomposables"
  1565. 'ContainedDecomposables'.
  1566.  
  1567. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1568. \Section{ContainedSpecialVectors}
  1569.  
  1570. 'ContainedSpecialVectors( <tbl>, <chars>, <parachar>, <func> )'
  1571.  
  1572. returns the list of all elements <vec> of the parametrized character
  1573. <parachar> (see "More about Maps and Parametrized Maps"), that have
  1574. integral norm and integral scalar product with the principal character
  1575. of the character table <tbl> and that satisfy '<func>( <tbl>, <chars>,
  1576.  <vec> )', i.e., for that 'true' is returned.
  1577.  
  1578. |    gap> s:= CharTable( "HSM12" );; hs:= CharTable( "HS" );;
  1579.     gap> fus:= InitFusion( s, hs );;
  1580.     gap> rest:= CompositionMaps( hs.irreducibles[8], fus );;
  1581.     # no further condition\:
  1582.     gap> ContainedSpecialVectors( s, s.irreducibles, rest,
  1583.     >                      function(tbl,chars,vec) return true; end );;
  1584.     gap> Length( last );
  1585.     24
  1586.     # better filter\:\ those with integral scalar products
  1587.     gap> ContainedSpecialVectors( s, s.irreducibles, rest,
  1588.     >                             IntScalarProducts );
  1589.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1590.           0, 1, 0, 0, 0, 0 ], 
  1591.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1592.           0, 1, 0, 0, 0, 0 ], 
  1593.       [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1594.           0, 1, 0, 0, 0, 0 ], 
  1595.       [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1596.           0, 1, 0, 0, 0, 0 ] ]
  1597.     # better filter\:\ the scalar products must be nonnegative
  1598.     gap> ContainedSpecialVectors( s, s.irreducibles, rest,
  1599.     >                             NonnegIntScalarProducts );
  1600.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1601.           0, 1, 0, 0, 0, 0 ], 
  1602.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1603.           0, 1, 0, 0, 0, 0 ] ]|
  1604.  
  1605. Special cases of 'ContainedSpecialVectors' are
  1606. "ContainedPossibleCharacters" 'ContainedPossibleCharacters' and
  1607. "ContainedPossibleVirtualCharacters"
  1608. 'ContainedPossibleVirtualCharacters'.
  1609.  
  1610. 'ContainedSpecialVectors' successively examines all vectors contained in
  1611. <parachar>, thus it might not be useful if the indeterminateness
  1612. exceeds $10^6$.  For another strategy that works for rational characters
  1613. only, see "ContainedDecomposables".
  1614.  
  1615. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1616. \Section{ContainedPossibleCharacters}
  1617.  
  1618. 'ContainedPossibleCharacters( <tbl>, <chars>, <parachar> )'
  1619.  
  1620. returns the list of all elements <vec> of the parametrized character
  1621. <parachar> (see "More about Maps and Parametrized Maps"), which have
  1622. integral norm and integral scalar product with the principal character
  1623. of the character table <tbl> and nonnegative integral scalar product
  1624. with all elements of the list <chars> of characters of <tbl>.
  1625.  
  1626. |    # see example in "ContainedSpecialVectors"
  1627.     gap> ContainedPossibleCharacters( s, s.irreducibles, rest );
  1628.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1629.           0, 1, 0, 0, 0, 0 ], 
  1630.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1631.           0, 1, 0, 0, 0, 0 ] ]|
  1632.  
  1633. 'ContainedPossibleCharacters' calls "ContainedSpecialVectors"
  1634. 'ContainedSpecialVectors'.
  1635.  
  1636. 'ContainedPossibleCharacters' successively examines all vectors contained
  1637. in <parachar>, thus it might not be useful if the indeterminateness
  1638. exceeds $10^6$.  For another strategy that works for rational characters
  1639. only, see "ContainedDecomposables".
  1640.  
  1641. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1642. \Section{ContainedPossibleVirtualCharacters}
  1643.  
  1644. 'ContainedPossibleVirtualCharacters( <tbl>, <chars>, <parachar> )'
  1645.  
  1646. returns the list of all elements <vec> of the parametrized character
  1647. <parachar> (see "More about Maps and Parametrized Maps"), which have
  1648. integral norm and integral scalar product with the principal character
  1649. of the character table <tbl> and integral scalar product with all
  1650. elements of the list <chars> of characters of <tbl>.
  1651.  
  1652. |    # see example in "ContainedSpecialVectors"
  1653.     gap> ContainedPossibleVirtualCharacters( s, s.irreducibles, rest );
  1654.     [ [ 231, 7, -9, -9, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1655.           0, 1, 0, 0, 0, 0 ], 
  1656.       [ 231, 7, -9, 7, 6, 15, 15, -1, -1, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1657.           0, 1, 0, 0, 0, 0 ], 
  1658.       [ 231, 7, -9, -9, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1659.           0, 1, 0, 0, 0, 0 ], 
  1660.       [ 231, 7, -9, 7, 6, 15, 15, 15, 15, 1, 6, 6, 1, 1, -2, 1, 2, 2, 0,
  1661.           0, 1, 0, 0, 0, 0 ] ]|
  1662.  
  1663. 'ContainedPossibleVirtualCharacters' calls "ContainedSpecialVectors"
  1664. 'ContainedSpecialVectors'.
  1665.  
  1666. 'ContainedPossibleVirtualCharacters' successively examines all vectors
  1667. that are contained in <parachar>, thus it might not be useful if the
  1668. indeterminateness exceeds $10^6$.
  1669. For another strategy that works for rational characters only,
  1670. see "ContainedDecomposables".
  1671.  
  1672.  
  1673. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1674. %%
  1675. %E  Emacs . . . . . . . . . . . . . . . . . . . . . local Emacs variables
  1676. %%
  1677. %%  Local Variables:
  1678. %%  mode:               outline
  1679. %%  outline-regexp:     "\\\\Chapter\\|\\\\Section"
  1680. %%  fill-column:        73
  1681. %%  eval:               (hide-body)
  1682. %%  End:
  1683. %%
  1684.