home *** CD-ROM | disk | FTP | other *** search
/ Math Solutions 1995 October / Math_Solutions_CD-ROM_Walnut_Creek_October_1995.iso / pc / mac / discrete / doc / group.tex < prev    next >
Encoding:
Text File  |  1993-05-05  |  149.9 KB  |  3,920 lines
  1. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2. %%
  3. %A  group.tex                   GAP documentation                Frank Celler
  4. %%
  5. %A  @(#)$Id: group.tex,v 3.28 1993/02/19 10:48:42 gap Exp $
  6. %%
  7. %Y  Copyright 1990-1992,  Lehrstuhl D fuer Mathematik,  RWTH Aachen,  Germany
  8. %%
  9. %%  This file contains the description of the group  record  and  polymorphic
  10. %%  functions for groups.
  11. %%
  12. %H  $Log: group.tex,v $
  13. %H  Revision 3.28  1993/02/19  10:48:42  gap
  14. %H  adjustments in line length and spelling
  15. %H
  16. %H  Revision 3.27  1993/02/15  14:22:26  felsch
  17. %H  DefineName eliminated
  18. %H
  19. %H  Revision 3.26  1993/02/12  17:13:51  felsch
  20. %H  examples adjusted to line length 72
  21. %H
  22. %H  Revision 3.25  1993/02/11  17:46:09  martin
  23. %H  changed '@' to '&'
  24. %H
  25. %H  Revision 3.24  1993/02/11  15:44:48  martin
  26. %H  added 'PCore' and 'Radical'
  27. %H
  28. %H  Revision 3.23  1993/02/02  12:51:37  felsch
  29. %H  long lines in examples fixed
  30. %H
  31. %H  Revision 3.22  1993/02/01  13:31:03  felsch
  32. %H  examples fixed
  33. %H
  34. %H  Revision 3.21  1993/01/27  10:09:53  fceller
  35. %H  various fixes of examples
  36. %H
  37. %H  Revision 3.20  1993/01/22  19:33:24  felsch
  38. %H  added 'Lattice', moved 'TableOfMarks' to "tom"
  39. %H
  40. %H  Revision 3.19  1993/01/04  10:59:55  fceller
  41. %H  added 'Exponent'
  42. %H
  43. %H  Revision 3.18  1992/12/02  10:05:22  fceller
  44. %H  moved 'PCentralSeries' to "group.g"
  45. %H
  46. %H  Revision 3.17  1992/11/30  18:46:25  fceller
  47. %H  moved 'ElementaryAbelianSeries' and 'CompositionSeries' into "group.g"
  48. %H
  49. %H  Revision 3.16  1992/04/30  12:34:13  martin
  50. %H  fixed '* ... *' to '\* ... \*'
  51. %H
  52. %H  Revision 3.15  1992/04/06  15:59:01  martin
  53. %H  fixed some more typos
  54. %H
  55. %H  Revision 3.14  1992/04/02  21:06:23  martin
  56. %H  changed *domain functions* to *set theoretic functions*
  57. %H
  58. %H  Revision 3.13  1992/04/02  16:53:52  martin
  59. %H  added 'ConjugationGroupHomomorphism' and 'InnerAutomorphism'
  60. %H
  61. %H  Revision 3.12  1992/03/26  17:30:10  martin
  62. %H  changed the order of the sections slightly
  63. %H
  64. %H  Revision 3.11  1992/03/26  13:28:49  martin
  65. %H  added sections for the conjugacy classes
  66. %H
  67. %H  Revision 3.10  1992/03/25  15:37:32  martin
  68. %H  added new sections for group homomorphisms
  69. %H
  70. %H  Revision 3.9  1992/03/11  13:58:55  martin
  71. %H  fixed the citations
  72. %H
  73. %H  Revision 3.8  1992/02/07  18:26:02  fceller
  74. %H  Initial GAP 3.1 release.
  75. %H
  76. %H  Revision 3.6  1992/01/24  11:49:32  martin
  77. %H  added the description of cosets
  78. %H
  79. %H  Revision 3.1  1991/05/21  12:03:25  fceller
  80. %H  Initial revision
  81. %%
  82.  
  83. \Chapter{Groups}
  84.  
  85. Finitely generated groups  and their  subgroups are important  domains in
  86. {\GAP}.  They  are  represented as permutation groups,  matrix groups, ag
  87. groups or even  more complicated constructs  as for instance automorphism
  88. groups, direct products or semi-direct products  where the group elements
  89. are represented by records.
  90.  
  91. Groups  are created using 'Group' (see "Group"),  they are represented by
  92. records that contain important  information  about the groups.  Subgroups
  93. are created as subgroups of a given group using 'Subgroup', and are  also
  94. represented  by records.   See  "More about  Groups  and  Subgroups"  for
  95. details about the distinction between groups and subgroups.
  96.  
  97. Because this chapter is very large it  is split into several parts.  Each
  98. part consists of several sections.
  99.  
  100. The first part describes the operations and functions  that are available
  101. for group elements, e.g., 'Order' (see "Group Elements").   The next part
  102. tells your more about the distinction of parent groups and subgroups (see
  103. "More  about  Groups  and  Subgroups").   The  next  parts  describe  the
  104. functions  that compute subgroups, e.g.,  'SylowSubgroup'  ("Subgroups"),
  105. and   series   of  subgroups,  e.g.,  'DerivedSeries'   (see  "Series  of
  106. Subgroups").  The next part describes the functions that compute and test
  107. properties  of  groups,  e.g.,  'AbelianInvariants' and  'IsSimple'  (see
  108. "Properties  and  Property  Tests").  The  next  parts describe conjugacy
  109. classes of elements and  subgroups  (see "Conjugacy  Classes") and cosets
  110. (see "Cosets of Subgroups").  The next part describes the functions  that
  111. create  new groups,  e.g., 'DirectProduct' (see  "Group  Constructions").
  112. The next part describes group  homomorphisms, e.g., 'NaturalHomomorphism'
  113. (see  "Group Homomorphisms").   The last part tells you  more  about  the
  114. implementation of groups, e.g., it describes the format of group  records
  115. (see "Set Functions for Groups").
  116.  
  117. The functions described in this chapter are  implemented in the following
  118. library files.  'LIBNAME/\"grpelms.g\"' contains the functions for  group
  119. elements, 'LIBNAME/\"group.g\"' contains the dispatcher and default group
  120. functions, 'LIBNAME/\"grpcoset.g\"' contains the functions for cosets and
  121. factor    groups,   'LIBNAME/\"grphomom.g\"'   implements    the    group
  122. homomorphisms,   and  'LIBNAME/\"grpprods.g\"'   implements   the   group
  123. constructions.
  124.  
  125. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  126.  
  127. \Section{Group Elements}%
  128.  
  129. The following  sections  describe the operations and  functions available
  130. for group  elements (see "Comparisons of Group Elements", "Operations for
  131. Group Elements", "IsGroupElement", and "Order").
  132.  
  133. Note  that group elements  usually  exist independently of a group, e.g.,
  134. you  can write down two  permutations and  compute  their product without
  135. ever defining a group that contains them.
  136.  
  137. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  138. \Section{Comparisons of Group Elements}%
  139. \index{equality!of group elements}%
  140. \index{ordering!of group elements}
  141.  
  142. '<g> = <h>' \\
  143. '<g> \<> <h>'
  144.  
  145. The equality operator '=' evaluates to 'true'  if the group  elements <g>
  146. and  <h> are  equal and  to 'false' otherwise.   The  inequality operator
  147. '\<>' evaluates to 'true' if the group elements <g> and <h> are not equal
  148. and to 'false' otherwise.
  149.  
  150. You can  compare group elements with objects  of other types.   Of course
  151. they are never equal.  Standard group elements are permutations, ag words
  152. and  matrices.  For examples of  generic group elements see for  instance
  153. "DirectProduct".
  154.  
  155. \vspace{5mm}
  156. '<g> \<\ <h>' \\
  157. '<g> \<= <h>' \\
  158. '<g> >= <h>' \\
  159. '<g> > <h>'
  160.  
  161. The operators '\<', '\<=', '>=' and '>' evaluate to 'true'  if  the group
  162. element <g> is strictly less than, less than or equal to, greater than or
  163. equal to  and strictly greater than the  group element <h>.  There  is no
  164. general ordering on group  elements.
  165.  
  166. Standard group elements may be compared with objects of other types while
  167. generic group elements may disallow such a comparison.
  168.  
  169. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  170. \Section{Operations for Group Elements}%
  171. \index{product!of group elements}%
  172. \index{product!of list and group element}%
  173. \index{quotient!of group elements}%
  174. \index{quotient!of list and group element}%
  175. \index{power!of group elements}%
  176. \index{conjugate!of a group element}%
  177. \index{Comm!for group elements}%
  178. \index{LeftQuotient!for group elements}
  179.  
  180. '<g> \*\ <h>' \\
  181. '<g> / <h>'
  182.  
  183. The operators  '\*' and '/' evaluate to the product and quotient  of  the
  184. two group elements <g> and <h>.   The  operands  must of course  lie in a
  185. common parent group, otherwise an error is signaled.
  186.  
  187. \vspace{5mm}
  188. '<g> \^\ <h>'
  189.  
  190. The operator '\^' evaluates to the conjugate $<h>^{-1}\*  <g>\*  <h>$  of
  191. <g> under  <h> for two group elements elements <g> and <h>.  The operands
  192. must  of course  lie  in  a  common parent  group, otherwise an  error is
  193. signaled.
  194.  
  195. \vspace{5mm}
  196. '<g> \^\ <i>'
  197.  
  198. The powering operator  '\^' returns the  <i>-th power  of a group element
  199. <g> and an integer <i>.  If <i> is zero the identity of a parent group of
  200. <g> is returned.
  201.  
  202. \vspace{5mm}
  203. '<list> \*\ <g>' \\
  204. '<g> \*\ <list>'
  205.  
  206. In this form the operator '\*' returns a new list where each entry is the
  207. product of <g>  and the   corresponding  entry  of <list>.    Of   course
  208. multiplication must be defined between <g> and each entry of <list>.
  209.  
  210. \vspace{5mm}
  211. '<list> / <g>'
  212.  
  213. In this form the operator '/' returns a new list where  each entry is the
  214. quotient of  <g>  and  the  corresponding entry  of   <list>.   Of course
  215. division must be defined between <g> and each entry of <list>.
  216.  
  217. 'Comm( <g>, <h> )'
  218.  
  219. 'Comm'  returns the commutator $<g>^{-1}\*  <h>^{-1}\* <g>\*  <h>$ of two
  220. group elements <g> and <h>.  The operands  must of course lie in a common
  221. parent group, otherwise an error is signaled.
  222.  
  223. \vspace{5mm}
  224. 'LeftQuotient( <g>, <h> )'
  225.  
  226. 'LeftQuotient'  returns the  left quotient $<g>^{-1}\*  <h>$ of two group
  227. elements <g> and <h>.  The operands must of course lie in a common parent
  228. group, otherwise an error is signaled.
  229.  
  230. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  231. \Section{IsGroupElement}%
  232. \index{test!for group element}
  233.  
  234. 'IsGroupElement( <obj> )'
  235.  
  236. 'IsGroupElement'  returns  'true' if  <obj>,  which may  be  an object of
  237. arbitrary type, is a  group element, and  'false' otherwise. The function
  238. will signal an error if <obj> is an unbound variable.
  239.  
  240. |    gap> IsGroupElement( 10 );
  241.     false
  242.     gap> IsGroupElement( (11,10) );
  243.     true
  244.     gap> IsGroupElement( IdWord );
  245.     true |
  246.  
  247. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  248. \Section{Order}%
  249. \index{order!of a group element}
  250.  
  251. 'Order( <G>, <g> )'
  252.  
  253. 'Order' returns the order of a group element <g> in the group <G>.
  254.  
  255. The *order* is the smallest positive integer $i$ such that $<g>^i$ is the
  256. identity.  The order of the identity is one.
  257.  
  258. |    gap> Order( Group( (1,2), (1,2,3,4) ), (1,2,3) );
  259.     3
  260.     gap> Order( Group( (1,2), (1,2,3,4) ), () );
  261.     1 |
  262.  
  263. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  264.  
  265. \Section{More about Groups and Subgroups}
  266.  
  267. {\GAP} distinguishs between parent groups and subgroups of parent groups.
  268. Each subgroup belongs to  a unique parent group.  We say that this parent
  269. group is the *parent* of the  subgroup.  We also say that a  parent group
  270. is its own parent.
  271.  
  272. Parent groups are constructed by 'Group' and subgroups are constructed by
  273. 'Subgroup'.  The first argument of  'Subgroup'  must be  a parent  group,
  274. i.e., it must not be a subgroup of a  parent group, and this parent group
  275. will be the parent of the constructed subgroup.
  276.  
  277. Those group functions that take more than one  argument require that  the
  278. arguments  have a  common parent.   Take for  instance  'Normalizer'.  It
  279. takes two  arguments,  a  group <G>  and  a  group  <H>, and  returns the
  280. normalizer  of <H> in <G>.  So either <G> is a parent group, and <H> is a
  281. subgroup of this parent  group, or <G> and <H> are  subgroups of a common
  282. parent group <P>.
  283.  
  284. |    gap> s4 := Group( (1,2), (1,2,3,4) );
  285.     Group( (1,2), (1,2,3,4) )
  286.     gap> c3 := Subgroup( s4, [ (1,2,3) ] );
  287.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )
  288.     gap> Normalizer( s4, c3 );
  289.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3), (2,3) ] )
  290.     # ok, 'c3' is a subgroup of the parent group 's4'
  291.     gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );
  292.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3), (2,3,4) ] )
  293.     gap> Normalizer( a4, c3 );
  294.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )
  295.     # also ok, 'c3' and 'a4' are subgroups of the parent group 's4'
  296.     gap> x3 := Group( (1,2,3) );
  297.     Group( (1,2,3) )
  298.     gap> Normalizer( s4, x3 );
  299.     Error, <G> and <H> must have the same parent group
  300.     # not ok, 's4' is its own parent and 'x3' is its own parent |
  301.  
  302. Those functions that return  new  subgroups, as  with 'Normalizer' above,
  303. return  this subgroup  as  a  subgroup  of  the  common  parent  of their
  304. arguments.  Note  especially  that the  normalizer  of 'c3'  in  'a4'  is
  305. returned  as a subgroup  of  their  common parent  group  's4', not as  a
  306. subgroup  of 'a4'.  It  can  not be a subgroup of 'a4', because subgroups
  307. must be  subgroups  of parent groups, and 'a4' is not a parent group.  Of
  308. course, mathematically the normalizer is a subgroup of 'a4'.
  309.  
  310. Note that a subgroup of a parent group need not be a proper subgroup, as
  311. can be seen in the following example.
  312.  
  313. |    gap> s4 := Group( (1,2), (1,2,3,4) );
  314.     Group( (1,2), (1,2,3,4) )
  315.     gap> x4 := Subgroup( s4, [ (1,2,3,4), (3,4) ] );
  316.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3,4), (3,4) ] )
  317.     gap> Index( s4, x4 );
  318.     1 |
  319.  
  320. One exception to the rule are functions that construct new groups such as
  321. 'DirectProduct'.  They accept groups with different parents.  If you want
  322. rename the function 'DirectProduct' to 'OuterDirectProduct'.
  323.  
  324. Another  exception is 'Intersection' (see "Intersection"),  which  allows
  325. groups with different parent groups, it computes the intersection in such
  326. cases  as  if  the  groups  were  sets  of  elements.   This  is  because
  327. 'Intersection'  is not a  group function, but a domain function, i.e., it
  328. accepts two (or more) arbitrary domains as arguments.
  329.  
  330. Whenever you have  two subgroups which have different  parent groups  but
  331. have a common supergroup <G> you can use 'AsSubgroup'  (see "AsSubgroup")
  332. in order to construct new subgroups which have a common parent group <G>.
  333.  
  334. |    gap> s4 := Group( (1,2), (1,2,3,4) );
  335.     Group( (1,2), (1,2,3,4) )
  336.     gap> x3 := Group( (1,2,3) );
  337.     Group( (1,2,3) )
  338.     gap> Normalizer( s4, x3 );
  339.     Error, <G> and <H> must have the same parent group
  340.     # not ok, 's4' is its own parent and 'x3' is its own parent
  341.     gap> c3 := AsSubgroup( s4, x3 );
  342.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )
  343.     gap> Normalizer( s4, c3 );
  344.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3), (2,3) ] ) |
  345.  
  346. The following sections describe  the functions  related  to  this concept
  347. (see  "IsParent", "Parent",  "Group", "AsGroup",  "IsGroup",  "Subgroup",
  348. "AsSubgroup").
  349.  
  350. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  351. \Section{IsParent}
  352.  
  353. 'IsParent( <G> )'
  354.  
  355. 'IsParent' returns 'true' if <G> is a parent group, and 'false' otherwise
  356. (see "More about Groups and Subgroups").
  357.  
  358. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  359. \Section{Parent}
  360.  
  361. 'Parent( <$U_1$>, ..., <$U_n$> )'
  362.  
  363. 'Parent' returns  the  common parent  group of its  subgroups  and parent
  364. group arguments.
  365.  
  366. In case more than one argument  is given, all  groups  must have the same
  367. parent  group.   Otherwise an  error is signaled.    This can  be used to
  368. ensure that a collection of given subgroups have a common parent group.
  369.  
  370. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  371. \Section{Group}
  372.  
  373. 'Group( <U> )'
  374.  
  375. Let <U> be a parent group or a subgroup.  'Group'  returns  a  new parent
  376. group $G$ which is isomorphic to <U>.  The generators of $G$  need not be
  377. the same elements as the  generators of <U>.   The default group function
  378. uses the same  generators, while the   ag group  function  may create new
  379. generators along with a new collector.
  380.  
  381. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  382.     Group( (1,2,3,4), (1,2) )
  383.     gap> s3 := Subgroup( s4, [ (1,2,3), (1,2) ] );
  384.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] )
  385.     gap> Group( s3 ); # same elements
  386.     Group( (1,2,3), (1,2) )
  387.     gap> s4.1 * s3.1;
  388.     (1,3,4,2)
  389.     gap> s4 := AgGroup( s4 );
  390.     Group( g1, g2, g3, g4 )
  391.     gap> a4 := DerivedSubgroup( s4 );
  392.     Subgroup( Group( g1, g2, g3, g4 ), [ g2, g3, g4 ] )
  393.     gap> a4 := Group( a4 ); # different elements
  394.     Group( g1, g2, g3 )
  395.     gap> s4.1 * a4.1;
  396.     Error, AgWord op: agwords have different groups |
  397.  
  398. 'Group( <list>, <id> )'
  399.  
  400. 'Group' returns a new parent group  $G$ generated by group elements $g_1,
  401. ..., g_n$ of <list>. <id> must be the identity of this group.
  402.  
  403. 'Group( <$g_1$>, ..., <$g_n$> )'
  404.  
  405. 'Group'  returns  a   new parent group   $G$ generated  by group elements
  406. <$g_1$>, ..., <$g_n$>.
  407.  
  408. The generators of this new parent group need not  be the same elements as
  409. $g_1, ...,  g_n$.  The default group  function  however returns   a group
  410. record with generators  $g_1, ..., g_n$  and identity <id>,  while the ag
  411. group function may create new generators along with a new  collector.
  412.  
  413. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  414.     Group( (1,2,3,4), (1,2) )
  415.     gap> z4 := Group( s4.1 ); # same element
  416.     Group( (1,2,3,4) )
  417.     gap> s4.1 * z4.1;
  418.     (1,3)(2,4)
  419.     gap> s4 := AgGroup( s4 );
  420.     Group( g1, g2, g3, g4 )
  421.     gap> z4 := Group( s4.1 * s4.3 ); # different elements
  422.     Group( g1, g2 )
  423.     gap> s4.1 * z4.1;
  424.     Error, AgWord op: agwords have different groups |
  425.  
  426. Let $g_{i_1}, ...,  g_{i_m}$ be the  set of nontrivial  generators in all
  427. four cases.   'Groups' sets  record components  '<G>.1',  ..., '<G>.m' to
  428. these generators.
  429.  
  430. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  431. \Section{AsGroup}
  432.  
  433. 'AsGroup( <D> )'
  434.  
  435. Let <D> be a domain. 'AsGroup' returns a group $G$ such that  the  set of
  436. elements of  <D> is the same as  the set of  elements of $G$  if  this is
  437. possible.
  438.  
  439. If <D> is  a list of  group elements these  elements must  form  a group.
  440. Otherwise an error is signaled.
  441.  
  442. Note that this function returns a parent group or a subgroup  of a parent
  443. group  depending on <D>. In order  to convert a   subgroup  into a parent
  444. group you must use 'Group' (see "Group").
  445.  
  446. |    gap> s4 := AgGroup( Group( (1,2,3,4), (2,3) ) );
  447.     Group( g1, g2, g3, g4 )
  448.     gap> Elements( last );
  449.     [ IdAgWord, g4, g3, g3*g4, g2, g2*g4, g2*g3, g2*g3*g4, g2^2, g2^2*g4,
  450.       g2^2*g3, g2^2*g3*g4, g1, g1*g4, g1*g3, g1*g3*g4, g1*g2, g1*g2*g4, 
  451.       g1*g2*g3, g1*g2*g3*g4, g1*g2^2, g1*g2^2*g4, g1*g2^2*g3, 
  452.       g1*g2^2*g3*g4 ]
  453.     gap> AsGroup( last );
  454.     Group( g1, g2, g3, g4 ) |
  455.  
  456. The default function 'GroupOps.AsGroup' for a group <D> returns a copy of
  457. <D>.  If <D>  is a  subgroup then  a   subgroup is  returned. The default
  458. function 'GroupElementsOps.AsGroup' expects a list <D> of group  elements
  459. forming a  group  and uses successively 'Closure'  in  order to compute a
  460. reduced generating set.
  461.  
  462. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  463. \Section{IsGroup}
  464.  
  465. 'IsGroup( <obj> )'
  466.  
  467. 'IsGroup' returns 'true' if  <obj>, which can be  an object of  arbitrary
  468. type, is a parent group or a subgroup and 'false' otherwise. The function
  469. will signal an error if <obj> is an unbound variable.
  470.  
  471. |    gap> IsGroup( Group( (1,2,3) ) );
  472.     true
  473.     gap> IsGroup( 1/2 );
  474.     false |
  475.  
  476. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  477. \Section{Subgroup}
  478.  
  479. 'Subgroup( <G>, <L> )'
  480.  
  481. Let <G> be a parent group and <L> be a  list  of elements $g_1, ..., g_n$
  482. of <G>.  'Subgroup' returns the subgroup $U$ generated by $g_1, ..., g_n$
  483. with parent group $G$.
  484.  
  485. Note  that this function  is  the only  group  function in which the name
  486. 'Subgroup'  does not   refer  to  the  mathematical terms  subgroup   and
  487. supergroup but  to the implementation  of  groups as subgroups and parent
  488. groups.   'IsSubgroup'  (see   "IsSubgroup")  is  not   the   negation of
  489. 'IsParent'  (see   "IsParent")  but   decides   subgroup  and  supergroup
  490. relations.
  491.  
  492. 'Subgroup' always binds a copy of <L> to '$U$.generators',  so it is safe
  493. to modify <L> after calling 'Subgroup' because  this will  not change the
  494. entries in $U$.
  495.  
  496. Let $g_{i_1}, ..., g_{i_m}$ be  the nontrivial  generators.   'Subgroups'
  497. binds these generators to '<U>.1', ..., '<U>.m'.
  498.  
  499. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  500.     Group( (1,2,3,4), (1,2) )
  501.     gap> v4 := Subgroup( s4, [ (1,2), (1,2)(3,4) ] );
  502.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2), (1,2)(3,4) ] )
  503.     gap> IsParent( v4 );
  504.     false |
  505.  
  506. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  507. \Section{AsSubgroup}
  508.  
  509. 'AsSubgroup( <G>, <U> )'
  510.  
  511. Let <G> be a parent group and <U> be a parent group or  a subgroup with a
  512. possibly different parent group, such that the generators $g_1, ..., g_n$
  513. of <U> are elements of <G>.  'AsSubgroup' returns a new subgroup $S$ such
  514. that $S$ has parent group <G> and is generated by $g_1, ..., g_n$.
  515.  
  516. |    gap> d8 := Group( (1,2,3,4), (1,2)(3,4) );
  517.     Group( (1,2,3,4), (1,2)(3,4) )
  518.     gap> z := Centre( d8 );
  519.     Subgroup( Group( (1,2,3,4), (1,2)(3,4) ), [ (1,3)(2,4) ] )
  520.     gap> s4 := Group( (1,2,3,4), (1,2) );
  521.     Group( (1,2,3,4), (1,2) )
  522.     gap> Normalizer( s4, AsSubgroup( s4, z ) );
  523.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (2,4), (1,2,3,4), (1,3)(2,4) 
  524.      ] ) |
  525.  
  526. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  527.  
  528. \Section{Subgroups}
  529.  
  530. The following sections describe functions that compute certain  subgroups
  531. of  a given group, e.g.,  'SylowSubgroup' computes  a Sylow subgroup of a
  532. group  (see  "Centralizer",  "Centre",  "Closure",  "CommutatorSubgroup",
  533. "ConjugateSubgroup",    "Core",   "DerivedSubgroup",   "FittingSubgroup",
  534. "NormalClosure",  "NormalIntersection", "Normalizer", "PCore", "Radical",
  535. "SylowSubgroup", "TrivialSubgroup").
  536.  
  537. They  return  group  records as  described in  "Group  Records"  for  the
  538. computed subgroups.  Some functions  may not terminate if the given group
  539. has  an infinite set  of elements, while other functions  may  signal  an
  540. error in such cases.
  541.  
  542. Here the term ``subgroup\'\'\ is used  in  a mathematical sense.  But  in
  543. {\GAP},  every group is either a parent group or  a  subgroup of a unique
  544. parent group.  If you compute a  Sylow subgroup  $S$ of a group $U$  with
  545. parent group $G$ then $S$ is a  subgroup of $U$ but its  parent group  is
  546. $G$ (see "More about Groups and Subgroups").
  547.  
  548. Further sections describe functions that return factor groups  of a given
  549. group (see "FactorGroup" and "CommutatorFactorGroup").
  550.  
  551. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  552. \Section{Centralizer}
  553.  
  554. 'Centralizer( <G>, <x> )'
  555.  
  556. 'Centralizer' returns the centralizer of an element <x> in <G>  where <x>
  557. must be an element of the parent group of <G>.
  558.  
  559. The *centralizer* of an element <x> in <G>  is defined as the set  $C$ of
  560. elements $c$ of <G> such that <c> and <x> commute.
  561.  
  562. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  563.     Group( (1,2,3,4), (1,2) )
  564.     gap> v4 := Centralizer( s4, (1,2) );
  565.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (3,4), (1,2) ] ) |
  566.  
  567. The  default    function 'GroupOps.Centralizer'   uses  'Stabilizer' (see
  568. "Stabilizer") in order to compute the centralizer of <x> in <G> acting by
  569. conjugation.
  570.  
  571. 'Centralizer( <G>, <U> )'
  572.  
  573. 'Centralizer'  returns the centralizer  of a group   <U>  in <G> as group
  574. record.  Note that <G> and <U> must have a common parent group.
  575.  
  576. The *centralizer* of  a group <U> in <G>  is  defined as  the set $C$  of
  577. elements $c$ of $C$ such $c$ commutes with every element of <U>.
  578.  
  579. If <G> is  the parent group of <U>  then 'Centralizer' will set  and test
  580. the  record   component '<U>.centralizer'.
  581.  
  582. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  583.     Group( (1,2,3,4), (1,2) )
  584.     gap> v4 := Centralizer( s4, (1,2) );
  585.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (3,4), (1,2) ] )
  586.     gap> c2 := Subgroup( s4, [ (1,3) ] );
  587.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3) ] )
  588.     gap> Centralizer( v4, c2 );
  589.     Subgroup( Group( (1,2,3,4), (1,2) ), [  ] ) |
  590.  
  591. The default function 'GroupOps.Centralizer' uses 'Stabilizer' in order to
  592. compute successively the stabilizer of the generators of <U>.
  593.  
  594. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  595. \Section{Centre}
  596.  
  597. 'Centre( <G> )'
  598.  
  599. 'Centre' returns the centre of <G>.
  600.  
  601. The *centre* of a group <G> is defined as the centralizer of <G> in <G>.
  602.  
  603. Note that 'Centre' sets and tests the record component '<G>.centre'.
  604.  
  605. |    gap> d8 := Group( (1,2,3,4), (1,2)(3,4) );
  606.     Group( (1,2,3,4), (1,2)(3,4) )
  607.     gap> Centre( d8 );
  608.     Subgroup( Group( (1,2,3,4), (1,2)(3,4) ), [ (1,3)(2,4) ] ) |
  609.  
  610. The default   group function   'GroupOps.Centre' uses  'Centralizer' (see
  611. "Centralizer") in order to compute the centralizer of <G> in <G>.
  612.  
  613. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  614. \Section{Closure}
  615.  
  616. 'Closure( <U>, <g> )'
  617.  
  618. Let <U> be  a group with  parent group $G$  and let <g> be an  element of
  619. $G$. Then 'Closure' returns the closure $C$ of <U> and <g> as subgroup of
  620. $G$. The closure $C$ of <U> and <g> is  the subgroup generated by <U> and
  621. <g>.
  622.  
  623. |    gap> s4 := Group( (1,2,3,4), (1,2 ) );
  624.     Group( (1,2,3,4), (1,2) )
  625.     gap> s2 := Subgroup( s4, [ (1,2) ] );
  626.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )
  627.     gap> Closure( s2, (3,4) );
  628.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2), (3,4) ] ) |
  629.  
  630. The default function 'GroupOps.Closure'  returns <U> if <U> is  a  parent
  631. group, or if <g> or its inverse  is a generator of  <U>, or if the set of
  632. elements  is  known  and  <g>  is in  this  set,  or  if <g>  is trivial.
  633. Otherwise the function constructs a  new subgroup $C$  which is generated
  634. by the generators of <U> and the element <g>.
  635.  
  636. Note  that if the set of elements of <U> is bound to '<U>.elements'  then
  637. 'GroupOps.Closure'  computes the set of elements  for $C$ and binds it to
  638. '$C$.elements'.
  639.  
  640. If <U> is known to be non-abelian or infinite so is $C$.  If <U> is known
  641. to be  abelian  the  function  checks  whether  <g>  commutes  with every
  642. generator of <U>.
  643.  
  644. 'Closure( <U>, <S> )'
  645.  
  646. Let <U> and <S> be  two  group with a   common parent  group   $G$.  Then
  647. 'Closure' returns the subgroup of $G$ generated by <U> and <S>.
  648.  
  649. |    gap> s4 := Group( (1,2,3,4), (1,2 ) );
  650.     Group( (1,2,3,4), (1,2) )
  651.     gap> s2 := Subgroup( s4, [ (1,2) ] );
  652.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )
  653.     gap> z3 := Subgroup( s4, [ (1,2,3) ] );
  654.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3) ] )
  655.     gap> Closure( z3, s2 );
  656.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] ) |
  657.  
  658. The default function 'GroupOps.Closure' returns the parent of <U> and <S>
  659. if <U> or <S> is  a  parent group. Otherwise  the  function computes  the
  660. closure of <U> under all generators of <S>.
  661.  
  662. Note that if the set  of elements of <U> is  bound to '<U>.elements' then
  663. 'GroupOps.Closure' computes the set of  elements for the closure $C$  and
  664. binds it to '$C$.elements'.
  665.  
  666. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  667. \Section{CommutatorSubgroup}
  668.  
  669. 'CommutatorSubgroup( <G>, <H> )'
  670.  
  671. Let <G>   and    <H>   be   groups    with   a  common     parent  group.
  672. 'CommutatorSubgroup' returns the commutator subgroup $[ G, H ]$.
  673.  
  674. The *commutator subgroup* of  <G> and <H>  is the group  generated by all
  675. commutators $[ g, h ]$ with $g\in <G>$ and $h\in <H>$.
  676.  
  677. See also 'DerivedSubgroup' ("DerivedSubgroup").
  678.  
  679. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  680.     Group( (1,2,3,4), (1,2) )
  681.     gap> d8 := Group( (1,2,3,4), (1,2)(3,4) );
  682.     Group( (1,2,3,4), (1,2)(3,4) )
  683.     gap> CommutatorSubgroup( s4, AsSubgroup( s4, d8 ) );
  684.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3)(2,4), (1,3,2) ] ) |
  685.  
  686. Let <G> be generated by $g_1,  ..., g_n$ and <H>  be generated  by  $h_1,
  687. ..., h_m$.   The normal  closure of the  subgroup $S$ generated by $Comm(
  688. g_i, h_j )$ for $1 \leq i \leq n$ and $1 \leq j \leq m$ under <G> and <H>
  689. is  the commutator  subgroup  of  <G> and  <H>  (see  \cite{Hup67}).  The
  690. default function 'GroupOps.CommutatorSubgroup' returns the normal closure
  691. of $S$ under the closure of <G> and <H>.
  692.  
  693. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  694. \Section{ConjugateSubgroup}
  695.  
  696. 'ConjugateSubgroup( <U>, <g> )'
  697.  
  698. 'ConjugateSubgroup' returns the subgroup $<U>^<g>$ conjugate to <U> under
  699. <g>, which must be an element of the parent group of <G>.
  700.  
  701. If       present,   the      flags      '<U>.isAbelian',  '<U>.isCyclic',
  702. '<U>.isElementaryAbelian',      '<U>.isFinite',        '<U>.isNilpotent',
  703. '<U>.isPerfect',   '<U>.isSimple', '<U>.isSolvable', and   '<U>.size' are
  704. copied to $<U>^<g>$.
  705.  
  706. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  707.     Group( (1,2,3,4), (1,2) )
  708.     gap> c2 := Subgroup( s4, [ (1,2)(3,4) ] );
  709.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2)(3,4) ] )
  710.     gap> ConjugateSubgroup( c2, (1,3) );
  711.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,4)(2,3) ] ) |
  712.  
  713. The default function 'GroupOps.ConjugateSubgroup' returns  <U> if the set
  714. of elements of <U> is known and <g> is an element  of this  set or if <g>
  715. is  a generator  of  <U>.  Otherwise it conjugates the  generators of <U>
  716. with <g>.
  717.  
  718. If  the set  of elements  of <U> is   known  the default   function  also
  719. conjugates and binds it to the conjugate subgroup.
  720.  
  721. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  722. \Section{Core}
  723.  
  724. 'Core( <S>, <U> )'
  725.  
  726. Let <S>  and <U>  be groups with a common  parent group $G$.  Then 'Core'
  727. returns the core of <U> under conjugation of <S>.
  728.  
  729. The  *core* of a group <U> under a group  <S> $Core_{<S>}(  <U> )$ is the
  730. intersection  $\bigcap_{s\in <S>} <U>^s$ of  all  groups conjugate to <U>
  731. under conjugation by elements of <S>.
  732.  
  733. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  734.     Group( (1,2,3,4), (1,2) )
  735.     gap> s4.name := "s4";;
  736.     gap> d8 := Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] );
  737.     Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] )
  738.     gap> Core( s4, d8 );
  739.     Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] )
  740.     gap> Core( d8, s4 );
  741.     s4 |
  742.  
  743. The default function 'GroupOps.Core' starts   with <U> and  replaces  <U>
  744. with  the intersection of <U>   and a conjugate subgroup  of  <U> under a
  745. generator of <G> until the subgroup is normalized by <G>.
  746.  
  747. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  748. \Section{DerivedSubgroup}
  749.  
  750. 'DerivedSubgroup( <G> )'
  751.  
  752. 'DerivedSubgroup' returns  the derived subgroup  $<G>^\prime = [ <G>, <G>
  753. ]$ of <G>.
  754.  
  755. The *derived subgroup* of <G> is the  group generated  by all commutators
  756. $[ g, h ]$ with $g, h\in <G>$.
  757.  
  758. Note   that  'DerivedSubgroup' sets  and   tests   '<G>.derivedSubgroup'.
  759. 'CommutatorSubgroup' (see "CommutatorSubgroup") allows you to compute the
  760. commutator group of two subgroups.
  761.  
  762. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  763.     Group( (1,2,3,4), (1,2) )
  764.     gap> DerivedSubgroup( s4 );
  765.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3,2), (2,4,3) ] ) |
  766.  
  767. Let   <G> be generated by  $g_1,  ...,  g_n$.  Then  the default function
  768. 'GroupOps.DerivedSubgroup' returns the  normal  closure of $S$ under  <G>
  769. where $S$ is the subgroup of <G> generated by $Comm(  g_i,  g_j )$ for $1
  770. \leq j \< i \leq n$.
  771.  
  772. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  773. \Section{FittingSubgroup}
  774.  
  775. 'FittingSubgroup( <G> )'
  776.  
  777. 'FittingSubgroup' returns the Fitting subgroup of <G>.
  778.  
  779. The *Fitting subgroup* of a  group  <G> is the  biggest  nilpotent normal
  780. subgroup of <G>.
  781.  
  782. |    gap> s4;
  783.     Group( (1,2,3,4), (1,2) )
  784.     gap> FittingSubgroup( s4 );
  785.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2)(3,4), (1,4)(2,3) ] )
  786.     gap> IsNilpotent( last );
  787.     true |
  788.  
  789. Let  <G>  be   a  finite  group.     Then  the  default  group   function
  790. 'GroupOps.FittingSubgroup' computes the subgroup of  <G> generated by the
  791. cores of the Sylow subgroups in <G>.
  792.  
  793. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  794. \Section{NormalClosure}
  795.  
  796. 'NormalClosure( <S>, <U> )'
  797.  
  798. Let  <S>  and <U>  be  groups  with  a  common  parent group  $G$.   Then
  799. 'NormalClosure' returns the normal closure of <U> under <S> as a subgroup
  800. of $G$.
  801.  
  802. The *normal  closure* $N$ of a group <U>  under the action of a group <S>
  803. is the smallest subgroup in $G$ that contains <U>  and is invariant under
  804. conjugation by elements of <S>.  Note that $N$ is independent of $G$.
  805.  
  806. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  807.     Group( (1,2,3,4), (1,2) )
  808.     gap> s4.name := "s4";;
  809.     gap> d8 := Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] );
  810.     Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] )
  811.     gap> NormalClosure( s4, d8 );
  812.     Subgroup( s4, [ (1,2,3,4), (1,2)(3,4), (1,3,4,2) ] )
  813.     gap> last = s4;
  814.     true |
  815.  
  816. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  817. \Section{NormalIntersection}
  818.  
  819. 'NormalIntersection( <N>, <U> )'
  820.  
  821. Let  <N>  and  <U>  be  two  subgroups   with  a  common   parent  group.
  822. 'NormalIntersection' returns the intersection in case <U> normalizes <N>.
  823.  
  824. Depending on the domain this may be faster  than the general intersection
  825. algorithm     (see       "Intersection").    The     default     function
  826. 'GroupOps.NormalIntersection' however uses 'Intersection'.
  827.  
  828. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  829. \Section{Normalizer}
  830.  
  831. 'Normalizer( <S>, <U> )'
  832.  
  833. Let   <S> and <U>  be groups  with  a  common   parent  group  $G$.  Then
  834. 'Normalizer' returns the normalizer of <U> in <S>.
  835.  
  836. The *normalizer* $N_{<S>}( <U> )$  of <U> in  <S> is the biggest subgroup
  837. of <S> which leaves <U> invariant under conjugation.
  838.  
  839. If <S>  is  the parent group of   <U>  then 'Normalizer'  sets and  tests
  840. '<U>.normalizer'.
  841.  
  842. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  843.     Group( (1,2,3,4), (1,2) )
  844.     gap> c2 := Subgroup( s4, [ (1,2) ] );
  845.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )
  846.     gap> Normalizer( s4, c2 );
  847.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (3,4), (1,2) ] ) |
  848.  
  849. The  default  function   'GroupOps.Normalizer'  uses    'Stabilizer' (see
  850. "Stabilizer") in order to compute the stabilizer of <U> in  <S> acting by
  851. conjugation (see "ConjugateSubgroup").
  852.  
  853. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  854. \Section{PCore}
  855.  
  856. 'PCore( <G>, <p> )'
  857.  
  858. 'PCore' returns the <p>-core of the finite group <G> for a prime <p>.
  859.  
  860. The <p>-core is the largest normal subgroup whose size is a power of <p>.
  861. This   is  the  core   of  the  Sylow-<p>-subgroups   (see   "Core"   and
  862. "SylowSubgroup").
  863.  
  864. Note that 'PCore' sets and tests '<G>.pCores[ <p> ]'.
  865.  
  866. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  867.     Group( (1,2,3,4), (1,2) )
  868.     gap> PCore( s4, 2 );
  869.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3)(2,4), (1,4)(2,3) ] )
  870.     gap> PCore( s4, 3 );
  871.     Subgroup( Group( (1,2,3,4), (1,2) ), [  ] ) |
  872.  
  873. The default function 'GroupOps.PCore' computes  the <p>-core as  the core
  874. of a Sylow-<p>-subgroup (see "Core" and "SylowSubgroup").
  875.  
  876. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  877. \Section{Radical}
  878.  
  879. 'Radical( <G> )'
  880.  
  881. 'Radical' returns the radical of the finite group <G>.
  882.  
  883. The radical is the largest normal solvable subgroup of <G>.
  884.  
  885. |    gap> g := Group( (1,5), (1,5,6,7,8)(2,3,4) );
  886.     Group( (1,5), (1,5,6,7,8)(2,3,4) )
  887.     gap> Radical( g );
  888.     Subgroup( Group( (1,5), (1,5,6,7,8)(2,3,4) ), [ (2,3,4) ] ) |
  889.  
  890. The default function  'GroupOps.Radical'  tests if  <G>  is  solvable and
  891. signals an error if not.
  892.  
  893. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  894. \Section{SylowSubgroup}
  895.  
  896. 'SylowSubgroup( <G>, <p> )'
  897.  
  898. 'SylowSubgroup' returns a Sylow-<p>-subgroup of the finite group  <G> for
  899. a prime <p>.
  900.  
  901. Let <p> be a prime and <G> be a finite group of order $<p>^n m$ where $m$
  902. is relative prime to <p>. Then by Sylow\'s theorem there  exists at least
  903. one subgroup $S$ of <G> of order $<p>^n$.
  904.  
  905. Note that 'SylowSubgroup' sets and tests '<G>.sylowSubgroups[ <p> ]'.
  906.  
  907. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  908.     Group( (1,2,3,4), (1,2) )
  909.     gap> SylowSubgroup( s4, 2 );
  910.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (2,3), (1,4)(2,3), (1,2)(3,4)
  911.      ] )
  912.     gap> SylowSubgroup( s4, 3 );
  913.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (2,3,4) ] ) |
  914.  
  915. The  default  function   'GroupOps.SylowSubgroup' computes  the   set  of
  916. elements of  <p> power  order  of <G>,  starts  with such an element   of
  917. maximal order and computes the  closure (see  "Closure") with normalizing
  918. elements of <p> power order until a Sylow group is found.
  919.  
  920. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  921. \Section{TrivialSubgroup}
  922.  
  923. 'TrivialSubgroup( <U> )'
  924.  
  925. Let <U> be a group with parent group $G$. Then  'TrivialSubgroup' returns
  926. the trivial subgroup $T$ of <U>. Note that the parent group of $T$ is $G$
  927. not <U> (see "Subgroups").
  928.  
  929. The default function 'GroupOps.TrivialSubgroup' binds the set of elements
  930. of <U>, namely $[ <U>.identity ]$, to '$T$.elements',
  931.  
  932. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  933. \Section{FactorGroup}
  934.  
  935. 'FactorGroup( <G>, <N> )'
  936.  
  937. 'FactorGroup' returns the factor group $<G> /  <N>$  where <N> must  be a
  938. normal subgroup of <G> (see "IsNormal").  This is the same as '<G> / <N>'
  939. (see "Operations for Groups").
  940.  
  941. 'NaturalHomomorphism' returns the  natural  homomorphism  from  <G> (or a
  942. subgroup thereof) onto the factor group (see "NaturalHomomorphism").
  943.  
  944. It is not specified how the factor group <N> is represented.
  945.  
  946. |    gap> a4 := Group( (1,2,3), (2,3,4) );;  a4.name := "a4";
  947.     "a4"
  948.     gap> v4 := Subgroup(a4,[(1,2)(3,4),(1,3)(2,4)]);;  v4.name := "v4";
  949.     "v4"
  950.     gap> f := FactorGroup( a4, v4 );
  951.     (a4 / v4)
  952.     gap> Size( f );
  953.     3
  954.     gap> Elements( f );
  955.     [ FactorGroupElement( v4, () ), FactorGroupElement( v4, (2,3,4) ), 
  956.       FactorGroupElement( v4, (2,4,3) ) ] |
  957.  
  958. If <G> is the parent group of  <N>,  'FactorGroup'  first checks  for the
  959. knowledge  component  '<N>.factorGroup'.   If  this component  is  bound,
  960. 'FactorGroup'  returns  its   value.    Otherwise,   'FactorGroup'  calls
  961. '<G>.operations.FactorGroup( <G>, <N> )', remembers the returned value in
  962. '<N>.factorGroup',  and returns it.  If  <G>  is not  the parent group of
  963. <N>,  'FactorGroup' calls  '<G>.operations.FactorGroup(  <G>, <N> )'  and
  964. returns this value.
  965.  
  966. The  default  function  called this way  is  'GroupOps.FactorGroup'.   It
  967. returns the  factor  group  as a  group  of  factor group  elements  (see
  968. "FactorGroupElement").  Look under *FactorGroup* in the index to see  for
  969. which groups this function is overlaid.
  970.  
  971. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  972. \Section{FactorGroupElement}
  973.  
  974. 'FactorGroupElement( <N>, <g> )'
  975.  
  976. 'FactorGroupElement' returns the coset '<N>  \*\ <g>' as a group element.
  977. It is not tested  whether  <g> normalizes <N>, but <g> must be an element
  978. of the parent group of <N>.
  979.  
  980. Factor group elements returned by 'FactorGroupElement' are represented by
  981. records.  Those records contain the following components.
  982.  
  983. 'isGroupElement': \\
  984.         contains 'true'.
  985.  
  986. 'isFactorGroupElement': \\
  987.         contains 'true'.
  988.  
  989. 'element': \\
  990.         contains a right coset of <N> (see "RightCoset").
  991.  
  992. 'domain': \\
  993.         contains 'FactorGroupElements' (see "Domain").
  994.  
  995. 'operations': \\
  996.         contains the operations record 'FactorGroupElementOps'.
  997.  
  998. All operations for group elements (see  "Operations for  Group Elements")
  999. are available for  factor group elements, e.g., two factor group elements
  1000. can be multiplied (provided that they have the same subgroup <N>).
  1001.  
  1002. |    gap> a4 := Group( (1,2,3), (2,3,4) );;  a4.name := "a4";;
  1003.     gap> v4 := Subgroup(a4,[(1,2)(3,4),(1,3)(2,4)]);;  v4.name := "v4";;
  1004.     gap> x := FactorGroupElement( v4, (1,2,3) );
  1005.     FactorGroupElement( v4, (2,4,3) )
  1006.     gap> y := FactorGroupElement( v4, (2,3,4) );
  1007.     FactorGroupElement( v4, (2,3,4) )
  1008.     gap> x * y;
  1009.     FactorGroupElement( v4, () ) |
  1010.  
  1011. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1012. \Section{CommutatorFactorGroup}
  1013.  
  1014. 'CommutatorFactorGroup( <G> )'
  1015.  
  1016. 'CommutatorFactorGroup' returns  a  group isomorphic  to <G>/$<G>^\prime$
  1017. where     $<G>^\prime$    is     the  derived    subgroup   of  <G>  (see
  1018. "DerivedSubgroup").
  1019.  
  1020. |    gap> s4 := AgGroup( Group( (1,2,3,4), (1,2) ) );
  1021.     Group( g1, g2, g3, g4 )
  1022.     gap> CommutatorFactorGroup( s4 );
  1023.     Group( g1 ) |
  1024.  
  1025. The   default   group function   'GroupOps.CommutatorFactorGroup'    uses
  1026. 'DerivedSubgroup'    (see   "DerivedSubgroup")   and  'FactorGroup'  (see
  1027. "FactorGroup") in order to compute the commutator factor group.
  1028.  
  1029. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1030.  
  1031. \Section{Series of Subgroups}
  1032.  
  1033. The following sections describe functions that compute and  return series
  1034. of subgroups of a given group (see "DerivedSeries", "LowerCentralSeries",
  1035. "SubnormalSeries", and "UpperCentralSeries").  The series are returned as
  1036. lists of subgroups of the group (see "More about Groups and Subgroups").
  1037.  
  1038. These  functions  print warnings  if the argument  is an infinite  group,
  1039. because they may run forever.
  1040.  
  1041. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1042. \Section{DerivedSeries}
  1043.  
  1044. 'DerivedSeries( <G> )'
  1045.  
  1046. 'DerivedSeries' returns the derived series of <G>.
  1047.  
  1048. The *derived series*  is the series  of iterated derived  subgroups.  The
  1049. group <G> is solvable  if and only if this  series reaches  $\{1\}$ after
  1050. finitely many steps.
  1051.  
  1052. Note that this function does  not terminate  if <G>  is an infinite group
  1053. with derived  series of  infinite  length. 
  1054.  
  1055. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1056.     Group( (1,2,3,4), (1,2) )
  1057.     gap> DerivedSeries( s4 );
  1058.     [ Group( (1,2,3,4), (1,2) ), Subgroup( Group( (1,2,3,4), (1,2) ), 
  1059.         [ (1,3,2), (2,4,3) ] ), Subgroup( Group( (1,2,3,4), (1,2) ), 
  1060.         [ (1,4)(2,3), (1,2)(3,4) ] ), 
  1061.       Subgroup( Group( (1,2,3,4), (1,2) ), [  ] ) ] |
  1062.  
  1063. The default function 'GroupOps.DerivedSeries' uses 'DerivedSubgroup' (see
  1064. "DerivedSubgroup") in order to compute the derived series of <G>.
  1065.  
  1066. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1067. \Section{CompositionSeries}
  1068.  
  1069. 'CompositionSeries( <G> )'
  1070.  
  1071. 'CompositionSeries'  returns  a composition  series  of <G>  as  list  of
  1072. subgroups.
  1073.  
  1074. |    gap> s4 := SymmetricGroup( 4 );
  1075.     Group( (1,4), (2,4), (3,4) )
  1076.     gap> s4.name := "s4";;
  1077.     gap> CompositionSeries( s4 );
  1078.     [ Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4), (1,2,4), (1,4) ] ), 
  1079.       Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4), (1,2,4) ] ), 
  1080.       Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] ), 
  1081.       Subgroup( s4, [ (1,2)(3,4) ] ), Subgroup( s4, [  ] ) ]
  1082.     gap> d8 := SylowSubgroup( s4, 2 );
  1083.     Subgroup( s4, [ (1,2), (3,4), (1,3)(2,4) ] )
  1084.     gap> CompositionSeries( d8 );
  1085.     [ Subgroup( s4, [ (3,4), (1,2), (1,3)(2,4) ] ), 
  1086.       Subgroup( s4, [ (3,4), (1,2) ] ), Subgroup( s4, [ (3,4) ] ), 
  1087.       Subgroup( s4, [  ] ) ] |
  1088.  
  1089. Note  that there  is no  default  function.  'GroupOps.CompositionSeries'
  1090. signals an error if called.
  1091.  
  1092. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1093. \Section{ElementaryAbelianSeries}
  1094.  
  1095. 'ElementaryAbelianSeries( <G> )'
  1096.  
  1097. Let <G> be  a solvable  group  (see  "IsSolvable").   Then the  functions
  1098. returns a normal series $G = E_0, E_1, ..., E_n = \{1\}$ of <G> such that
  1099. the factor groups $E_i / E_{i+1}$ are elementary abelian groups.
  1100.  
  1101. |    gap> s5 := SymmetricGroup( 5 );; s5.name := "s5";;
  1102.     gap> s4 := Subgroup( s5, [ (2,3,4,5), (2,3) ] );
  1103.     Subgroup( s5, [ (2,3,4,5), (2,3) ] )
  1104.     gap> ElementaryAbelianSeries( s4 );
  1105.     [ Subgroup( s5, [ (2,3)(4,5), (2,5)(3,4), (2,3,5), (2,3,4,5) ] ), 
  1106.       Subgroup( s5, [ (2,3)(4,5), (2,5)(3,4), (2,3,5) ] ), 
  1107.       Subgroup( s5, [ (2,3)(4,5), (2,5)(3,4) ] ), Subgroup( s5, [  ] ) ] |
  1108.  
  1109. The  default  function 'GroupOps.ElementaryAbelianSeries' uses  'AgGroup'
  1110. (see "AgGroup") in order to  convert <G> into  an isomorphic ag group and
  1111. computes   the  elementary   abelian   series   in   this   group.   (see
  1112. "ElementaryAbelianSeries for Ag Groups").
  1113.  
  1114. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1115. \Section{LowerCentralSeries}
  1116.  
  1117. 'LowerCentralSeries( <G> )'
  1118.  
  1119. 'LowerCentralSeries' returns the lower central series of <G> as a list of
  1120. group records.
  1121.  
  1122. The  *lower central series*  is  the series defined  by  $S_1 = <G>$  and
  1123. $S_i = [  <G>, S_{i-1} ]$.   The group <G>  is  nilpotent  if this series
  1124. reaches $\{1\}$ after finitely many steps.
  1125.  
  1126. Note that  this function may not terminate  if <G> is an  infinite group.
  1127. 'LowerCentralSeries'     sets  and  tests    the     record     component
  1128. '<G>.lowerCentralSeries' in the group record of <G>.
  1129.  
  1130. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1131.     Group( (1,2,3,4), (1,2) )
  1132.     gap> LowerCentralSeries( s4 );
  1133.     [ Group( (1,2,3,4), (1,2) ), Subgroup( Group( (1,2,3,4), (1,2) ), 
  1134.         [ (1,3,2), (2,4,3) ] ) ] |
  1135.  
  1136. The   default    group   function     'GroupOps.LowerCentralSeries'  uses
  1137. 'CommutatorSubgroup' (see "CommutatorSubgroup")  in  order to compute the
  1138. lower central series of <G>.
  1139.  
  1140. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1141. \Section{PCentralSeries}
  1142.  
  1143. 'PCentralSeries( <G>, <p> )'
  1144.  
  1145. 'PCentralSeries' returns the  <p>-central  series  of  a  group <G> for a
  1146. prime <p>.
  1147.  
  1148. The *p-central series* of a group  <G> is defined as  follows.  $S_1 = G$
  1149. and $S_{i+1}$ is set to $[G,S_i] \* S_i^p$.  The length of this series is
  1150. $n$, where $n = max\{ i ; S_i > S_{i+1} \}$.
  1151.  
  1152. |    gap> s4 := Group( (1,2,3,4), (1,2) );; s4.name := "s4";;
  1153.     gap> PCentralSeries( s4, 3 );
  1154.     [ s4 ]
  1155.     gap> PCentralSeries( s4, 2 );
  1156.     [ s4, Subgroup( s4, [ (1,2,3), (2,3,4) ] ) ] |
  1157.  
  1158. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1159. \Section{SubnormalSeries}
  1160.  
  1161. 'SubnormalSeries( <G>, <U> )'
  1162.  
  1163. Let <U> be a subgroup of <G>, then 'SubnormalSeries' returns  a subnormal
  1164. series $<G> = G_1  > ... > G_n$ of  groups such that  <U> is contained in
  1165. $G_n$ and there exists no proper subgroup $V$ between $G_n$ and <U> which
  1166. is normal in $G_n$.
  1167.  
  1168. $G_n$ is equal to <U> if and only if <U> is *subnormal* in <G>.
  1169.  
  1170. Note that this function  may not terminate if  <G>  is an infinite group.
  1171.  
  1172. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1173.     Group( (1,2,3,4), (1,2) )
  1174.     gap> c2 := Subgroup( s4, [ (1,2) ] );
  1175.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )
  1176.     gap> SubnormalSeries( s4, c2 );
  1177.     [ Group( (1,2,3,4), (1,2) ) ]
  1178.     gap> IsSubnormal( s4, c2 );
  1179.     false
  1180.     gap> c2 := Subgroup( s4, [ (1,2)(3,4) ] );
  1181.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2)(3,4) ] )
  1182.     gap> SubnormalSeries( s4, c2 );
  1183.     [ Group( (1,2,3,4), (1,2) ), Subgroup( Group( (1,2,3,4), (1,2) ), 
  1184.         [ (1,2)(3,4), (1,4)(2,3) ] ), 
  1185.       Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2)(3,4) ] ) ]
  1186.     gap> IsSubnormal( s4, c2 );
  1187.     true |
  1188.  
  1189. The default function 'GroupOps.SubnormalSeries' constructs  the subnormal
  1190. series as follows.  $G_1 = G$ and $G_{i+1}$ is  set to the normal closure
  1191. (see "NormalClosure") of <U> under  $G_i$.  The length of  the series  is
  1192. $n$, where $n = max\{i; G_i > G_{i+1}\}$.
  1193.  
  1194. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1195. \Section{UpperCentralSeries}
  1196.  
  1197. 'UpperCentralSeries( <G> )'
  1198.  
  1199. 'UpperCentralSeries' returns the upper central series of <G> as a list of
  1200. subgroups.
  1201.  
  1202. The *upper central series* is the series $S_n,  ..., S_0$ defined by $S_0
  1203. = \{1\} \< <G>$ and $S_i/S_{i-1} = Z( <G>/S_{i-1} )$ where $n = min\{ i ;
  1204. S_i = S_{i+1} \}$
  1205.  
  1206. Note that this function may  not  terminate  if <G> is an infinite group.
  1207. 'UpperCentralSeries' sets and tests '<G>.upperCentralSeries' in the group
  1208. record of <G>.
  1209.  
  1210. |    gap> d8 := AgGroup( Group( (1,2,3,4), (1,2)(3,4) ) );
  1211.     Group( g1, g2, g3 )
  1212.     gap> UpperCentralSeries( d8 );
  1213.     [ Group( g1, g2, g3 ), Subgroup( Group( g1, g2, g3 ), [ g3 ] ), 
  1214.       Subgroup( Group( g1, g2, g3 ), [  ] ) ] |
  1215.  
  1216. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1217.  
  1218. \Section{Properties and Property Tests}
  1219.  
  1220. The following sections describe  the  functions  that  computes  or  test
  1221. properties of groups (see "AbelianInvariants",  "Factorization", "Index",
  1222. "IsAbelian",        "IsCentral",        "IsConjugate",        "IsCyclic",
  1223. "IsElementaryAbelian",    "IsNilpotent",     "IsNormal",     "IsPerfect",
  1224. "IsSimple",  "IsSolvable", "IsSubgroup",  "IsSubnormal",  "IsTrivial  for
  1225. Groups").
  1226.  
  1227. All tests expect  a  parent group or  subgroup and  return  'true' if the
  1228. group has the property  and 'false'  otherwise.   Some functions may  not
  1229. terminate if the given group has an infinite set of elements.   A warning
  1230. may be printed in such cases.
  1231.  
  1232. In   addition  the  set   theoretic  functions  'Elements',   'Size'  and
  1233. 'IsFinite', which are described in  chapter "Domains",  can be  used  for
  1234. groups.  'Size' (see "Size") returns the order of a group, this is either
  1235. a  positive  integer  or the  string {``infinity\'\'}.   'IsFinite'  (see
  1236. "IsFinite") returns 'true' if a group is finite and 'false' otherwise.
  1237.  
  1238. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1239. \Section{AbelianInvariants}
  1240.  
  1241. 'AbelianInvariants( <G> )'
  1242.  
  1243. Let  <G>  be  an  abelian group.  Then  'AbelianInvariants'  returns  the
  1244. abelian invariants of <G> as a list of integers.
  1245.  
  1246. Let  <G>  be  a finitely generated abelian  group.  Then there  exist $n$
  1247. nontrivial subgroups  $A_i$  of prime  power  order $p_i^{e_i}$  and  $m$
  1248. infinite cyclic  subgroups $Z_j$ such that $<G>  = A_1 \times ...  \times
  1249. A_n \times  Z_1  ...   \times  Z_m$.   The  *invariants* of  <G> are  the
  1250. integers $p_1^{e_1}, ..., p_n^{e_n}$ together with $m$ zeros.
  1251.  
  1252. Note that 'AbelianInvariants' tests and sets '<G>.abelianInvariants'.
  1253.  
  1254. |    gap> AbelianInvariants( AbelianGroup( AgWords, [2,3,4,5,6,9] ) );
  1255.     [ 2, 2, 3, 3, 4, 5, 9 ] |
  1256.  
  1257. The default  function 'GroupOps.AbelianInvariants' needs a finite abelian
  1258. group <G>.
  1259.  
  1260. Let <G> be a finite abelian group of  order $p_1^{e_1}...p_n^{e_n}$ where
  1261. $p_i$ are distinct  primes.   The default  function constructs  for every
  1262. prime $p_i$ the series  $<G>, <G>^{p_i},  <G>^{p_i^2}, ...$ and  computes
  1263. the abelian invariants using the indices of these groups.
  1264.  
  1265. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1266. \Section{Exponent}
  1267.  
  1268. 'Exponent( <G> )'
  1269.  
  1270. Let <G> be a finite group.  Then 'Exponent' returns the exponent of <G>.
  1271.  
  1272. Note that 'Exponent' tests and sets '<G>.exponent'.
  1273.  
  1274. |    gap> Exponent( Group( (1,2,3,4), (1,2) ) );
  1275.     12 |
  1276.  
  1277. The default function 'GroupOps.Exponent' computes all elements of <G> and
  1278. their orders.
  1279.  
  1280. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1281. \Section{Factorization}
  1282.  
  1283. 'Factorization( <G>, <g> )'
  1284.  
  1285. Let <G>  be a group  with generators $g_1, ...,  g_n$ and let  <g>  be an
  1286. element of <G>.  'Factorization' returns a  representation of <g> as word
  1287. in the generators of <G>.
  1288.  
  1289. The group record  of  <G> must have a component  '<G>.abstractGenerators'
  1290. which contains a list of $n$ abstract words $h_1, ..., h_n$.  Otherwise a
  1291. list of $n$ abstract generators is bound to '<G>.abstractGenerators'. The
  1292. function  returns  an  abstract  word   $h  = h_{i_1}^{e_1}   \*  ...  \*
  1293. h_{i_m}^{e_m}$ such that $g_{i_1}^{e_1} \* ... \* g_{i_m}^{e_m} = <g>$.
  1294.  
  1295. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1296.     Group( (1,2,3,4), (1,2) )
  1297.     gap> Factorization( s4, (1,2,3) );
  1298.     x1^3*x2*x1*x2
  1299.     gap> (1,2,3,4)^3 * (1,2) * (1,2,3,4) * (1,2);
  1300.     (1,2,3) |
  1301.  
  1302. The default group function  'GroupOps.Factorization' needs a finite group
  1303. <G>.  It computes  the set of  elements of  <G> using a Dimino algorithm,
  1304. together  with  a  representation of   these elements as   words   in the
  1305. generators of <G>.
  1306.  
  1307. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1308. \Section{Index}
  1309.  
  1310. 'Index( <G>, <U> )'
  1311.  
  1312. Let <U> be a subgroup of  <G>.  Then 'Index' returns the  index of <U> in
  1313. <G> as an integer.
  1314.  
  1315. Note that 'Index' sets and checks '<U>.index' if <G>  is the parent group
  1316. of <U>.
  1317.  
  1318. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1319.     Group( (1,2,3,4), (1,2) )
  1320.     gap> Index( s4, DerivedSubgroup( s4 ) );
  1321.     2 |
  1322.  
  1323. The  default  function  'GroupOps.Index' needs   a finite  group <G>.  It
  1324. returns the quotient of 'Size( <G> )' and 'Size( <U> )'.
  1325.  
  1326. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1327. \Section{IsAbelian}
  1328.  
  1329. 'IsAbelian( <G> )'
  1330.  
  1331. 'IsAbelian'  returns 'true' if  the  group   <G> is   abelian and 'false'
  1332. otherwise.
  1333.  
  1334. A  group  <G>  is *abelian* if  and only if  for every  $g, h\in <G>$ the
  1335. equation $g\* h = h\* g$ holds.
  1336.  
  1337. Note   that  'IsAbelian'  sets    and   tests    the   record   component
  1338. '<G>.isAbelian'.  If <G> is abelian it also  sets '<G>.centre'.
  1339.  
  1340. |    gap> s4 := Group( (1,2,3,4), (1,2) );;
  1341.     gap> IsAbelian( s4 );
  1342.     false
  1343.     gap> IsAbelian( Subgroup( s4, [ (1,2) ] ) );
  1344.     true |
  1345.  
  1346. The default  group   function 'GroupOps.IsAbelian' returns 'true' for   a
  1347. group <G> generated by $g_1,  ..., g_n$ if $g_i$  commutes with $g_j$ for
  1348. $i > j$.
  1349.  
  1350. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1351. \Section{IsCentral}
  1352.  
  1353. 'IsCentral( <G>, <U> )'
  1354.  
  1355. 'IsCentral' returns 'true' if the group <G> centralizes the group <U> and
  1356. 'false' otherwise.
  1357.  
  1358. A group <G>  *centralizes*  a group <U> if and only if for all $g\in <G>$
  1359. and for all $u\in <U>$ the equation $g\* u = u\* g$ holds.  Note that <U>
  1360. need not  to  be a subgroup  of  <G> but they  must have a  common parent
  1361. group.
  1362.  
  1363. Note that 'IsCentral' sets and tests '<U>.isCentral' if <G> is the parent
  1364. group of <U>.
  1365.  
  1366. |    gap> s4 := Group( (1,2,3,4), (1,2) );;
  1367.     gap> d8 := Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] );;
  1368.     gap> c2 := Subgroup( s4, [ (1,3)(2,4) ] );;
  1369.     gap> IsCentral( s4, c2 );
  1370.     false
  1371.     gap> IsCentral( d8, c2 );
  1372.     true |
  1373.  
  1374. The  default function 'GroupOps.IsCentral'  tests whether <G> centralizes
  1375. <U> by testing whether the generators of <G> commutes with the generators
  1376. of <U>.
  1377.  
  1378. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1379. \Section{IsConjugate}
  1380.  
  1381. 'IsConjugate( <G>, <x>, <y> )'
  1382.  
  1383. Let   <x>  and <y>   be  elements  of the  parent   group of    <G>. Then
  1384. 'IsConjugate' returns 'true' if <x> is conjugate  to <y> under an element
  1385. $g$ of <G> and 'false' otherwise.
  1386.  
  1387. |    gap> s5 := Group( (1,2,3,4,5), (1,2) );
  1388.     Group( (1,2,3,4,5), (1,2) )
  1389.     gap> a5 := Subgroup( s5, [ (1,2,3), (2,3,4), (3,4,5) ] );
  1390.     Subgroup( Group( (1,2,3,4,5), (1,2) ), [ (1,2,3), (2,3,4), (3,4,5) ] )
  1391.     gap> IsConjugate( a5, (1,2,3,4,5), (1,2,3,4,5)^2 );
  1392.     false
  1393.     gap> IsConjugate( s5, (1,2,3,4,5), (1,2,3,4,5)^2 );
  1394.     true |
  1395.  
  1396. The  default  function  'GroupOps.IsConjugate' uses 'Representative' (see
  1397. "Representative") in order to check whether <x> is conjugate to <y> under
  1398. <G>.
  1399.  
  1400. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1401. \Section{IsCyclic}
  1402.  
  1403. 'IsCyclic( <G> )'
  1404.  
  1405. 'IsCyclic' returns 'true' if <G> is cyclic and 'false' otherwise.
  1406.  
  1407. A group <G> is *cyclic* if and only if there exists an element $g\in <G>$
  1408. such that <G> is generated by $g$.
  1409.  
  1410. Note that 'IsCyclic' sets and tests the record  component '<G>.isCyclic'.
  1411.  
  1412. |    gap> z6 := Group( (1,2,3), (4,5) );;
  1413.     gap> IsCyclic( z6 );
  1414.     true
  1415.     gap> z36 := AbelianGroup( AgWords, [ 9, 4 ] );;
  1416.     gap> IsCyclic( z36 );
  1417.     true |
  1418.  
  1419. The default function 'GroupOps.IsCyclic' returns 'false' if <G> is not an
  1420. abelian  group.   Otherwise   it computes  the   abelian  invariants (see
  1421. "AbelianInvariants") if <G>  is infinite.   If   <G> is  finite of  order
  1422. $p_1^{e_1} ... p_n^{e_n}$, where $p_i$  are distinct primes, then  <G> is
  1423. cyclic if and only if each $<G>^{p_i}$ has index $p_i$ in <G>.
  1424.  
  1425. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1426. \Section{IsElementaryAbelian}
  1427.  
  1428. 'IsElementaryAbelian( <G> )'
  1429.  
  1430. 'IsElementaryAbelian' returns  'true' if  the group  <G> is an elementary
  1431. abelian $p$-group for a prime $p$ and 'false' otherwise.
  1432.  
  1433. A $p$-group <G> is *elementary abelian* if and only if for every $g, h\in
  1434. <G>$ the equations $g\* h = h\* g$ and $g^p = 1$ hold.
  1435.  
  1436. Note       that    the     'IsElementaryAbelian'     sets   and     tests
  1437. '<G>.isElementaryAbelian'.
  1438.  
  1439. |    gap> z4 := Group( (1,2,3,4) );;
  1440.     gap> IsElementaryAbelian( z4 );
  1441.     false
  1442.     gap> v4 := Group( (1,2)(3,4), (1,3)(2,4) );;
  1443.     gap> IsElementaryAbelian( v4 );
  1444.     true |
  1445.  
  1446. The default function 'GroupOps.IsElementaryAbelian' returns 'true' if <G>
  1447. is abelian and each generator is of prime order for a prime $p$.
  1448.  
  1449. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1450. \Section{IsNilpotent}
  1451.  
  1452. 'IsNilpotent( <G> )'
  1453.  
  1454. 'IsNilpotent' returns  'true' if the  group <G> is  nilpotent and 'false'
  1455. otherwise.
  1456.  
  1457. A group $G$ is *nilpotent* if and only if the lower central series of $G$
  1458. is of finite length and reaches $\{1\}$.
  1459.  
  1460. Note   that 'IsNilpotent'   sets   and   tests   the   record   component
  1461. '<G>.isNilpotent'.
  1462.  
  1463. |    gap> s4 := Group( (1,2,3,4), (1,2) );;
  1464.     gap> IsNilpotent( s4 );
  1465.     false
  1466.     gap> v4 := Group( (1,2)(3,4), (1,3)(2,4) );;
  1467.     gap> IsNilpotent( v4 );
  1468.     true |
  1469.  
  1470. The default   group function  'GroupOps.IsNilpotent' computes  the  lower
  1471. central series  using 'LowerCentralSeries' (see  "LowerCentralSeries") in
  1472. order to check whether <G> is nilpotent.
  1473.  
  1474. If $G$  has an  infinite set  of  elements  a warning is given,   as this
  1475. function does  not stop if  $G$ has  a lower   central series of infinite
  1476. length.
  1477.  
  1478. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1479. \Section{IsNormal}
  1480.  
  1481. 'IsNormal( <G>, <U> )'
  1482.  
  1483. 'IsNormal' returns 'true' if  the group  <G> normalizes the group <U> and
  1484. 'false' otherwise.
  1485.  
  1486. A group <G> *normalizes* a group <U> if and  only if for every $g\in <G>$
  1487. and $u\in <U>$ the element $u^g$ is a member of <U>.  Note  that <U> need
  1488. not be a subgroup of <G> but they must have a common parent group.
  1489.  
  1490. Note that 'IsNormal' tests and  sets '<U>.isNormal'  if <G> is the parent
  1491. group of <U>.
  1492.  
  1493. |    gap> s4 := Group( (1,2,3,4), (1,2) );;
  1494.     gap> d8 := Subgroup( s4, [ (1,2,3,4), (1,2)(3,4) ] );;
  1495.     gap> c2 := Subgroup( s4, [ (1,3)(2,4) ] );;
  1496.     gap> IsNormal( s4, c2 );
  1497.     false
  1498.     gap> IsNormal( d8, c2 );
  1499.     true |
  1500.  
  1501. Let <G> be a finite group.  Then the default function 'GroupOps.IsNormal'
  1502. checks  whether the  conjugate  of  each  generator  of  <U>  under  each
  1503. generator of <G> is an element of <U>.
  1504.  
  1505. If   <G>   is   an    infinite   group,   then   the   default   function
  1506. 'GroupOps.IsNormal' checks whether the conjugate of each generator of <U>
  1507. under each generator of <G> and its inverse is an element of <U>.
  1508.  
  1509. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1510. \Section{IsPerfect}
  1511.  
  1512. 'IsPerfect( <G> )'
  1513.  
  1514. 'IsPerfect' returns  'true'  if  <G>    is  a perfect group  and  'false'
  1515. otherwise.
  1516.  
  1517. A  group <G> is *perfect* if  <G> is equal to  its derived subgroup.  See
  1518. "DerivedSubgroup".
  1519.  
  1520. Note that 'IsPerfect' sets and tests '<G>.isPerfect'.
  1521.  
  1522. |    gap> a4 := Group( (1,2,3), (2,3,4) );
  1523.     Group( (1,2,3), (2,3,4) )
  1524.     gap> IsPerfect( a4 );
  1525.     false
  1526.     gap> a5 := Group( (1,2,3), (2,3,4), (3,4,5) );
  1527.     Group( (1,2,3), (2,3,4), (3,4,5) )
  1528.     gap> IsPerfect( a5 );
  1529.     true |
  1530.  
  1531. The default group function 'GroupOps.IsPerfect' checks for a finite group
  1532. <G> the  index of $<G>^\prime$  (see  "DerivedSubgroup")  in <G>.  For an
  1533. infinite  group it  computes  the  abelian  invariants  of the commutator
  1534. factor group (see "AbelianInvariants" and "CommutatorFactorGroup").
  1535.  
  1536. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1537. \Section{IsSimple}
  1538.  
  1539. 'IsSimple( <G> )'
  1540.  
  1541. 'IsSimple' returns 'true' if <G> is simple and 'false' otherwise.
  1542.  
  1543. A group <G> is *simple* if and only if <G>  and  the trivial subgroup are
  1544. the only normal subgroups of <G>.
  1545.  
  1546. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1547.     Group( (1,2,3,4), (1,2) )
  1548.     gap> IsSimple( DerivedSubgroup( s4 ) );
  1549.     false
  1550.     gap> s5 := Group( (1,2,3,4,5), (1,2) );
  1551.     Group( (1,2,3,4,5), (1,2) )
  1552.     gap> IsSimple( DerivedSubgroup( s5 ) );
  1553.     true |
  1554.  
  1555. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1556. \Section{IsSolvable}
  1557.  
  1558. 'IsSolvable( <G> )'
  1559.  
  1560. 'IsSolvable' returns 'true' if  the group  <G>   is solvable  and 'false'
  1561. otherwise.
  1562.  
  1563. A group $G$ is *solvable* if and only if the derived series of  $G$ is of
  1564. finite length and reaches $\{1\}$.
  1565.  
  1566. Note that 'IsSolvable' sets and tests '<G>.isSolvable'.
  1567.  
  1568. |    gap> s4 := Group( (1,2,3,4), (1,2) );;
  1569.     gap> IsSolvable( s4 );
  1570.     true |
  1571.  
  1572. The default  function 'GroupOps.IsSolvable' computes  the  derived series
  1573. using the function 'DerivedSeries' (see "DerivedSeries")  in order to see
  1574. whether <G> is solvable.
  1575.  
  1576. If  $G$ has  an infinite set   of elements a   warning is given,  as this
  1577. function does not stop if $G$ has a derived series of infinite length.
  1578.  
  1579. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1580. \Section{IsSubgroup}
  1581.  
  1582. 'IsSubgroup( <G>, <U> )'
  1583.  
  1584. 'IsSubgroup'  returns 'true' if   <U> is a  subgroup of  <G> and  'false'
  1585. otherwise.
  1586.  
  1587. Note  that <G> and  <U>  must have a common   parent group. This function
  1588. returns 'true' if and only if the set of elements of <U>  is  a subset of
  1589. the set of  elements  of <G>, it  is not the  inverse of 'IsParent'  (see
  1590. "IsParent").
  1591.  
  1592. |    gap> s6  := Group( (1,2,3,4,5,6), (1,2) );;
  1593.     gap> s4 := Subgroup( s6, [ (1,2,3,4), (1,2) ] );;
  1594.     gap> z2 := Subgroup( s6, [ (5,6) ] );;
  1595.     gap> IsSubgroup( s4, z2 );
  1596.     false
  1597.     gap> v4 := Subgroup( s6, [ (1,2)(3,4), (1,3)(2,4) ] );;
  1598.     gap> IsSubgroup( s4, v4 );
  1599.     true |
  1600.  
  1601. If  the   elements  of  <G>  are   known,  then   the   default  function
  1602. 'GroupOps.IsSubgroup' checks  whether  the set of generators of <U> is  a
  1603. subset of the set of  elements  of  <G>.   Otherwise the  function checks
  1604. whether each generator of <U> is an element of <G> using 'in'.
  1605.  
  1606. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1607. \Section{IsSubnormal}
  1608.  
  1609. 'IsSubnormal( <G>, <U> )'
  1610.  
  1611. 'IsSubnormal' returns 'true' if the subgroup <U> of <G> is subnormal in
  1612. <G> and 'false' otherwise.
  1613.  
  1614. A subgroup <U> of <G> is subnormal if and  only  if there exists a series
  1615. of subgroups $<G> =  G_0 > G_1 >  ...  >  G_n  = <U>$ such  that $G_i$ is
  1616. normal in $G_{i-1}$ for all $i\in\{1, ..., n\}$.
  1617.  
  1618. Note that <U> must be  a  subgroup of  <G>. The function  sets and checks
  1619. '<U>.isSubnormal' if <G> is the parent group of <G>.
  1620.  
  1621. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  1622.     Group( (1,2,3,4), (1,2) )
  1623.     gap> c2 := Subgroup( s4, [ (1,2) ] );
  1624.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2) ] )
  1625.     gap> IsSubnormal( s4, c2 );
  1626.     false
  1627.     gap> c2 := Subgroup( s4, [ (1,2)(3,4) ] );
  1628.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2)(3,4) ] )
  1629.     gap> IsSubnormal( s4, c2 );
  1630.     true |
  1631.  
  1632. The default  function  'GroupOps.IsSubnormal' uses 'SubnormalSeries' (see
  1633. "SubnormalSeries") in order to check if <U> is subnormal in <G>.
  1634.  
  1635. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1636. \Section{IsTrivial for Groups}%
  1637. \index{IsTrivial!for groups}
  1638.  
  1639. 'GroupOps.IsTrivial( <G> )'
  1640.  
  1641. 'GroupOps.IsTrivial'  returns 'true'  if  <G> is the   trivial  group and
  1642. 'false' otherwise.
  1643.  
  1644. Note that <G> is trivial if and only if the component 'generators' of the
  1645. group record of <G> is the empty list.  It is  faster  to check this than
  1646. to call 'IsTrivial'.
  1647.  
  1648. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1649.  
  1650. \Section{Conjugacy Classes}
  1651.  
  1652. The following sections describe how one  can compute conjugacy classes of
  1653. elements and subgroups in a group (see "ConjugacyClasses" and
  1654. "ConjugacyClassesSubgroups"). Further sections
  1655. describe   how  conjugacy  classes   of   elements   are   created   (see
  1656. "ConjugacyClass" and  "IsConjugacyClass"), and  how  they are implemented
  1657. (see  "Set  Functions  for  Conjugacy  Classes"  and   "Conjugacy   Class
  1658. Records").   Further  sections  describe how  classes  of  subgroups  are
  1659. created (see  "ConjugacyClassSubgroups" and "IsConjugacyClassSubgroups"),
  1660. and how they  are implemented  (see "Set Functions for Subgroup Conjugacy
  1661. Classes"  and  "Subgroup  Conjugacy  Class  Records").   Another  section
  1662. describes the function that  returns a conjugacy class of subgroups  as a
  1663. list of subgroups (see "ConjugateSubgroups").
  1664.  
  1665. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1666. \Section{ConjugacyClasses}
  1667.  
  1668. 'ConjugacyClasses( <G> )'
  1669.  
  1670. 'ConjugacyClasses' returns a list of the conjugacy classes of elements of
  1671. the group  <G>.   The elements in the list returned  are conjugacy  class
  1672. domains  as created  by 'ConjugacyClass' (see "ConjugacyClass").  Because
  1673. conjugacy classes are domains, all set theoretic functions can be applied
  1674. to them (see "Domains").
  1675.  
  1676. |    gap> a5 := Group( (1,2,3), (3,4,5) );;  a5.name := "a5";;
  1677.     gap> ConjugacyClasses( a5 );
  1678.     [ ConjugacyClass( a5, () ), ConjugacyClass( a5, (3,4,5) ), 
  1679.       ConjugacyClass( a5, (2,3)(4,5) ), ConjugacyClass( a5, (1,2,3,4,5) ), 
  1680.       ConjugacyClass( a5, (1,2,3,5,4) ) ] |
  1681.  
  1682. 'ConjugacyClasses' first checks  if '<G>.conjugacyClasses' is  bound.  If
  1683. the component  is  bound,  it  returns  that value.   Otherwise it  calls
  1684. '<G>.operations.ConjugacyClasses( <G> )', remembers the returned value in
  1685. '<G>.conjugacyClasses', and returns it.
  1686.  
  1687. The  default  function  called this  way  is 'GroupOps.ConjugacyClasses'.
  1688. This  function takes  random  elements in  <G> and tests whether  such  a
  1689. random element <g> lies in one of the already known classes.   If it does
  1690. not  it  adds   the   new  class   'ConjugacyClass(  <G>,  <g>   )'  (see
  1691. "ConjugacyClass").  Also after adding  a new  class it tests  whether any
  1692. power  of  the representative gives rise  to a new class.  It returns the
  1693. list of classes when the sum of the sizes is equal to the size of <G>.
  1694.  
  1695. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1696. \Section{ConjugacyClass}
  1697.  
  1698. 'ConjugacyClass( <G>, <g> )'
  1699.  
  1700. 'ConjugacyClass' returns the conjugacy class of the  element  <g> in  the
  1701. group  <G>.  Signals  an  error  if <g> is not an  element in  <G>.   The
  1702. conjugacy class  is returned as a  domain,  so  that  all  set  theoretic
  1703. functions are applicable (see "Domains").
  1704.  
  1705. |    gap> a5 := Group( (1,2,3), (3,4,5) );;  a5.name := "a5";;
  1706.     gap> c := ConjugacyClass( a5, (1,2,3,4,5) );
  1707.     ConjugacyClass( a5, (1,2,3,4,5) )
  1708.     gap> Size( c );
  1709.     12
  1710.     gap> Representative( c );
  1711.     (1,2,3,4,5)
  1712.     gap> Elements( c );
  1713.     [ (1,2,3,4,5), (1,2,4,5,3), (1,2,5,3,4), (1,3,5,4,2), (1,3,2,5,4), 
  1714.       (1,3,4,2,5), (1,4,3,5,2), (1,4,5,2,3), (1,4,2,3,5), (1,5,4,3,2), 
  1715.       (1,5,2,4,3), (1,5,3,2,4) ] |
  1716.  
  1717. 'ConjugacyClass'  calls '<G>.operations.ConjugacyClass(  <G>, <g> )'  and
  1718. returns that value.
  1719.  
  1720. The default function called this  way is 'GroupOps.ConjugacyClass', which
  1721. creates a conjugacy class record (see "Conjugacy Class Records") with the
  1722. operations record 'ConjugacyClassOps' (see  "Set Functions  for Conjugacy
  1723. Classes").   Look  in  the index  under *ConjugacyClass* to see for which
  1724. groups this function is overlaid.
  1725.  
  1726. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1727. \Section{IsConjugacyClass}
  1728.  
  1729. 'IsConjugacyClass( <obj> )'
  1730.  
  1731. 'IsConjugacyClass' returns  'true' if  <obj>  is  a  conjugacy  class  as
  1732. created by 'ConjugacyClass' (see "ConjugacyClass") and 'false' otherwise.
  1733.  
  1734. |    gap> a5 := Group( (1,2,3), (3,4,5) );;  a5.name := "a5";;
  1735.     gap> c := ConjugacyClass( a5, (1,2,3,4,5) );
  1736.     ConjugacyClass( a5, (1,2,3,4,5) )
  1737.     gap> IsConjugacyClass( c );
  1738.     true
  1739.     gap> IsConjugacyClass(
  1740.     >       [ (1,2,3,4,5), (1,2,4,5,3), (1,2,5,3,4), (1,3,5,4,2),
  1741.     >         (1,3,2,5,4), (1,3,4,2,5), (1,4,3,5,2), (1,4,5,2,3),
  1742.     >         (1,4,2,3,5), (1,5,4,3,2), (1,5,2,4,3), (1,5,3,2,4) ] );
  1743.     false    # even though this is as a set equal to 'c' |
  1744.  
  1745. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1746. \Section{Set Functions for Conjugacy Classes}%
  1747. \index{Elements!for Conjugacy Classes}%
  1748. \index{Size!for Conjugacy Classes}%
  1749. \index{in!for Conjugacy Classes}%
  1750. \index{Random!for Conjugacy Classes}
  1751.  
  1752. As  mentioned  above,  conjugacy  classes  are  domains,  so  all  domain
  1753. functions  are applicable  to  conjugacy  classes (see  "Domains").  This
  1754. section  describes  the functions  that  are  implemented  especially for
  1755. conjugacy  classes.   Functions  not  mentioned here  inherit the default
  1756. functions mentioned in the respective sections.
  1757.  
  1758. In the following let <C> be the conjugacy class of the element <g> in the
  1759. group <G>.
  1760.  
  1761. \vspace{5mm}
  1762. 'Elements( <C> )'
  1763.  
  1764. The elements of the conjugacy class <C> are computed as  the orbit of <g>
  1765. under <G>, where <G> operates by conjugation.
  1766.  
  1767. \vspace{5mm}
  1768. 'Size( <C> )'
  1769.  
  1770. The  size of  the  conjugacy  class <C>  is computed as the  index of the
  1771. centralizer of <g> in <G>.
  1772.  
  1773. \vspace{5mm}
  1774. '<h> in <C>'
  1775.  
  1776. To test whether an element <h> lies in <C>,  'in' tests whether there  is
  1777. an element of  <G> that  takes  <h>  to <g>.   This  is  done by  calling
  1778. 'RepresentativeOperation(<G>,<h>,<g>)' (see "RepresentativeOperation").
  1779.  
  1780. \vspace{5mm}
  1781. 'Random( <C> )'
  1782.  
  1783. A random element of the  conjugacy  class <C> is  computed by conjugating
  1784. <g> with a random element of <G>.
  1785.  
  1786. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1787. \Section{Conjugacy Class Records}
  1788.  
  1789. A conjugacy class <C> of an element <g> in a group <G> is represented  by
  1790. a record with the following components.
  1791.  
  1792. 'isDomain': \\
  1793.         always 'true'.
  1794.  
  1795. 'isConjugacyClass': \\
  1796.         always 'true'.
  1797.  
  1798. 'group': \\
  1799.         holds the group <G>.
  1800.  
  1801. 'representative': \\
  1802.         holds the representative <g>.
  1803.  
  1804. The  following component  is optional.  It is computed and assigned  when
  1805. the size of a conjugacy class is computed.
  1806.  
  1807. 'centralizer': \\
  1808.         holds the centralizer of <g> in <G>.
  1809.  
  1810. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1811. \Section{ConjugacyClassesSubgroups}
  1812.  
  1813. 'ConjugacyClassesSubgroups( <G> )'
  1814.  
  1815. 'ConjugacyClassesSubgroups' returns a  list of  all  conjugacy classes of
  1816. subgroups  of the group  <G>.  The  elements in  the  list  returned  are
  1817. conjugacy  class  domains  as created  by  'ConjugacyClassSubgroups' (see
  1818. "ConjugacyClassSubgroups").  Because  conjugacy classes are  domains, all
  1819. set theoretic functions can be applied (see "Domains").
  1820.  
  1821. In fact, 'ConjugacyClassesSubgroups'  computes much more than it returns,
  1822. for      it      calls      (indirectly      via       the       function
  1823. '<G>.operations.ConjugacyClassesSubgroups( <G> )'), the 'Lattice' command
  1824. (see "Lattice"), constructs the whole subgroup lattice of  <G>, stores it
  1825. in  the  record  component  '<G>.lattice', and  finally returns the  list
  1826. '<G>.lattice.classes'. This means, in particular,  that  it will fail  if
  1827. <G>  is  non-solvable  and  its maximal  perfect subgroup is  not in  the
  1828. built-in  catalogue  of  perfect  groups  (see  the  description  of  the
  1829. 'Lattice' command "Lattice" for details).
  1830.  
  1831. |    gap> & Conjugacy classes of subgroups of S4
  1832.     gap> s4 := Group( (1,2,3,4), (1,2) );;
  1833.     gap> s4.name := "s4";;
  1834.     gap> cl := ConjugacyClassesSubgroups( s4 );
  1835.     [ ConjugacyClassSubgroups( s4, Subgroup( s4, [  ] ) ), 
  1836.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (3,4) ] ) ), 
  1837.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (1,2)(3,4) ] ) ), 
  1838.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (2,3,4) ] ) ), 
  1839.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (3,4), (1,2) ] ) ), 
  1840.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) 
  1841.          ] ) ), ConjugacyClassSubgroups( s4, Subgroup( s4, 
  1842.         [ (1,2)(3,4), (1,3,2,4) ] ) ), 
  1843.       ConjugacyClassSubgroups( s4, Subgroup( s4, [ (2,3,4), (3,4) ] ) ), 
  1844.       ConjugacyClassSubgroups( s4, Subgroup( s4, 
  1845.         [ (3,4), (1,2), (1,2)(3,4), (1,3)(2,4) ] ) ), 
  1846.       ConjugacyClassSubgroups( s4, Subgroup( s4, 
  1847.         [ (1,2)(3,4), (1,3)(2,4), (2,3,4) ] ) ), 
  1848.       ConjugacyClassSubgroups( s4, s4 ) ] |
  1849.  
  1850. Each entry of the resulting list is a domain. As an example, let us take
  1851. the seventh class in the above list of conjugacy classes of $S_4$.
  1852.  
  1853. |    gap> & Conjugacy classes of subgroups of S4 (continued)
  1854.     gap> class7 := cl[7];;
  1855.     gap> & Print the class representative subgroup.
  1856.     gap> rep7 := Representative( class7 );
  1857.     Subgroup( s4, [ (1,2)(3,4), (1,3,2,4) ] )
  1858.     gap> & Print the order of the class representative subgroup.
  1859.     gap> Size( rep7 );
  1860.     4
  1861.     gap> & Print the number of conjugates.
  1862.     gap> Size( class7 );
  1863.     3 |
  1864.  
  1865. In the record representing the domain there is an additional component
  1866. '<class7>.conjugands' which contains a list of conjugating elements.
  1867.  
  1868. |    gap> & Conjugacy classes of subgroups of S4 (continued)
  1869.     gap> & Print a list of the subgroups in class7.
  1870.     gap> List( class7.conjugands, c -> rep7^c );
  1871.     [ Subgroup( s4, [ (1,2)(3,4), (1,3,2,4) ] ), 
  1872.       Subgroup( s4, [ (1,4)(2,3), (1,2,4,3) ] ), 
  1873.       Subgroup( s4, [ (1,3)(2,4), (1,4,3,2) ] ) ] |
  1874.  
  1875. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1876. \Section{Lattice}
  1877.  
  1878. 'Lattice( <G> )'
  1879.  
  1880. 'Lattice' returns the lattice of  subgroups of the group <G> in  the form
  1881. of  a record <L>, say, which contains certain lists with some appropriate
  1882. information  on  the  subgroups  of <G>  and  their conjugacy classes. In
  1883. particular, in its component '<L>.classes', <L> provides the same list of
  1884. all  conjugacy classes of all  subgroups  of <G>  as is returned  by  the
  1885. 'ConjugacyClassesSubgroups' command (see "ConjugacyClassesSubgroups").
  1886.  
  1887. The construction of the subgroup lattice record <L> of a group <G> may be
  1888. very time consuming. Therefore, as soon  as <L> has been computed for the
  1889. first  time, it will be  saved as a component '<G>.lattice' in the  group
  1890. record <G> to avoid any duplication of that effort.
  1891.  
  1892. The  underlying routines are a reimplementation  of the  subgroup lattice
  1893. routines which have been developed since 1958 by several  people  in Kiel
  1894. and Aachen under the supervision of Joachim  Neub{\accent127 u}ser. Their
  1895. final  version, written  by Volkmar Felsch in  1984, has  been  available
  1896. since  then in Cayley (see  \cite{BC92}) and  has also been used in SOGOS
  1897. (see \cite{Sog89}). The current implementation in {\GAP} by  J{\accent127
  1898. u}rgen Mnich is  described in \cite{Mni92}, a summary  of  the method and
  1899. references to all predecessors can be found in \cite{FS84}.
  1900.  
  1901. The 'Lattice'  command invokes the following procedure. In a  first step,
  1902. the solvable re\-si\-du\-um <P>, say, of <G> is computed and looked up in
  1903. a  built-in  catalogue  of perfect  groups  which  is  given in the  file
  1904. 'LIBNAME/\"lattperf.g\"'.  A list of  subgroups is  read  off  from  that
  1905. catalogue which contains just one representative of  each conjugacy class
  1906. of perfect subgroups of <P> and hence at least one representative of each
  1907. conjugacy  class  of perfect  subgroups of  <G>. Then, starting from  the
  1908. identity subgroup and the conjugacy  classes of perfect subgroups, the so
  1909. called  *cyclic extension  method* is used  to  compute  the  non-perfect
  1910. subgroups of <G> by forming for each class representative all its not yet
  1911. involved  cyclic  extensions  of  prime  number  index and  adding  their
  1912. conjugacy classes to the list.
  1913.  
  1914. It is clear that this procedure cannot work  if the  catalogue of perfect
  1915. groups  does  not  contain  a  group  isomorphic to  <P>. At  present, it
  1916. contains  only all  perfect  groups  of  order less  than  5000  and,  in
  1917. addition, the  groups $PSL(3,3)$,  $M_{11}$, and $A_8$. If  the 'Lattice'
  1918. command is called for a group <G> with a solvable residuum <P> not in the
  1919. catalogue, it will provide an  error message. As an example we handle the
  1920. group $SL(2,19)$ of order 6840.
  1921.  
  1922. |    gap> s := [ [4,0], [0,5] ] * Z( 19 )^0;;
  1923.     gap> t := [ [4,4], [-9,-4] ] * Z(19)^0;;
  1924.     gap> G := Group( s, t );;
  1925.     gap> Size( G );
  1926.     6840
  1927.     gap> Lattice( G );
  1928.     Error, sorry, can' t identify the group's solvable residuum |
  1929.  
  1930. However, if you know  the perfect  subgroups of  <G>,  you  can  use  the
  1931. 'Lattice'  command to compute the whole  subgroup lattice  of <G> even if
  1932. the  solvable residuum of <G> is not in the catalogue. All you have to do
  1933. in  such a case is to create a list of subgroups of <G> which contains at
  1934. least one  representative  of  each  conjugacy class  of  proper  perfect
  1935. subgroups of <G>, attach this list to the group record as a new component
  1936. '<G>.perfectSubgroups',   and  then  call  the  'Lattice'  command.   The
  1937. existence of  that  record component  will prevent {\GAP} from looking up
  1938. the  solvable residuum of  <G> in  the catalogue. Instead, it will insert
  1939. the given subgroups into the lattice, leaving it to you to guarantee that
  1940. in fact all conjugacy classes of proper perfect subgroups are involved.
  1941.  
  1942. If you miss  classes, the resulting lattice will  be incomplete,  but you
  1943. will not get any warning. As long as you are  aware of this fact, you may
  1944. use  this  possibility to compute a sublattice of the subgroup lattice of
  1945. <G>  without  getting  the  above  mentioned  error message  even if  the
  1946. solvable residuum of <G> is not in the catalogue. In particular, you will
  1947. get at least  the classes of all proper solvable subgroups of <G>  if you
  1948. define '<G>.perfectSubgroups' to be an empty list.
  1949.  
  1950. As an example for the computation of the complete lattice of subgroups of
  1951. a group which is not covered by the  catalogue,  we  handle  the  Mathieu
  1952. group $M_{12}$.
  1953.  
  1954. |    gap> & Define the Mathieu group M12.
  1955.     gap> a := (2,3,5,7,11,9,8,12,10,6,4);;
  1956.     gap> b := (3,6)(5,8)(9,11)(10,12);;
  1957.     gap> c := (1,2)(3,4)(5,9)(6,8)(7,12)(10,11);;
  1958.     gap> M12 := Group( a, b, c );;
  1959.     gap> Print( "&I  M12 has order ", Size( M12 ), "\n" );
  1960.     &I  M12 has order 95040
  1961.     gap> & Define a list of proper perfect subgroups of M_12 and attach
  1962.     gap> & it to the group record M12 as component M12.perfectSubgroups.
  1963.     gap> L2_11a := Subgroup( M12, [ a, b ] );;
  1964.     gap> M11a   := Subgroup( M12, [ a, b, c*a^-1*b*a*c ] );;
  1965.     gap> M11b   := Subgroup( M12, [ a, b, c*a*b*a^-1*c ] );;
  1966.     gap> x      := a*b*a^2;;
  1967.     gap> y      := a*c*a^-1*b*a*c*a^6;;
  1968.     gap> A6a    := Subgroup( M12, [ x, y ] );;
  1969.     gap> A5c    := Subgroup( M12, [ x*y, x^3*y^2*x^2*y ] );;
  1970.     gap> x      := a^2*b*a;;
  1971.     gap> y      := a^6*c*a*b*a^-1*c*a;;
  1972.     gap> A6b    := Subgroup( M12, [ x, y ] );;
  1973.     gap> A5d    := Subgroup( M12, [ x*y, x^3*y^2*x^2*y ] );;
  1974.     gap> x      := a;;
  1975.     gap> y      := b*c*b;;
  1976.     gap> z      := c;;
  1977.     gap> L2_11b := Subgroup( M12, [ x, y, z ] );;
  1978.     gap> A5b    := Subgroup( M12, [ y, x*z ] );;
  1979.     gap> x      := c;;
  1980.     gap> y      := b*a^-1*c*a*b;;
  1981.     gap> z      := a^2*b*a^-1*c*a*b*a^-2;;
  1982.     gap> Z2xS5  := Subgroup( M12, [ x, y, z ] );;
  1983.     gap> A5a    := Subgroup( M12, [ (x*z)^2, (y*z)^2 ] );;
  1984.     gap> M12.perfectSubgroups := [
  1985.     >   L2_11a, L2_11b, M11a, M11b, A6a, A6b, Z2xS5, A5a, A5b, A5c, A5d ];;
  1986.     gap> & Now compute the subgroup lattice of M12.
  1987.     gap> lat := Lattice( M12 );
  1988.     Lattice( Group( ( 2, 3, 5, 7,11, 9, 8,12,10, 6, 4), ( 3, 6)( 5, 8)
  1989.     ( 9,11)(10,12), ( 1, 2)( 3, 4)( 5, 9)( 6, 8)( 7,12)(10,11) ) ) |
  1990.  
  1991. The  'Lattice'  command  returns  a  record  which   represents  a   very
  1992. complicated structure.
  1993.  
  1994. |    gap> & Subgroup lattice of M12 (continued)
  1995.     gap> RecFields( lat );
  1996.     [ "group", "classes", "queue", "externalGroups", "calculatedGroups", 
  1997.       "extensionGroups", "queueGroups", "classGroups", "method",
  1998.       "statistics", "isLattice", "isSubgroupLattice", "operations",
  1999.       "printLevel" ] |
  2000.  
  2001. Probably the  most important component of the lattice  record is the list
  2002. '<lat>.classes'. Its elements are domains.  They are described in section
  2003. "ConjugacyClassesSubgroups". We can use this list, for instance, to print
  2004. the number of conjugacy  classes of subgroups and the number of subgroups
  2005. of $M_{12}$.
  2006.  
  2007. |    gap> & Subgroup lattice of M12 (continued)
  2008.     gap> n1 := Length( lat.classes );;
  2009.     gap> n2 := Sum( [ 1 .. n1 ], i -> Size( lat.classes[i] ) );;
  2010.     gap> Print( "&I  M12 has ", n1, " classes of altogether ", n2,
  2011.     >   " subgroups\n" );
  2012.     &I  M12 has 147 classes of altogether 214871 subgroups |
  2013.  
  2014. It  would not  make  sense  to get all components  of a subgroup  lattice
  2015. record  printed in  full  detail  whenever we  ask  {\GAP}  to  print the
  2016. lattice.  Therefore,  as you can see in the above  example,  the  default
  2017. printout is just an expression  of  the  form \"'Lattice(\,<group>\,)'\".
  2018. However,  you can ask {\GAP} to  display  some  additional information in
  2019. each printout of the  lattice by increasing  its individual print  level.
  2020. This print level is stored (in the form of a list of several print flags)
  2021. in the lattice record and can  be  changed by an appropriate call of  the
  2022. 'SetPrintLevel' \index{SetPrintLevel} command described below.
  2023.  
  2024. The  following  example demonstrates the effect  of  the subgroup lattice
  2025. print level.
  2026.  
  2027. |    gap> & Subgroup lattice of S4
  2028.     gap> s4 := Group( (1,2,3,4), (1,2) );;
  2029.     gap> lat := Lattice( s4 );
  2030.     Lattice( Group( (1,2,3,4), (1,2) ) ) |
  2031.  
  2032. The default subgroup lattice print level is 0. In this case, the
  2033. Print command provides just the expression mentioned above.
  2034.  
  2035. |    gap> & Subgroup lattice of S4 (continued)
  2036.     gap> SetPrintLevel( lat, 1 );
  2037.     gap> lat;
  2038.     &I  Class number   1, Length    1, Order 1
  2039.     &I  Class number   2, Length    6, Order 2
  2040.     &I  Class number   3, Length    3, Order 2
  2041.     &I  Class number   4, Length    4, Order 3
  2042.     &I  Class number   5, Length    3, Order 4
  2043.     &I  Class number   6, Length    1, Order 4
  2044.     &I  Class number   7, Length    3, Order 4
  2045.     &I  Class number   8, Length    4, Order 6
  2046.     &I  Class number   9, Length    3, Order 8
  2047.     &I  Class number  10, Length    1, Order 12
  2048.     &I  Class number  11, Length    1, Order 24
  2049.     Lattice( Group( (1,2,3,4), (1,2) ) ) |
  2050.  
  2051. If the  print  level  is  set  to  a  value greater than 0,  you get,  in
  2052. addition, for  each class a kind of heading line.  This line contains the
  2053. position number  and the length of the respective  class  as well as  the
  2054. order of the subgroups in the class.
  2055.  
  2056. |    gap> & Subgroup lattice of S4 (continued)
  2057.     gap> SetPrintLevel( lat, 2 );
  2058.     gap> lat;
  2059.     &I  Class number   1, Length    1, Order 1
  2060.     &I    Representative [  ]
  2061.     &I  Class number   2, Length    6, Order 2
  2062.     &I    Representative [ (3,4) ]
  2063.     &I    Max  [1,1]
  2064.     &I  Class number   3, Length    3, Order 2
  2065.     &I    Representative [ (1,2)(3,4) ]
  2066.     &I    Max  [1,1]
  2067.     &I  Class number   4, Length    4, Order 3
  2068.     &I    Representative [ (2,3,4) ]
  2069.     &I    Max  [1,1]
  2070.     &I  Class number   5, Length    3, Order 4
  2071.     &I    Representative [ (3,4), (1,2) ]
  2072.     &I    Max  [2,1] [2,4] [3,1]
  2073.     &I  Class number   6, Length    1, Order 4
  2074.     &I    Representative [ (1,2)(3,4), (1,3)(2,4) ]
  2075.     &I    Max  [3,1] [3,2] [3,3]
  2076.     &I  Class number   7, Length    3, Order 4
  2077.     &I    Representative [ (1,2)(3,4), (1,3,2,4) ]
  2078.     &I    Max  [3,1]
  2079.     &I  Class number   8, Length    4, Order 6
  2080.     &I    Representative [ (2,3,4), (3,4) ]
  2081.     &I    Max  [2,1] [2,2] [2,5] [4,1]
  2082.     &I  Class number   9, Length    3, Order 8
  2083.     &I    Representative [ (3,4), (1,2), (1,2)(3,4), (1,3)(2,4) ]
  2084.     &I    Max  [5,1] [6,1] [7,1]
  2085.     &I  Class number  10, Length    1, Order 12
  2086.     &I    Representative [ (1,2)(3,4), (1,3)(2,4), (2,3,4) ]
  2087.     &I    Max  [4,1] [4,2] [4,3] [4,4] [6,1]
  2088.     &I  Class number  11, Length    1, Order 24
  2089.     &I    Representative [ (1,2,3,4), (1,2) ]
  2090.     &I    Max  [8,1] [8,2] [8,3] [8,4] [9,1] [9,2] [9,3] [10,1]
  2091.     Lattice( Group( (1,2,3,4), (1,2) ) )
  2092.     gap> PrintClassSubgroupLattice( lat, 8 );
  2093.     &I  Class number   8, Length    4, Order 6
  2094.     &I    Representative [ (2,3,4), (3,4) ]
  2095.     &I    Max  [2,1] [2,2] [2,5] [4,1] |
  2096.  
  2097. If the  subgroup  lattice  print level  is  at least 2, {\GAP} prints, in
  2098. addition, for each  class representative subgroup a set of generators and
  2099. a list of  of its  maximal subgroups,  where  each  maximal  subgroup  is
  2100. represented by a pair of  integers consisting of its class number and its
  2101. position  number in that class. As this information blows up the  output,
  2102. it may be convenient to restrict it to a particular class. We can do this
  2103. by           calling            the           'PrintClassSubgroupLattice'
  2104. \index{PrintClassSubgroupLattice} command described below.
  2105.  
  2106. |    gap> & Subgroup lattice of S4 (continued)
  2107.     gap> SetPrintLevel( lat, 3 );
  2108.     gap> PrintClassSubgroupLattice( lat, 8 );
  2109.     &I  Class number   8, Length    4, Order 6
  2110.     &I    Representative [ (2,3,4), (3,4) ]
  2111.     &I    Max  [2,1] [2,2] [2,5] [4,1]
  2112.     &I    Conjugate 2 by (1,4,3,2) is [ (1,2,3), (2,3) ]
  2113.     &I    Conjugate 3 by (1,2) is [ (1,3,4), (3,4) ]
  2114.     &I    Conjugate 4 by (1,3)(2,4) is [ (1,2,4), (1,2) ] |
  2115.  
  2116. If the subgroup lattice  print level  has been set to  at least 3, {\GAP}
  2117. displays,  in addition, for  each non-representative subgroup of  a class
  2118. its   number  in  the  class,  an  element  which  transforms  the  class
  2119. representative subgroup into that subgroup, and a set of generators.
  2120.  
  2121. |    gap> & Subgroup lattice of S4 (continued)
  2122.     gap> SetPrintLevel( lat, 4 );
  2123.     gap> PrintClassSubgroupLattice( lat, 8 );
  2124.     &I  Class number   8, Length    4, Order 6
  2125.     &I    Representative [ (2,3,4), (3,4) ]
  2126.     &I    Max  [2,1] [2,2] [2,5] [4,1]
  2127.     &I    Conjugate 2 by (1,4,3,2) is [ (1,2,3), (2,3) ]
  2128.     &I    Max  [2,2] [2,3] [2,4] [4,2]
  2129.     &I    Conjugate 3 by (1,2) is [ (1,3,4), (3,4) ]
  2130.     &I    Max  [2,1] [2,3] [2,6] [4,3]
  2131.     &I    Conjugate 4 by (1,3)(2,4) is [ (1,2,4), (1,2) ]
  2132.     &I    Max  [2,4] [2,5] [2,6] [4,4] |
  2133.  
  2134. A subgroup lattice print  level value of at least 4 causes {\GAP} also to
  2135. list the maximal subgroups of the non-representative subgroups.
  2136.  
  2137. |    gap> & Subgroup lattice of S4 (continued)
  2138.     gap> SetPrintLevel( lat, 5 );
  2139.     gap> PrintClassSubgroupLattice( lat, 8 );
  2140.     &I  Class number   8, Length    4, Order 6
  2141.     &I    Representative [ (2,3,4), (3,4) ]
  2142.     &I    Min  [11,1]
  2143.     &I    Max  [2,1] [2,2] [2,5] [4,1]
  2144.     &I    Conjugate 2 by (1,4,3,2) is [ (1,2,3), (2,3) ]
  2145.     &I    Min  [11,1]
  2146.     &I    Max  [2,2] [2,3] [2,4] [4,2]
  2147.     &I    Conjugate 3 by (1,2) is [ (1,3,4), (3,4) ]
  2148.     &I    Min  [11,1]
  2149.     &I    Max  [2,1] [2,3] [2,6] [4,3]
  2150.     &I    Conjugate 4 by (1,3)(2,4) is [ (1,2,4), (1,2) ]
  2151.     &I    Min  [11,1]
  2152.     &I    Max  [2,4] [2,5] [2,6] [4,4] |
  2153.  
  2154. The  maximal valid value  of the subgroup lattice print level is 6. If it
  2155. is set,  {\GAP} displays  not only the  maximal  subgroups, but also  the
  2156. minimal supergroups of each subgroup. This is the  most extensive  output
  2157. of a subgroup lattice record which you can get with the  'Print' command,
  2158. but of course  you  can use  the 'RecFields' command (see "RecFields") to
  2159. list all record components and then  print them out individually  in full
  2160. detail.
  2161.  
  2162. If the computation of some subgroup lattice is very time consuming (as in
  2163. the above example of the  Mathieu group $M_{12}$), you might wish to  see
  2164. some intermediate printout which informs you about the  progress  of  the
  2165. computation.  In fact, you  can get such messages  by activating a  print
  2166. mechanism which has been inserted  into the subgroup lattice routines for
  2167. diagnostic purposes. All you have to do is to replace the call
  2168.  
  2169. |    lat := Lattice( M12 ); |
  2170.  
  2171. by the three calls
  2172.  
  2173. |    InfoLattice1 := Print;
  2174.     lat := Lattice( M12 );
  2175.     InfoLattice1 := Ignore; |
  2176. \index{InfoLattice1}
  2177.  
  2178. Note,  however, that  the  final  numbering of  the  conjugacy classes of
  2179. subgroups will  differ  from  the  order  in  which  they  occur  in  the
  2180. intermediate  listing  because  they  will  be  reordered  by  increasing
  2181. subgroup orders at the end of the construction.
  2182.  
  2183. \vspace{5mm}
  2184. 'PrintClassSubgroupLattice( <lattice>, <n> )'
  2185. \index{PrintClassSubgroupLattice}
  2186.  
  2187. 'PrintClassSubgroupLattice' prints  information on  the  <n>th  conjugacy
  2188. class  of subgroups in the subgroup lattice <lattice>. The amount of this
  2189. information depends on  the  current value of the subgroup  lattice print
  2190. level of  <lattice>.  Note that the default of  that print  level is zero
  2191. which   means   that   you   will   not   get   any   output   from   the
  2192. 'PrintClassSubgroupLattice'   command   without   increasing   it    (see
  2193. 'SetPrintLevel'  below).  Examples are given in  the above description of
  2194. the 'Lattice' command.
  2195.  
  2196. \vspace{5mm}
  2197. 'SetPrintLevel( <lattice>, <level> )'
  2198. \index{SetPrintLevel}
  2199.  
  2200. 'SetPrintLevel' changes the subgroup print  level of the subgroup lattice
  2201. <lattice>  to the specified value <level> by an appropriate alteration of
  2202. the list of  print flags which is stored in  '<lattice>.printLevel'.  The
  2203. argument <level> is expected to be an integer between 0 and 6.
  2204.  
  2205. Examples  of the effect of the  subgroup lattice print level are given in
  2206. the above description of the 'Lattice' command.
  2207.  
  2208. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2209. \Section{ConjugacyClassSubgroups}
  2210.  
  2211. 'ConjugacyClassSubgroups( <G>, <U> )'
  2212.  
  2213. 'ConjugacyClassSubgroups' returns the conjugacy class of the subgroup <U>
  2214. in the group <G>.  Signals an error if <U> is not a subgroup of <G>.  The
  2215. conjugacy class is returned as  a domain, so all set  theoretic functions
  2216. are applicable (see "Domains").
  2217.  
  2218. |    gap> s5 := Group( (1,2), (1,2,3,4,5) );;  s5.name := "s5";;
  2219.     gap> a5 := DerivedSubgroup( s5 );
  2220.     Subgroup( s5, [ (1,2,3), (2,3,4), (3,4,5) ] )
  2221.     gap> C := ConjugacyClassSubgroups( s5, a5 );
  2222.     ConjugacyClassSubgroups( s5, Subgroup( s5, 
  2223.     [ (1,2,3), (2,3,4), (3,4,5) ] ) )
  2224.     gap> Size( C );
  2225.     1 |
  2226.  
  2227. Another example of such domains is given in section
  2228. "ConjugacyClassesSubgroups".
  2229.  
  2230. 'ConjugacyClassSubgroups' calls \\
  2231. '<G>.operations.ConjugacyClassSubgroups( <G>, <U> )'
  2232. and returns this value.
  2233.  
  2234. The default function called  is 'GroupOps.ConjugacyClassSubgroups', which
  2235. creates a conjugacy class record (see "Subgroup Conjugacy Class Records")
  2236. with   the   operations  record  'ConjugacyClassSubgroupsOps'  (see  "Set
  2237. Functions for  Subgroup Conjugacy  Classes").   Look  in the index  under
  2238. *ConjugacyClassSubgroups*  to see  for  which  groups  this  function  is
  2239. overlaid.
  2240.  
  2241. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2242. \Section{IsConjugacyClassSubgroups}
  2243.  
  2244. 'IsConjugacyClassSubgroups( <obj> )'
  2245.  
  2246. 'IsConjugacyClassSubgroups' returns 'true' if <obj> is a  conjugacy class
  2247. of   subgroups    as    created    by    'ConjugacyClassSubgroups'   (see
  2248. "ConjugacyClassSubgroups") and 'false' otherwise.
  2249.  
  2250. |    gap> s5 := Group( (1,2), (1,2,3,4,5) );;  s5.name := "s5";;
  2251.     gap> a5 := DerivedSubgroup( s5 );
  2252.     Subgroup( s5, [ (1,2,3), (2,3,4), (3,4,5) ] )
  2253.     gap> c := ConjugacyClassSubgroups( s5, a5 );
  2254.     ConjugacyClassSubgroups( s5, Subgroup( s5, 
  2255.     [ (1,2,3), (2,3,4), (3,4,5) ] ) )
  2256.     gap> IsConjugacyClassSubgroups( c );
  2257.     true
  2258.     gap> IsConjugacyClassSubgroups( [ a5 ] );
  2259.     false    # even though this is as a set equal to 'c' |
  2260.  
  2261. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2262. \Section{Set Functions for Subgroup Conjugacy Classes}%
  2263. \index{Elements!for conjugacy classes of subgroups}%
  2264. \index{in!for conjugacy classes of subgroups}%
  2265. \index{Size!for conjugacy classes of subgroups}
  2266.  
  2267. As mentioned  above,  conjugacy classes of subgroups  are domains, so all
  2268. set theoretic functions are also are applicable to conjugacy classes (see
  2269. "Domains").  This section  describes the  functions that  are implemented
  2270. especially  for conjugacy  classes.  Functions not mentioned here inherit
  2271. the default functions mentioned in the respective sections.
  2272.  
  2273. \vspace{5mm}
  2274. 'Elements( <C> )'
  2275.  
  2276. The elements of  the conjugacy  class <C> with representative <U> in  the
  2277. group  <G> are  computed  by  first finding a  right transversal  of  the
  2278. normalizer of <U> in <G> and by computing the conjugates  of <U> with the
  2279. elements in the right transversal.
  2280.  
  2281. \vspace{5mm}
  2282. '<V> in <C>'
  2283.  
  2284. Membership of a  group <V> is tested  by comparing  the set  of contained
  2285. cyclic  subgroups of prime power order of <V> with those of the groups in
  2286. <C>.
  2287.  
  2288. \vspace{5mm}
  2289. 'Size( <C> )'
  2290.  
  2291. The size of the  conjugacy class <C> with representative <U> in the group
  2292. <G> is computed as the index of the normalizer of <U> in <G>.
  2293.  
  2294. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2295. \Section{Subgroup Conjugacy Class Records}
  2296.  
  2297. Each conjugacy class of subgroups <C> is represented as a  record with at
  2298. least the following components.
  2299.  
  2300. 'isDomain': \\
  2301.         always  'true',  because  conjugacy   classes  of  subgroups  are
  2302.         domains.
  2303.  
  2304. 'isConjugacyClassSubgroups': \\
  2305.         as well, this entry is always set to 'true'.
  2306.  
  2307. 'group': \\
  2308.         The group in which the members of this conjugacy class lie.  This
  2309.         is not necessarily a parent group; it may also be a subgroup.
  2310.  
  2311. 'representative': \\
  2312.         The representative of the conjugacy class of subgroups as domain.
  2313.  
  2314. The following  components are optional and may be bound by some functions
  2315. which compute or make use of their value.
  2316.  
  2317. 'normalizer': \\
  2318.         The normalizer of '<C>.representative' in '<C>.group'.
  2319.  
  2320. 'normalizerLattice': \\
  2321.         A  special  entry  that is  used when  the conjugacy  classes  of
  2322.         subgroups  are  computed   by  'ConjugacyClassesSubgroups'.    It
  2323.         determines the normalizer of the  subgroup  '<C>.representative'.
  2324.         It is a list of length 2.  The first element is another conjugacy
  2325.         class <D>  (in the same group), the  second is an element  <g> in
  2326.         '<C>.group'.   The normalizer  of  '<C>.representative'  is  then
  2327.         '<D>.representative \^\ <g>'.
  2328.  
  2329. 'conjugands': \\
  2330.         A right transversal of the normalizer  of '<C>.representative' in
  2331.         '<C>.group'.  Thus the elements of the conjugacy class <C> can be
  2332.         computed by conjugating '<C>.representative' with those elements.
  2333.         this list, regarding each entry as a conjugating element.
  2334.  
  2335. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2336. \Section{ConjugateSubgroups}
  2337.  
  2338. 'ConjugateSubgroups( <G>, <U> )'
  2339.  
  2340. 'ConjugateSubgroups' returns   the orbit   of <U>   under  <G> acting  by
  2341. conjugation (see "ConjugateSubgroup") as  list of subgroups.  <U> and <G>
  2342. must have a common parent group.
  2343.  
  2344. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  2345.     Group( (1,2,3,4), (1,2) )
  2346.     gap> s3 := Subgroup( s4, [ (1,2,3), (1,2) ] );
  2347.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] )
  2348.     gap> ConjugateSubgroups( s4, s3 );
  2349.     [ Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,3), (1,2) ] ), 
  2350.       Subgroup( Group( (1,2,3,4), (1,2) ), [ (2,3,4), (2,3) ] ), 
  2351.       Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3,4), (3,4) ] ), 
  2352.       Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,2,4), (1,4) ] ) ] |
  2353.  
  2354. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2355.  
  2356. \Section{Cosets of Subgroups}%
  2357.  
  2358. The following sections  describe how one can compute the right, left, and
  2359. double   cosets   of   subgroups   (see    "RightCosets",   "LeftCosets",
  2360. "DoubleCosets").  Further sections  describe how cosets are created  (see
  2361. "RightCoset", "IsRightCoset", "LeftCoset", "IsLeftCoset",  "DoubleCoset",
  2362. and  "IsDoubleCoset"),  and how they are implemented  (see "Set Functions
  2363. for Right  Cosets", "Right  Cosets  Records", "Set Functions  for  Double
  2364. Cosets", and "Double Coset Records").
  2365.  
  2366. A coset is a {\GAP} domain, which is different from a group.  Altough the
  2367. set  of elements of a group and  its trivial coset  are  equal, the group
  2368. functions do not take trivial cosets as arguments.  A  trivial coset must
  2369. be convert  into a  group using 'AsGroup' (see "AsGroup")  in order to be
  2370. used as group.
  2371.  
  2372. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2373. \Section{RightCosets}%
  2374. \index{cosets!right}
  2375.  
  2376. 'Cosets( <G>, <U> )' \\
  2377. 'RightCosets( <G>, <U> )'
  2378.  
  2379. 'Cosets' and  'RightCosets' return  a list of   the right  cosets  of the
  2380. subgroup <U> in the group <G>.  The  list is not  sorted, i.e., the right
  2381. cosets  may  appear in   any  order.  The  right   cosets are domains  as
  2382. constructed by 'RightCoset' (see "RightCoset").
  2383.  
  2384. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2385.     gap> G.name := "G";;
  2386.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2387.     gap> RightCosets( G, U );
  2388.     [ (Subgroup( G, [ (1,2), (3,4) ] )*()), 
  2389.       (Subgroup( G, [ (1,2), (3,4) ] )*(2,4,3)), 
  2390.       (Subgroup( G, [ (1,2), (3,4) ] )*(2,3)), 
  2391.       (Subgroup( G, [ (1,2), (3,4) ] )*(1,2,4,3)), 
  2392.       (Subgroup( G, [ (1,2), (3,4) ] )*(1,2,3)), 
  2393.       (Subgroup( G, [ (1,2), (3,4) ] )*(1,3)(2,4)) ] |
  2394.  
  2395. If <G> is  the parent of  <U>, the dispatcher  'RightCosets' first checks
  2396. whether <U> has a component 'rightCosets'.  If <U> has this component, it
  2397. returns        that       value.         Otherwise        it        calls
  2398. '<G>.operations.RightCosets(<G>,<U>)',  remembers the  returned value  in
  2399. '<U>.rightCosets' and returns  it.   If  <G>  is not the parent  of  <U>,
  2400. 'RightCosets'         directly         calls         the         function
  2401. '<G>.operations.RightCosets(<G>,<U>)' and returns that value.
  2402.  
  2403. The  default function called  this  way is 'GroupOps.RightCosets',  which
  2404. calls 'Orbit( <G>, RightCoset( <U> ), OnRight  )'.  Look up 'RightCosets'
  2405. in the index, to see for which groups this function is overlaid.
  2406.  
  2407. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2408. \Section{RightCoset}%
  2409. \index{Coset}%
  2410. \index{coset!right}
  2411.  
  2412. '<U> \*\ <u>' \\
  2413. 'Coset( <U>, <u> )' \\
  2414. 'RightCoset( <U>, <u> )' \\
  2415. 'Coset( <U> )' \\
  2416. 'RightCoset( <U> )'
  2417.  
  2418. The first three forms return the right coset of the subgroup <U> with the
  2419. representative <u>.  <u> must  lie in the parent  group of <U>, otherwise
  2420. an error is signalled.  In the last two forms the right coset of <U> with
  2421. the identity element of the parent of <U>  as representative is returned.
  2422. In  each case the   right coset is returned as   a domain, so all  domain
  2423. functions   are applicable to   right  cosets (see chapter  "Domains" and
  2424. "Set Functions for Right Cosets").
  2425.  
  2426. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2427.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2428.     gap> U * (1,2,3);
  2429.     (Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2), (3,4) ] )*(1,2,3)) |
  2430.  
  2431. 'RightCosets' (see "RightCosets") computes the set of all right cosets of
  2432. a subgroup  in  a group.  'LeftCoset'   (see "LeftCoset") constructs left
  2433. cosets.
  2434.  
  2435. 'RightCoset' calls '<U>.operations.RightCoset(  <U>, <u>  )' and  returns
  2436. that value.
  2437.  
  2438. The default  function called this  way  is  'GroupOps.RightCoset',  which
  2439. creates a  right  coset record  (see  "Right  Cosets  Records") with  the
  2440. operations  record  'RightCosetGroupOps' (see "Set  Functions  for  Right
  2441. Cosets").  Look  up the entries for 'RightCoset' in the index  to see for
  2442. which groups this function is overlaid.
  2443.  
  2444. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2445. \Section{IsRightCoset}%
  2446. \index{IsCoset}%
  2447. \index{coset!right}
  2448.  
  2449. 'IsRightCoset( <obj> )' \\
  2450. 'IsCoset( <obj> )'
  2451.  
  2452. 'IsRightCoset' and 'IsCoset' return 'true' if the object <obj> is a right
  2453. coset,  i.e., a  record  with the   component 'isRightCoset' with   value
  2454. 'true', and 'false' otherwise.   Will  signal  an error if  <obj>   is an
  2455. unbound variable.
  2456.  
  2457. |    gap> C := Subgroup( Group( (1,2), (1,2,3) ), [ (1,2,3) ] ) * (1,2);;
  2458.     gap> IsRightCoset( C );
  2459.     true
  2460.     gap> D := (1,2) * Subgroup( Group( (1,2), (1,2,3) ), [ (1,2,3) ] );;
  2461.     gap> IsCoset( D );
  2462.     false    # note that <D> is a *left coset* record,
  2463.     gap> C = D;
  2464.     true     # though as a set, it is of course also a right coset
  2465.     gap> IsCoset( 17 );
  2466.     false |
  2467.  
  2468. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2469. \Section{Set Functions for Right Cosets}%
  2470. \index{Elements!for right cosets}\index{IsFinite!for right cosets}%
  2471. \index{Size!for right cosets}\index{comparison!of right cosets}%
  2472. \index{Intersection!for right cosets}\index{Random!for right cosets}%
  2473. \index{Print!for right cosets}\index{product!for right cosets}%
  2474. \index{RightCosetGroupOps}
  2475.  
  2476. Right cosets are domains, thus all set theoretic functions are applicable
  2477. to cosets (see chapter "Domains").  The following describes the functions
  2478. that  are  implemented  especially  for  right  cosets.    Functions  not
  2479. mentioned here inherit the default function  mentioned in the  respective
  2480. sections.
  2481.  
  2482. More technically speaking, all  right cosets of  generic groups  have the
  2483. operations record 'RightCosetGroupOps', which inherits its functions from
  2484. 'DomainOps'  and overlays   the  components   mentioned below  with  more
  2485. efficient functions.
  2486.  
  2487. In the following let <C> be the coset '<U> \*\ <u>'.
  2488.  
  2489. \vspace{5mm}
  2490. 'Elements( <C> )'
  2491.  
  2492. To compute the proper set of elements of a right coset <C> the proper set
  2493. of elements of the subgroup  <U> is computed,  each element is multiplied
  2494. by <u>, and the result is sorted.
  2495.  
  2496. \vspace{5mm}
  2497. 'IsFinite( <C> )'
  2498.  
  2499. This returns the result of applying 'IsFinite' to the subgroup <U>.
  2500.  
  2501. \vspace{5mm}
  2502. 'Size( <C> )'
  2503.  
  2504. This returns the result of applying 'Size' to the subgroup <U>.
  2505.  
  2506. \vspace{5mm}
  2507. '<C> = <D>'
  2508.  
  2509. If  <C> and <D> are  both right cosets  of the same subgroup, '=' returns
  2510. 'true' if the quotient  of the representatives lies  in the subgroup <U>,
  2511. otherwise the test is delegated to 'DomainOps.='.
  2512.  
  2513. \vspace{5mm}
  2514. '<h> in <U>'
  2515.  
  2516. If <h> is an element of  the parent group of <U>,  this returns 'true' if
  2517. the quotient '<h> / <u>' lies in the subgroup <U>,  otherwise the test is
  2518. delegated to 'DomainOps.in'.
  2519.  
  2520. \vspace{5mm}
  2521. 'Intersection( <C>, <D> )'
  2522.  
  2523. If <C> and <D>  are both right cosets  of subgroups <U>  and <V> with the
  2524. same parent group the result is a right coset  of the intersection of <U>
  2525. and <V>.  The representative  is found by   a random search for  a common
  2526. element.  In other cases the computation of the intersection is delegated
  2527. to 'DomainOps.Intersection'.
  2528.  
  2529. \vspace{5mm}
  2530. 'Random( <C> )'
  2531.  
  2532. This takes a random element of  the subgroup <U>  and returns the product
  2533. of this element by the representative <u>.
  2534.  
  2535. \vspace{5mm}
  2536. 'Print( <C> )'
  2537.  
  2538. A right coset <C> is printed as '(<U> \*\ <u>)' (the parenthesis are used
  2539. to  avoid confusion about the precedence,  which could occur if the coset
  2540. is part of a larger object).
  2541.  
  2542. \vspace{5mm}
  2543. '<C> \*\ <v>'
  2544.  
  2545. If <v> is an element of the parent group of the  subgroup <U>, the result
  2546. is a new right coset of <U> with representative '<u> \*\ <v>'.  Otherwise
  2547. the result is obtained by multiplying  the proper set  of elements of <C>
  2548. with the element <v>, which may signal an error.
  2549.  
  2550. \vspace{5mm}
  2551. '<v> \*\ <C>'
  2552.  
  2553. The result  is obtained by multiplying the  proper set of elements of the
  2554. coset <C> with the element <v>, which may signal an error.
  2555.  
  2556. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2557. \Section{Right Cosets Records}%
  2558. \index{domain record!for right cosets}
  2559.  
  2560. A right   coset is represented  by   a domain record  with  the following
  2561. tag components.
  2562.  
  2563. 'isDomain': \\
  2564.         always 'true'.
  2565.  
  2566. 'isRightCoset': \\
  2567.         always 'true'.
  2568.  
  2569. The right coset is determined by the following identity components, which
  2570. every right coset record has.
  2571.  
  2572. 'group': \\
  2573.         the subgroup <U> of which this right coset is a right coset.
  2574.  
  2575. 'representative': \\
  2576.         an element of the right coset.  It is unspecified which element.
  2577.  
  2578. In   addition,  a right   coset record may    have the following optional
  2579. information components.
  2580.  
  2581. 'elements': \\
  2582.         if present the proper set of elements of the coset.
  2583.  
  2584. 'isFinite': \\
  2585.         if present this is 'true' if the coset  is  finite,  and  'false'
  2586.         if the coset is infinite.  If not present it is not known whether
  2587.         the coset is finite or infinite.
  2588.  
  2589. 'size': \\
  2590.         if present the size of the coset.  Is \"infinity\"\ if the  coset
  2591.         is infinite.  If not present the size of the coset is not known.
  2592.  
  2593. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2594. \Section{LeftCosets}%
  2595. \index{cosets!left}
  2596.  
  2597. 'LeftCosets( <G>, <U> )'
  2598.  
  2599. 'LeftCosets' returns a list of the left cosets of the subgroup <U> in the
  2600. group <G>.  The list is not  sorted, i.e., the left  cosets may appear in
  2601. any order.  The  left  cosets are domains as constructed  by 'LeftCosets'
  2602. (see "LeftCosets").
  2603.  
  2604. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2605.     gap> G.name := "G";;
  2606.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2607.     gap> LeftCosets( G, U );
  2608.     [ ((3,4)*Subgroup( G, [ (1,2), (3,4) ] )),
  2609.       ((2,4)*Subgroup( G, [ (1,2), (3,4) ] )),
  2610.       ((1,2,4,3)*Subgroup( G, [ (1,2), (3,4) ] )),
  2611.       ((1,3,4,2)*Subgroup( G, [ (1,2), (3,4) ] )),
  2612.       ((1,3)*Subgroup( G, [ (1,2), (3,4) ] )),
  2613.       ((1,3,2,4)*Subgroup( G, [ (1,2), (3,4) ] )) ] |
  2614.  
  2615. If <G> is  the parent of  <U>,  the  dispatcher 'LeftCosets' first checks
  2616. whether  <U> has a component 'leftCosets'.  If <U> has this component, it
  2617. returns      that      value.       Otherwise      'LeftCosets'     calls
  2618. '<G>.operations.LeftCosets(<G>,<U>)',  remembers the  returned  value  in
  2619. '<U>.leftCosets' and  returns  it.   If  <G>  is not  the parent  of <U>,
  2620. 'LeftCosets'   calls '<G>.operations.LeftCosets(<G>,<U>)'   directly  and
  2621. returns that value.
  2622.  
  2623. The default  function  called this  way is 'GroupOps.LeftCosets',   which
  2624. calls 'RightCosets( <G>, <U> )' and turns each right coset  '<U> \*\ <u>'
  2625. into  the  left  coset   '<u>\^-1 \*\  <U>'.    Look up   the entries for
  2626. 'LeftCosets' in the  index,  to  see for  which  groups this function  is
  2627. overlaid.
  2628.  
  2629. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2630. \Section{LeftCoset}%
  2631. \index{coset!left}
  2632.  
  2633. '<u> \*\ <U>' \\
  2634. 'LeftCoset( <U>, <u> )' \\
  2635. 'LeftCoset( <U> )'
  2636.  
  2637. 'LeftCoset' is exactly like  'RightCoset', except that it constructs left
  2638. cosets  instead  of   right  cosets.   So  everything  that   applies  to
  2639. 'RightCoset' applies also to 'LeftCoset', with *right* replaced by *left*
  2640. (see  "RightCoset",  "Set  Functions  for  Right  Cosets", "Right  Cosets
  2641. Records").
  2642.  
  2643. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2644.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2645.     gap> (1,2,3) * U;
  2646.     ((1,2,3)*Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2), (3,4) ] )) |
  2647.  
  2648. 'LeftCosets' (see "LeftCosets") computes the set of all  left cosets of a
  2649. subgroup in a group.
  2650.  
  2651. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2652. \Section{IsLeftCoset}%
  2653. \index{coset!left}
  2654.  
  2655. 'IsLeftCoset( <obj> )'
  2656.  
  2657. 'IsLeftCoset' returns 'true' if the object <obj> is a left coset, i.e., a
  2658. record  with the component 'isLeftCoset' with  value 'true', and  'false'
  2659. otherwise.  Will signal an error if <obj> is an unbound variable.
  2660.  
  2661. |    gap> C := (1,2) * Subgroup( Group( (1,2), (1,2,3) ), [ (1,2,3) ] );;
  2662.     gap> IsLeftCoset( C );
  2663.     true
  2664.     gap> D := Subgroup( Group( (1,2), (1,2,3) ), [ (1,2,3) ] ) * (1,2);;
  2665.     gap> IsLeftCoset( D );
  2666.     false    # note that <D> is a *right coset* record,
  2667.     gap> C = D;
  2668.     true     # though as a set, it is of course also a left coset
  2669.     gap> IsLeftCoset( 17 );
  2670.     false |
  2671.  
  2672. 'IsRightCoset' (see "IsRightCoset") tests if an object is a right coset.
  2673.  
  2674. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2675. \Section{DoubleCosets}%
  2676. \index{cosets!double}
  2677.  
  2678. 'DoubleCosets( <G>, <U>, <V> )'
  2679.  
  2680. 'DoubleCosets' returns a list of the double cosets  of the  subgroups <U>
  2681. and <V> in the group  <G>.   The list is  not sorted,  i.e.,  the  double
  2682. cosets  may appear in  any  order.  The   double cosets  are  domains  as
  2683. constructed by 'DoubleCoset' (see "DoubleCoset").
  2684.  
  2685. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2686.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;  U.name := "U";;
  2687.     gap> DoubleCosets( G, U, U );
  2688.     [ DoubleCoset( U, (), U ), DoubleCoset( U, (2,3), U ), 
  2689.       DoubleCoset( U, (1,3)(2,4), U ) ] |
  2690.  
  2691. 'DoubleCosets' calls   '<G>.operations.DoubleCoset( <G>, <U>,  <V> )' and
  2692. returns that value.
  2693.  
  2694. The default  function called this  way is  'GroupOps.DoubleCosets', which
  2695. takes random elements from <G>, tests if this element lies  in one of the
  2696. already found double cosets, adds  the double  coset if this is  not  the
  2697. case, and continues this until the sum of the  sizes of  the found double
  2698. cosets equals the size of  <G>.  Look up 'DoubleCosets'  in the index, to
  2699. see for which groups this function is overlaid.
  2700.  
  2701. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2702. \Section{DoubleCoset}%
  2703. \index{coset!double}
  2704.  
  2705. 'DoubleCoset( <U>, <u>, <V> )'
  2706.  
  2707. 'DoubleCoset'  returns the double coset with  representative <u> and left
  2708. group <U> and right group <V>.  <U> and <V> must have a common parent and
  2709. <u> must lie  in this parent,  otherwise  an error  is signaled.   Double
  2710. cosets are domains,  so all  domain function  are  applicable  to  double
  2711. cosets (see chapter "Domains" and "Set Functions for Double Cosets").
  2712.  
  2713. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2714.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2715.     gap> D := DoubleCoset( U, (1,2,3), U );
  2716.     DoubleCoset( Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2), (3,4) ] ),
  2717.     (1,2,3), Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2), (3,4) ] ) )
  2718.     gap> Size( D );
  2719.     16 |
  2720.  
  2721. 'DoubleCosets' (see "DoubleCosets") computes the set of all double cosets
  2722. of two subgroups in a group.
  2723.  
  2724. 'DoubleCoset' calls '<U>.operations.DoubleCoset(<U>,<u>,<V>)' and returns
  2725. that value.
  2726.  
  2727. The  default function called  this way  is 'GroupOps.DoubleCoset',  which
  2728. creates  a double  coset  record (see  "Double  Coset  Records") with the
  2729. operations record 'DoubleCosetGroupOps' (see  "Set  Functions  for Double
  2730. Cosets").  Look up  'DoubleCosets' in  the index to see  for which groups
  2731. this function is overlaid.
  2732.  
  2733. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2734. \Section{IsDoubleCoset}%
  2735. \index{coset!double}
  2736.  
  2737. 'IsDoubleCoset( <obj> )'
  2738.  
  2739. 'IsDoubleCoset' returns 'true'  if the object <obj>   is a double  coset,
  2740. i.e., a record with the component  'isDoubleCoset' with value 'true', and
  2741. 'false' otherwise.  Will signal an error if <obj> is an unbound variable.
  2742.  
  2743. |    gap> G := Group( (1,2), (1,2,3,4) );;
  2744.     gap> U := Subgroup( G, [ (1,2), (3,4) ] );;
  2745.     gap> D := DoubleCoset( U, (1,2,3), U );;
  2746.     gap> IsDoubleCoset( D );
  2747.     true |
  2748.  
  2749. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2750. \Section{Set Functions for Double Cosets}%
  2751. \index{Elements!for double cosets}\index{IsFinite!for double cosets}%
  2752. \index{Size!for double cosets}\index{comparison!of double cosets}%
  2753. \index{Intersection!for double cosets}\index{Random!for double cosets}%
  2754. \index{Print!for double cosets}\index{product!for double cosets}%
  2755. \index{DoubleCosetGroupOps}
  2756.  
  2757. Double  cosets  are   domains,  thus  all  set  theoretic  functions  are
  2758. applicable to  double  cosets  (see  chapter  "Domains").   The following
  2759. describes  the  functions  that  are  implemented  especially for  double
  2760. cosets.   Functions  not mentioned  here  inherit  the default  functions
  2761. mentioned in the respective sections.
  2762.  
  2763. More technically  speaking, double  cosets  of generic   groups  have the
  2764. operations  record 'DoubleCosetGroupOps',   which inherits its  functions
  2765. from 'DomainOps'  and overlays  the components mentioned  below with more
  2766. efficient functions.
  2767.  
  2768. Most functions below use  the component '<D>.rightCosets' that contains a
  2769. list of right cosets of the  left  group <U> whose  union is  this double
  2770. coset.  If this  component  is unbound they  will compute it by computing
  2771. the orbit of the right group <V> on the right coset  '<U> \*\ <u>', where
  2772. <u>  is the  representative  of  the  double   coset (see "Double   Coset
  2773. Records").
  2774.  
  2775. \vspace{5mm}
  2776. 'Elements( <D> )'
  2777.  
  2778. To compute the  proper set of  elements the  union   of the right  cosets
  2779. '<D>.rightCosets' is computed.
  2780.  
  2781. \vspace{5mm}
  2782. 'IsFinite( <D> )'
  2783.  
  2784. This returns the result of 'IsFinite( <U> ) and IsFinite( <V> )'.
  2785.  
  2786. \vspace{5mm}
  2787. 'Size( <D> )'
  2788.  
  2789. This returns the size of the left group <U> times the number of cosets in
  2790. '<D>.rightCosets'.
  2791.  
  2792. \vspace{5mm}
  2793. '<C> = <D>'
  2794.  
  2795. If <C> and <D> are both double cosets with the same left and right groups
  2796. this returns the result of testing whether the representative of <C> lies
  2797. in <D>.  In other cases the test is delegated to 'DomainOps.='.
  2798.  
  2799. \vspace{5mm}
  2800. '<g> in <D>'
  2801.  
  2802. If <g> is an element of the parent group  of the left  and right group of
  2803. <D>, this returns  'true' if <g>   lies  in one of  the  right  cosets in
  2804. '<D>.rightCosets'.   In    other cases the  the    test is   delegated to
  2805. 'DomainOps.in'.
  2806.  
  2807. \vspace{5mm}
  2808. 'Intersection( <C>, <D> )'
  2809.  
  2810. If <C> and <D> are both double  cosets that are equal, this  returns <C>.
  2811. If <C> and <D> are both double cosets with the same left and right groups
  2812. that  are  not  equal,  this  returns  '[]'.   In  all  other  cases  the
  2813. computation is delegated to 'DomainsOps.Intersection'.
  2814.  
  2815. \vspace{5mm}
  2816. 'Random( <D> )'
  2817.  
  2818. This takes a  random right coset from '<D>.rightCosets'  and returns  the
  2819. result of applying 'Random' to this right coset.
  2820.  
  2821. \vspace{5mm}
  2822. 'Print( <D> )'
  2823.  
  2824. This prints the double coset in the form 'DoubleCoset( <U>, <u>, <V> )'.
  2825.  
  2826. \vspace{5mm}
  2827. '<D> \*\ <g>'\\
  2828. '<g> \*\ <D>'
  2829.  
  2830. Those returns the result of multiplying the proper  set of element of <D>
  2831. with the element <g>, which may signal an error.
  2832.  
  2833. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2834. \Section{Double Coset Records}%
  2835.  
  2836. A double coset is  represented by a  domain record with the following tag
  2837. components.
  2838.  
  2839. 'isDomain': \\
  2840.         always 'true'.
  2841.  
  2842. 'isDoubleCoset': \\
  2843.         always 'true'.
  2844.  
  2845. The  double coset  is determined by  the following  identity  components,
  2846. which every double coset must have.
  2847.  
  2848. 'leftGroup': \\
  2849.         the left subgroup <U>.
  2850.  
  2851. 'rightGroup': \\
  2852.         the right subgroup <V>.
  2853.  
  2854. 'representative': \\
  2855.         an element of the double coset.  It is unspecified which element.
  2856.  
  2857. In  addition,  a double  coset  record  may have the   following optional
  2858. information components.
  2859.  
  2860. 'rightCosets': \\
  2861.         a  list  of disjoint  right  cosets of the   left  subgroup  <U>,
  2862.         whose union is the double coset.
  2863.  
  2864. 'elements': \\
  2865.         if present the proper set of elements of the double coset.
  2866.  
  2867. 'isFinite': \\
  2868.         if present this  is 'true' if  the  double coset   is finite  and
  2869.         'false' if the  double coset is  infinite.  If not present it  is
  2870.         not known whether the double coset is finite or infinite.
  2871.  
  2872. 'size': \\
  2873.         if present the size of the double coset.  Is \"infinity\"\ if the
  2874.         coset is infinite.  If not present the  size  of the double coset
  2875.         is not known.
  2876.  
  2877. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2878.  
  2879. \Section{Group Constructions}
  2880.  
  2881. The  following  functions construct new  parent  groups from given groups
  2882. (see    "DirectProduct",  "SemidirectProduct",    "SubdirectProduct"  and
  2883. "WreathProduct").
  2884.  
  2885. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2886. \Section{DirectProduct}%
  2887. \index{Embedding!into direct products}%
  2888. \index{Projection!onto component of direct products}
  2889.  
  2890. 'DirectProduct( <$G_1$>, ..., <$G_n$> )'
  2891.  
  2892. 'DirectProduct' returns a group record  of the direct  product $D$ of the
  2893. groups <$G_1$>, ....,  <$G_n$> which need not  to have  a  common  parent
  2894. group, it is even possible to construct the direct product of an ag group
  2895. with a permutation group.
  2896.  
  2897. Note that the elements of the direct product  may be just  represented as
  2898. records.  But more complicate constructions, as for instance installing a
  2899. new collector, may be used.  The choice of method strongly depends on the
  2900. type of group arguments.
  2901.  
  2902. \vspace{5mm}
  2903. 'Embedding( <U>, <D>, <i> )'
  2904.  
  2905. Let <U> be a subgroup of  $G_<i>$. 'Embedding' returns  a homomorphism of
  2906. <U> into <D> which describes the embedding of <U> in <D>.
  2907.  
  2908. \vspace{5mm}
  2909. 'Projection( <D>, <U>, <i> )'
  2910.  
  2911. Let <U> be a supergroup of $G_<i>$.  'Projection' returns a  homomorphism
  2912. of <D> into <U> which describes the projection of <D> onto $G_<i>$.
  2913.  
  2914. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  2915.     Group( (1,2,3,4), (1,2) )
  2916.     gap> S4 := AgGroup( s4 );
  2917.     Group( g1, g2, g3, g4 )
  2918.     gap> D := DirectProduct( s4, S4 );
  2919.     Group( DirectProductElement( (1,2,3,4), IdAgWord ), 
  2920.       DirectProductElement( (1,2), IdAgWord ), 
  2921.       DirectProductElement( (), g1 ), 
  2922.       DirectProductElement( (), g2 ), 
  2923.       DirectProductElement( (), g3 ), 
  2924.       DirectProductElement( (), g4 ) )
  2925.     gap> pr := Projection( D, s4, 1 );;
  2926.     gap> Image( pr );
  2927.     Group( (1,2,3,4), (1,2) ) |
  2928.  
  2929. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2930. \Section{DirectProduct for Groups}%
  2931. \index{DirectProduct!for groups}
  2932.  
  2933. 'GroupOps.DirectProduct( <L> )'
  2934.  
  2935. Let <L> be a list of groups $G_1, ..., G_n$. Then a group  element $g$ of
  2936. the direct product $D$ is represented as  record containing the following
  2937. components.
  2938.  
  2939. 'element': \\
  2940.         a list $g_1\in G_1, ..., g_n\in G_n$ describing $g$.
  2941.  
  2942. 'domain': \\
  2943.         contains 'GroupElements'.
  2944.  
  2945. 'isGroupElement': \\
  2946.         contains 'true'.
  2947.  
  2948. 'isDirectProductElement': \\
  2949.         contains 'true'.
  2950.  
  2951. 'operations': \\
  2952.         contains  the    operations   record    'DirectProductElementOps'
  2953.         (see "Domain").
  2954.  
  2955. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  2956. \Section{SemidirectProduct}%
  2957. \index{Embedding!into semidirect products}%
  2958. \index{Projection!onto component of semidirect products}
  2959.  
  2960. 'SemidirectProduct( <G>, <a>, <H> )'
  2961.  
  2962. 'SemidirectProduct' returns the semidirect  product of <G> with <H>.  <a>
  2963. must be  a homomorphism  that from  <G> onto a group <A> that operates on
  2964. <H> via the caret ('\^')  operator.  <A> may either  be a subgroup of the
  2965. parent  group  of   <H>  that  normalizes  <H>,  or  a  subgroup  of  the
  2966. automorphism  group  of <H>, i.e., a group  of automorphisms  (see "Group
  2967. Homomorphisms").
  2968.  
  2969. The semidirect product  of $G$ and $H$  is a the  group of  pairs $(g,h)$
  2970. with $g \in G$ and  $h \in H$, where the product of $(g_1,h_1) (g_2,h_2)$
  2971. is defined as  $(g_1 g_2,  h_1^{g_2^a}  h_2)$.  Note  that  the  elements
  2972. $(1_G,h)$ form a normal subgroup in the semidirect product.
  2973.  
  2974. \vspace{5mm}
  2975. 'Embedding( <U>, <S>, 1 )'
  2976.  
  2977. Let <U>  be  a subgroup of <G>.  'Embedding' returns  the homomorphism of
  2978. <U> into the semidirect product <S> where <u> is mapped to '(<u>,1)'.
  2979.  
  2980. 'Embedding( <U>, <S>, 2 )'
  2981.  
  2982. Let <U> be a subgroup  of <H>.   'Embedding'  returns the homomorphism of
  2983. <U> into the semidirect product <S> where <u> is mapped to '(1,<u>)'.
  2984.  
  2985. \vspace{5mm}
  2986. 'Projection( <S>, <G>, 1 )'
  2987.  
  2988. 'Projection' returns  the homomorphism of <S> onto <G>, where '(<g>,<h>)'
  2989. is mapped to <g>.
  2990.  
  2991. 'Projection( <S>, <H>, 2 )'
  2992.  
  2993. 'Projection' returns the homomorphism of <S> onto <H>, where '(<g>,<h>)'
  2994. is mapped to <h>.
  2995.  
  2996. It is  not specified how  the  elements  of  the  semidirect product  are
  2997. represented.   Thus  'Embedding'  and 'Projection'  are the  only general
  2998. possibility to relate <G> and <H> with the semidirect product.
  2999.  
  3000. |    gap> s4 := Group( (1,2), (1,2,3,4) );;  s4.name := "s4";;
  3001.     gap> s3 := Subgroup( s4, [ (1,2), (1,2,3) ] );; s3.name := "s3";;
  3002.     gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );;  a4.name := "a4";;
  3003.     gap> a := IdentityMapping( s3 );;
  3004.     gap> s := SemidirectProduct( s3, a, a4 );
  3005.     Group( SemidirectProductElement( (1,2), (1,2), () ), 
  3006.       SemidirectProductElement( (1,2,3), (1,2,3), () ), 
  3007.       SemidirectProductElement( (), (), (1,2,3) ), 
  3008.       SemidirectProductElement( (), (), (2,3,4) ) )
  3009.     gap> Size( s );
  3010.     72 |
  3011.  
  3012. Note  that  the three  arguments  of  'SemidirectProductElement'  are the
  3013. element <g>, its image under <a>, and the element <h>.
  3014.  
  3015. 'SemidirectProduct' calls the function '<G>.operations.SemidirectProduct'
  3016. with the arguments <G>, <a>, and <H>, and returns the result.
  3017.  
  3018. The  default  function called  this way is  'GroupOps.SemidirectProduct'.
  3019. This function constructs the semidirect  product as a group of semidirect
  3020. product elements (see "SemidirectProduct for Groups").  Look in the index
  3021. under  *SemidirectProduct*  to see  for  which groups  this  function  is
  3022. overlaid.
  3023.  
  3024. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3025. \Section{SemidirectProduct for Groups}%
  3026. \index{SemidirectProduct!for groups}
  3027.  
  3028. The  function   'GroupOps.SemidirectProduct'  constructs  the  semidirect
  3029. product as a group of semidirect product  elements.  In the following let
  3030. <G>, <a>, and <H> be the arguments of 'SemidirectProduct'.
  3031.  
  3032. Each  such  element  '(<g>,<h>)'  is represented  by a  record  with  the
  3033. following components.
  3034.  
  3035. 'element': \\
  3036.         the list '[ <g>, <h> ]'.
  3037.  
  3038. 'automorphism': \\
  3039.         contains the image of <g> under <a>.
  3040.  
  3041. 'isGroupElement': \\
  3042.         always 'true'.
  3043.  
  3044. 'isSemidirectProductElement': \\
  3045.         always 'true'.
  3046.  
  3047. 'domain': \\
  3048.         contains 'GroupElements'.
  3049.  
  3050. 'operations': \\
  3051.         contains the operations record 'SemidirectProductOps'.
  3052.  
  3053. The operations of semidirect product elements in done in the obvious way.
  3054.  
  3055. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3056. \Section{SubdirectProduct}%
  3057. \index{Projection!for subdirect products}
  3058.  
  3059. 'SubdirectProduct( <G1>, <G2>, <h1>, <h2> )'
  3060.  
  3061. 'SubdirectProduct' returns  the subdirect product of the  groups <G1> and
  3062. <G2>.   <h1> and <h2> must be homomorphisms from  <G1>  and  <G2> into  a
  3063. common group <H>.
  3064.  
  3065. The subdirect product of $G_1$ and $G_2$ is  the  subgroup of  the direct
  3066. product of $G_1$ and $G_2$ of those elements  $(g_1,g_2)$ with $g_1^{h_1}
  3067. =   g_2^{h_2}$.    This   subgroup   is   generated   by   the   elements
  3068. $(g_1,x_{g_1})$,  where $g_1$  loops over  the  generators  of $G_1$  and
  3069. $x_{g_1}  \in  G_2$  is  an  arbitrary  element  such  that $g_1^{h_1}  =
  3070. x_{g_1}^{h_2}$ together with  the  element $(1_G,k_2)$  where $k_2$ loops
  3071. over the generators of the kernel of $h_2$.
  3072.  
  3073. \vspace{5mm}
  3074. 'Projection( <S>, <G1>, 1 )'
  3075.  
  3076. 'Projection' returns the projection of <S> onto <G1>, where '(<g1>,<g2>)'
  3077. is mapped to <g1>.
  3078.  
  3079. 'Projection( <S>, <G2>, 2 )'
  3080.  
  3081. 'Projection' returns the projection of <S> onto <G2>, where '(<g1>,<g2>)'
  3082. is mapped to <g2>.
  3083.  
  3084. It  is  not  specified  how  the  elements of the subdirect  product  are
  3085. represented.   Therefor  'Projection' is the only general possibility  to
  3086. relate <G1> and <G2> with the subdirect product.
  3087.  
  3088. |    gap> s3 := Group( (1,2,3), (1,2) );;
  3089.     gap> c3 := Subgroup( s3, [ (1,2,3) ] );;
  3090.     gap> x1 := Operation( s3, Cosets( s3, c3 ), OnRight );;
  3091.     gap> h1 := OperationHomomorphism( s3, x1 );;
  3092.     gap> d8 := Group( (1,2,3,4), (2,4) );;
  3093.     gap> c4 := Subgroup( d8, [ (1,2,3,4) ] );;
  3094.     gap> x2 := Operation( d8, Cosets( d8, c4 ), OnRight );;
  3095.     gap> h2 := OperationHomomorphism( d8, x2 );;
  3096.     gap> s := SubdirectProduct( s3, d8, h1, h2 );
  3097.     Group( (1,2,3), (1,2)(5,7), (4,5,6,7) )
  3098.     gap> Size( s );
  3099.     24 |
  3100.  
  3101. 'SubdirectProduct' calls the  function '<G1>.operations.SubdirectProduct'
  3102. with the arguments <G1>, <G2>, <h1>, and <h2>.
  3103.  
  3104. The  default  function  called  this way  is 'GroupOps.SubdirectProduct'.
  3105. This  function  constructs the subdirect product as  a  subgroup  of  the
  3106. direct  product.   The  generators for  this  subgroup  are  computed  as
  3107. described above.
  3108.  
  3109. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3110. \Section{WreathProduct}
  3111.  
  3112. 'WreathProduct( <G>, <H> )' \\
  3113. 'WreathProduct( <G>, <H>, <$\alpha$> )'
  3114.  
  3115. In  the   first form of 'WreathProduct'   the  right  regular permutation
  3116. representation   of <H> on  its  elements  is  used as  the  homomorphism
  3117. <$\alpha$>.  In the second form <$\alpha$> must be a homomorphism  of <H>
  3118. into  a  permutation  group.  Let   $d$ be the  degree  of the range   of
  3119. <$\alpha$>.  Then  'WreathProduct'  returns the wreath product  of <G> by
  3120. <H> with  respect to <$\alpha$>,  that is the semi-direct product  of the
  3121. direct product of $d$  copies of <G> which  are  permuted by  <H> through
  3122. application of <$\alpha$> to <H>.
  3123.  
  3124. |    gap> s3 := Group( (1,2,3), (1,2) );
  3125.     Group( (1,2,3), (1,2) )
  3126.     gap> z2 := CyclicGroup( AgWords, 2 );
  3127.     Group( c2 )
  3128.     gap> f := IdentityMapping( s3 );
  3129.     IdentityMapping( Group( (1,2,3), (1,2) ) )
  3130.     gap> w := WreathProduct( z2, s3, f );
  3131.     Group( WreathProductElement( c2, IdAgWord, IdAgWord, (), () ), 
  3132.       WreathProductElement( IdAgWord, c2, IdAgWord, (), () ), 
  3133.       WreathProductElement( IdAgWord, IdAgWord, c2, (), () ), 
  3134.       WreathProductElement( IdAgWord, IdAgWord, IdAgWord, (1,2,3), (1,2,3) 
  3135.        ), 
  3136.       WreathProductElement( IdAgWord, IdAgWord, IdAgWord, (1,2), (1,2) ) )
  3137.     gap> Factors( Size( w ) );
  3138.     [ 2, 2, 2, 2, 3 ] |
  3139.  
  3140. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3141. \Section{WreathProduct for Groups}
  3142.  
  3143. 'GroupOps.WreathProduct( <G>, <H>, <$\alpha$> )'
  3144.  
  3145. Let  $d$ be the  degree of '<$\alpha$>.range'.    A group element  of the
  3146. wreath  product $W$ is represented  as  a record containing the following
  3147. components.
  3148.  
  3149. 'element': \\
  3150.         a list of $d$ elements of <G> followed by an element $h$ of <H>.
  3151.  
  3152. 'permutation': \\
  3153.         the image of $h$ under <$\alpha$>.
  3154.  
  3155. 'domain': \\
  3156.         contains 'GroupElements'.
  3157.  
  3158. 'isGroupElement': \\
  3159.         contains 'true'.
  3160.  
  3161. 'isWreathProductElement': \\
  3162.         contains 'true'.
  3163.  
  3164. 'operations': \\
  3165.         contains         the              operations             record
  3166.         'WreathProductElementOps' (see "Domain").
  3167.  
  3168. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3169.  
  3170. \Section{Group Homomorphisms}%
  3171. \index{homomorphisms!of groups}
  3172.  
  3173. Since groups is probably the most important category of domains in {\GAP}
  3174. group homomorphisms  are  probably the most  important homomorphisms (see
  3175. chapter "Homomorphisms")
  3176.  
  3177. A *group homomorphism* $\phi$  is a  mapping  that maps each element of a
  3178. group $G$,  called  the  source of $\phi$, to an element of another group
  3179. $H$, called the range of $\phi$, such that for each pair $x, y \in  G$ we
  3180. have $(xy)^\phi = x^\phi y^\phi$.
  3181.  
  3182. Examples of group homomorphisms are the natural homomorphism  of  a group
  3183. into a factor group (see "NaturalHomomorphism") and the homomorphism of a
  3184. group    into  a symmetric    group    defined  by   an   operation  (see
  3185. "OperationHomomorphism").  Look under  *group homomorphisms* in the index
  3186. for a list of all available group homomorphisms.
  3187.  
  3188. Since group homomorphisms are just a special  case of  homomorphisms, all
  3189. functions  described in  chapter "Homomorphisms"  are  applicable to  all
  3190. group homomorphisms, e.g., the  function  to test if a homomorphism is an
  3191. automorphism  (see   "IsAutomorphism").   More   general,   since   group
  3192. homomorphisms are just a special case of mappings all functions described
  3193. in chapter "Mappings" are also applicable, e.g., the  function to compute
  3194. the image of an element under a group homomorphism (see "Image").
  3195.  
  3196. The following sections describe the functions that test whether a mapping
  3197. is a group homomorphism (see  "IsGroupHomomorphism"), compute the  kernel
  3198. of a group homomorphism (see "KernelGroupHomomorphism"), how the  general
  3199. mapping  functions are implemented for group homomorphisms (see  "Mapping
  3200. Functions for Group  Homomorphisms"), the natural homomorphism of a group
  3201. onto  a  factor  group  (see   "NaturalHomomorphism"),  homomorphisms  by
  3202. conjugation  (see  "ConjugationGroupHomomorphism",  "InnerAutomorphism"),
  3203. and the  most  general group  homomorphism,  which  is  defined by simply
  3204. specifying    the    images    of    a    set    of    generators    (see
  3205. "GroupHomomorphismByImages").
  3206.  
  3207. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3208. \Section{IsGroupHomomorphism}%
  3209. \index{IsHomomorphism!for groups}
  3210.  
  3211. 'IsGroupHomomorphism( <map> )'
  3212.  
  3213. 'IsGroupHomomorphism' returns  'true'  if the function <map>  is  a group
  3214. homomorphism and 'false' otherwise.  Signals an error if <map> is a multi
  3215. value mapping.
  3216.  
  3217. A mapping $map$ is a group homomorphism  if its source $G$  and range $H$
  3218. are both groups and if  for every pair of elements $x, y \in  G$ it holds
  3219. that $(x y)^{map} = x^{map} y^{map}$.
  3220.  
  3221. |    gap> s4 := Group( (1,2), (1,2,3,4) );;
  3222.     gap> v4 := Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] );;
  3223.     gap> phi := NaturalHomomorphism( s4, s4/v4 );;
  3224.     gap> IsGroupHomomorphism( phi );
  3225.     true
  3226.     gap> IsHomomorphism( phi );
  3227.     true    # since the source is a group this is equivalent to the above
  3228.     gap> IsGroupHomomorphism( FrobeniusAutomorphism( GF(16) ) );
  3229.     false   # it is a field automorphism |
  3230.  
  3231. 'IsGroupHomomorphism' first tests if the flag '<map>.isGroupHomomorphism'
  3232. is bound.  If the flag is bound, 'IsGroupHomomorphism' returns its value.
  3233. Otherwise it calls \\
  3234. '<map>.source.operations.IsGroupHomomorphism(  <map>  )',  remembers  the
  3235. returned value in '<map>.isGroupHomomorphism', and returns it.  Note that
  3236. of  course  all functions  that create group  homomorphisms set the  flag
  3237. '<map>.isGroupHomomorphism' to 'true',  so that no function is called for
  3238. those group homomorphisms.
  3239.  
  3240. The default function called this way is 'MappingOps.IsGroupHomomorphism'.
  3241. It  computes all  the elements  of  the source of <map> and for each such
  3242. element $x$ and  each generator $y$ tests whether $(xy)^{map}  =  x^{map}
  3243. y^{map}$.   Look under  *IsHomomorphism* in  the  index to see  for which
  3244. mappings this function is overlaid.
  3245.  
  3246. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3247. \Section{KernelGroupHomomorphism}%
  3248. \index{Kernel!for groups}
  3249.  
  3250. 'KernelGroupHomomorphism( <hom> )'
  3251.  
  3252. 'KernelGroupHomomorphism'  returns the  kernel of the group  homomorphism
  3253. <hom> as a subgroup of the group '<hom>.source'.
  3254.  
  3255. The *kernel* of a group homomorphism $hom$ is the  subset of elements $x$
  3256. of the source $G$ that are mapped to the identity of the range $H$, i.e.,
  3257. $x^{hom} = H.identity$.
  3258.  
  3259. |    gap> s4 := Group( (1,2), (1,2,3,4) );;
  3260.     gap> v4 := Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] );;
  3261.     gap> phi := NaturalHomomorphism( s4, s4/v4 );;
  3262.     gap> KernelGroupHomomorphism( phi );
  3263.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2)(3,4), (1,3)(2,4) ] )
  3264.     gap> Kernel( phi );
  3265.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2)(3,4), (1,3)(2,4) ] )
  3266.         # since the source is a group this is equivalent to the above
  3267.     gap> rho := GroupHomomorphismByImages( s4, Group( (1,2) ),
  3268.     >                          [ (1,2), (1,2,3,4) ], [ (1,2), (1,2) ] );;
  3269.     gap> Kernel( rho );
  3270.     Subgroup( Group( (1,2), (1,2,3,4) ), [ (2,3,4), (1,3,4) ] ) |
  3271.  
  3272. 'KernelGroupHomomorphism' first  tests if '<hom>.kernelGroupHomomorphism'
  3273. is bound.  If it is bound, 'KernelGroupHomomorphisms' returns that value.
  3274. Otherwise it calls \\
  3275. '<hom>.operations.KernelGroupHomomorphism(   <hom>   )',   remembers  the
  3276. returned value in '<hom>.kernelGroupHomomorphism', and returns it.
  3277.  
  3278. The default  function for  this  is 'MappingOps.KernelGroupHomomorphism',
  3279. which  simply tries random elements  of the  source of  <hom>,  until the
  3280. subgroup  generated  by those that map  to  the identity has the  correct
  3281. size,  i.e.,  'Size( <hom>.source ) / Size(  Image( hom )  )'.  Note that
  3282. this implies  that the  image  of <hom> and  its size are computed.  Look
  3283. under *Kernel* in the  index to see for  which  group  homomorphisms this
  3284. function is overlaid.
  3285.  
  3286. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3287. \Section{Mapping Functions for Group Homomorphisms}%
  3288. \index{IsInjective!for group homomorphisms}%
  3289. \index{IsSurjective!for group homomorphisms}%
  3290. \index{equality!of group homomorphisms}%
  3291. \index{ordering!of group homomorphisms}%
  3292. \index{Image!for group homomorphisms}%
  3293. \index{Images!for group homomorphisms}%
  3294. \index{PreImage!for group homomorphisms}%
  3295. \index{PreImages!for group homomorphisms}
  3296.  
  3297. This  section describes  how the  mapping functions  defined  in  chapter
  3298. "Mappings" are implemented  for group homomorphisms.  Those functions not
  3299. mentioned here  are implemented by the default functions described in the
  3300. respective sections.
  3301.  
  3302. \vspace{5mm}
  3303. 'IsInjective( <hom> )'
  3304.  
  3305. The  group   homomorphism <hom>  is injective  if  the  kernel  of  <hom>
  3306. 'KernelGroupHomomorphism( <hom>   )' (see  "KernelGroupHomomorphism")  is
  3307. trivial.
  3308.  
  3309. \vspace{5mm}
  3310. 'IsSurjective( <hom> )'
  3311.  
  3312. The group homomorphism  <hom> is  surjective  if the size  of  the  image
  3313. 'Size( Image( <hom> ) )'  (see "Image" and below) is equal to the size of
  3314. the range 'Size( <hom>.range )'.
  3315.  
  3316. \vspace{5mm}
  3317. '<hom1> = <hom2>'
  3318.  
  3319. The two group  homomorphisms <hom1>  and <hom2> are equal if the have the
  3320. same source and range and if the images  of the generators of  the source
  3321. under <hom1> and <hom2> are equal.
  3322.  
  3323. \vspace{5mm}
  3324. '<hom1> \<\ <hom2>'
  3325.  
  3326. By definition <hom1> is smaller  than  <hom2> if  either  the  source  of
  3327. <hom1> is  smaller  than  the source of <hom2>,  or, if  the sources  are
  3328. equal, if the range of <hom1> is smaller than the range of <hom2>, or, if
  3329. sources and ranges are  equal, the  image  of the smallest element <x> of
  3330. the source for that the images are not equal under <hom1> is smaller than
  3331. the  image  under   <hom2>.   Therefor   'GroupHomomorphismOps.\<'  first
  3332. compares the sources and the  ranges.  For group homomorphisms with equal
  3333. sources and ranges only the images of the smallest irredundant generating
  3334. system are compared.  A generating system $g_1, g_2, ..., g_n$ is  called
  3335. irredundant if no $g_i$ lies  in the subgroup  generated  by  $g_1,  ...,
  3336. g_{i-1}$.   The  smallest  irredundant generating  system  is simply  the
  3337. smallest  such generating system  with  respect  to  the  lexicographical
  3338. ordering.
  3339.  
  3340. \vspace{5mm}
  3341. 'Image( <hom> )' \\
  3342. 'Image( <hom>, <H> )' \\
  3343. 'Images( <hom>, <H> )'
  3344.  
  3345. The  image  of a  subgroup  under a  group   homomorphism is  computed by
  3346. computing the images  of a set  of  generators  of the subgroup, and  the
  3347. result is the subgroup generated by those images.
  3348.  
  3349. \vspace{5mm}
  3350. 'PreImages( <hom>, <elm> )'
  3351.  
  3352. The preimages of an  element under a group  homomorphism are  computed by
  3353. computing a representative with 'PreImagesRepresentative( <hom>, <elm> )'
  3354. and   the result  is the  coset   of  'Kernel(  <hom> )'  containing this
  3355. representative.
  3356.  
  3357. \vspace{5mm}
  3358. 'PreImage( <hom> )' \\
  3359. 'PreImage( <hom>, <H> )' \\
  3360. 'PreImages( <hom>, <H> )'
  3361.  
  3362. The preimages of a subgroup  under a group  homomorphism  are computed by
  3363. computing representatives of the preimages of  all the generators  of the
  3364. subgroup, adding the generators of the kernel of <hom>, and the result is
  3365. the subgroup generated by those elements.
  3366.  
  3367. Look   under  *IsInjective*,   *IsSurjective*,  *equality*,   *ordering*,
  3368. *Image*, *Images*, *PreImage*,  and *PreImages*  in the index  to see for
  3369. which group homomorphisms these functions are overlaid.
  3370.  
  3371. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3372. \Section{NaturalHomomorphism}%
  3373. \index{group homomorphisms!natural}%
  3374. \index{homomorphisms!natural, group}
  3375.  
  3376. 'NaturalHomomorphism( <G>, <F> )'
  3377.  
  3378. 'NaturalHomomorphism' returns  the natural  homomorphism of the group <G>
  3379. into the factor group <F>.  <F> must be a factor group, i.e.,  the result
  3380. of   'FactorGroup(<H>,<N>)' (see   "FactorGroup")   or   '<H>/<N>'   (see
  3381. "Operations for Groups"), and <G> must be a subgroup of <H>.
  3382.  
  3383. Mathematically the  factor group $H/N$ consists of the cosets of $N$, and
  3384. the natural homomorphism $\phi$ maps each element $h$ of $H$ to the coset
  3385. $N h$.  Note  that in {\GAP} the  representation of factor group elements
  3386. is unspecified, but they are *never* cosets (see "IsRightCoset"), because
  3387. cosets are domains and not  group elements in  {\GAP}.   Thus the natural
  3388. homomorphism  is the  only  connection between  a group  and  one of  its
  3389. factorgroups.
  3390.  
  3391. $G$ is the source  of the natural  homomorphism $\phi$, $F$ is its range.
  3392. Note that because $G$ may be a proper subgroup  of the group $H$ of which
  3393. $F$ is a factor group $\phi$ need not  be  surjective, i.e., the image of
  3394. $\phi$ may be  a proper  subgroup of  $F$.  The  kernel  of $\phi$ is  of
  3395. course the intersection of $N$ and $G$.
  3396.  
  3397. |    gap> s4 := Group( (1,2), (1,2,3,4) );;
  3398.     gap> v4 := Subgroup( s4, [ (1,2)(3,4), (1,3)(2,4) ] );;
  3399.     gap> v4.name := "v4";;
  3400.     gap> phi := NaturalHomomorphism( s4, s4/v4 );;
  3401.     gap> (1,2,3) ^ phi;
  3402.     FactorGroupElement( v4, (2,4,3) )
  3403.     gap> PreImages( phi, last );
  3404.     (v4*(2,4,3))
  3405.     gap> (1,2,3) in last;
  3406.     true
  3407.     gap> rho :=
  3408.     >  NaturalHomomorphism( Subgroup( s4, [ (1,2), (1,2,3) ] ), s4/v4 );;
  3409.     gap> Kernel( rho );
  3410.     Subgroup( Group( (1,2), (1,2,3,4) ), [  ] )
  3411.     gap> IsIsomorphism( rho );
  3412.     true |
  3413.  
  3414. 'NaturalHomomorphism' calls \\
  3415. '<F>.operations.NaturalHomomorphism( <G>, <F> )'
  3416. and returns that value.
  3417.  
  3418. The default function  called this  way is 'GroupOps.NaturalHomomorphism'.
  3419. The  homomorphism   constructed  this  way has the     operations  record
  3420. 'NaturalHomomorphismOps'.  It computes the image of an element <g> of <G>
  3421. by calling 'FactorGroupElement( <N>,  <g> )', the preimages of  an factor
  3422. group element  <f>  as 'Coset(  Kernel(<phi>), <f>.element.representative
  3423. )', and the kernel by  computing 'Intersection( <G>,  <N> )'.  Look under
  3424. *NaturalHomomorphism* in the index to see for which groups this function
  3425. is overlaid.
  3426.  
  3427. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3428. \Section{ConjugationGroupHomomorphism}
  3429. \index{group homomorphisms!conjugation}%
  3430. \index{homomorphisms!conjugation, group}
  3431.  
  3432. 'ConjugationGroupHomomorphism( <G>, <H>, <x> )'
  3433.  
  3434. 'ConjugationGroupHomomorphism' returns the homomorphism from <G> into <H>
  3435. that takes each element <g> in <G> to the element '<g> \^\ <x>'.  <G> and
  3436. <H> must have a common parent  group <P> and <x> must lie in  this parent
  3437. group.  Of course '<G> \^\ <x>' must be a subgroup of <H>.
  3438.  
  3439. |    gap> d12 := Group( (1,2,3,4,5,6), (2,6)(3,5) );; d12.name := "d12";;
  3440.     gap> c2 := Subgroup( d12, [ (2,6)(3,5) ] );
  3441.     Subgroup( d12, [ (2,6)(3,5) ] )
  3442.     gap> v4 := Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6) ] );
  3443.     Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6) ] )
  3444.     gap> x := ConjugationGroupHomomorphism( c2, v4, (1,3,5)(2,4,6) );
  3445.     ConjugationGroupHomomorphism( Subgroup( d12, 
  3446.     [ (2,6)(3,5) ] ), Subgroup( d12, [ (1,2)(3,6)(4,5), (1,4)(2,5)(3,6) 
  3447.      ] ), (1,3,5)(2,4,6) )
  3448.     gap> IsSurjective( x );
  3449.     false
  3450.     gap> Image( x );
  3451.     Subgroup( d12, [ (1,5)(2,4) ] ) |
  3452.  
  3453. 'ConjugationGroupHomomorphism' calls \\
  3454. '<G>.operations.ConjugationGroupHomomorphism( <G>, <H>, <x> )'
  3455. and returns that value.
  3456.  
  3457. The default  function  called is 'GroupOps.ConjugationGroupHomomorphism'.
  3458. It just creates a homomorphism record with range <G>, source <H>, and the
  3459. component 'element' with  the value <x>.   It  computes the  image of  an
  3460. element <g> of <G> as  '<g> \^\ <x>'.  If the sizes  of the range and the
  3461. source are  equal  the inverse  of such  a homomorphism is computed  as a
  3462. conjugation homomorphism from <H> to <G> by  '<x>\^-1'.   To multiply two
  3463. such   homomorphisms  their   elements   are   multiplied.   Look   under
  3464. *ConjugationGroupHomomorphism* in the index to  see for which groups this
  3465. default function is overlaid.
  3466.  
  3467. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3468. \Section{InnerAutomorphism}
  3469. \index{group homomorphisms!inner}%
  3470. \index{homomorphisms!inner, group}
  3471.  
  3472. 'InnerAutomorphism( <G>, <g> )'
  3473.  
  3474. 'InnerAutomorphism' returns the automorphism on the  group <G> that takes
  3475. each element <h> to '<h> \^\ <g>'.  <g> must be an element  in the parent
  3476. group of <G> (but need not actually be in <G>) that normalizes <G>.
  3477.  
  3478. |    gap> s5 := Group( (1,2), (1,2,3,4,5) );;  s5.name := "s5";;
  3479.     gap> i := InnerAutomorphism( s5, (1,2) );
  3480.     InnerAutomorphism( s5, (1,2) )
  3481.     gap> (1,2,3,4,5) ^ i;
  3482.     (1,3,4,5,2) |
  3483.  
  3484. 'InnerAutomorphism( <G>, <g> )' calls 'ConjugationGroupHomomorphism( <G>,
  3485. <G>, <g> )' (see "ConjugationGroupHomomorphism").
  3486.  
  3487. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3488. \Section{GroupHomomorphismByImages}%
  3489. \index{group homomorphisms!by images}%
  3490. \index{homomorphisms!by images, group}%
  3491. \index{Image!for GroupHomomorphismByImages}%
  3492. \index{Images!for GroupHomomorphismByImages}%
  3493. \index{PreImage!for GroupHomomorphismByImages}%
  3494. \index{PreImages!for GroupHomomorphismByImages}%
  3495. \index{IsMapping!for GroupHomomorphismByImages}%
  3496. \index{CompositionMapping!for GroupHomomorphismByImages}%
  3497. \index{InverseMapping!for GroupHomomorphismByImages}
  3498.  
  3499. 'GroupHomomorphismByImages( <G>, <H>, <gens>, <imgs> )'
  3500.  
  3501. 'GroupHomomorphismByImages' returns   the group homomorphism  with source
  3502. <G>  and  range  <H> that  is  defined by mapping    the  list <gens>  of
  3503. generators of <G> to the list <imgs> of images in <H>.
  3504.  
  3505. |    gap> g := Group( (1,2,3,4), (1,2) );;
  3506.     gap> h := Group( (2,3), (1,2) );;
  3507.     gap> m := GroupHomomorphismByImages(g,h,g.generators,h.generators);
  3508.     GroupHomomorphismByImages( Group( (1,2,3,4), (1,2) ), Group( (2,3), 
  3509.     (1,2) ), [ (1,2,3,4), (1,2) ], [ (2,3), (1,2) ] )
  3510.     gap> Image( m, (1,3,4) );
  3511.     (1,3,2)
  3512.     gap> Kernel( m );
  3513.     Subgroup( Group( (1,2,3,4), (1,2) ), [ (1,3)(2,4), (1,4)(2,3) ] ) |
  3514.  
  3515. Note that  the result need not  always be a *single value*  mapping, even
  3516. though the name seems to imply this.  Namely if the elements in <imgs> do
  3517. not satisfy all relations that hold for the generators <gens>, no element
  3518. of <G> has a unique image under the mapping.  This is demonstrated in the
  3519. following example.
  3520.  
  3521. |    gap> g := Group( (1,2,3,4,5,6,7,8,9,10) );;
  3522.     gap> h := Group( (1,2,3,4,5,6) );;
  3523.     gap> m := GroupHomomorphismByImages(g,h,g.generators,h.generators);
  3524.     GroupHomomorphismByImages( Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10
  3525.      ) ), Group( (1,2,3,4,5,6) ), [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10) ],
  3526.     [ (1,2,3,4,5,6) ] )
  3527.     gap> IsMapping( m );
  3528.     false
  3529.     gap> Images( m, () );
  3530.     (Subgroup( Group( (1,2,3,4,5,6) ), [ (1,5,3)(2,6,4) ] )*())
  3531.     gap> g.1^10;
  3532.     ()    # the generator of <g> satisfies this relation
  3533.     gap> h.1^10;
  3534.     (1,5,3)(2,6,4)    # but its image does not |
  3535.  
  3536. The set  of images of the identity  returned  by 'Images'  is the set  of
  3537. elements 'h.1\^<n>' such that 'g.1\^<n>' is the identity in 'g'.
  3538.  
  3539. The test whether  a mapping constructed by 'GroupHomomorphismByImages' is
  3540. a single valued mapping, is usually quite expensive.  Note that this test
  3541. is  automatically performed the first time that you apply a function that
  3542. expects a single valued mapping, e.g., 'Image'  or  'Images'.  There  are
  3543. two possibilities to  avoid this  test.   When  you know that the mapping
  3544. constructed is really  a  single  valued  mapping,  you can  set the flag
  3545. '<map>.isMapping'  to 'true'.   Then  the functions  assume that <map> is
  3546. indeed a mapping and do not test it again.  On the other hand  if you are
  3547. not  certain  whether  the   mapping  is  single  valued,  you   can  use
  3548. 'ImagesRepresentative'  instead of 'Image'  (see "ImagesRepresentative").
  3549. 'ImagesRepresentative' returns  just one possible image,  without testing
  3550. whether there might actually be more than one possible image.
  3551.  
  3552. 'GroupHomomorphismByImages' calls \\
  3553. '<G>.operations.GroupHomomorphismByImages( <G>, <H>, <gens>, <imgs> )' \\
  3554. and returns this value.
  3555.  
  3556. The      default      function       called       this       way       is
  3557. 'GroupOps.GroupHomomorphismByImages'.  Below we describe how the  mapping
  3558. functions  are  implemented  for  such  a  mapping.   The  functions  not
  3559. mentioned below  are implemented by  the  default functions described  in
  3560. "Mapping Functions for Group Homomorphisms".
  3561.  
  3562. All the function below first compute the list of elements  of <G> with an
  3563. orbit   algorithm,   sorts   this  list,   and   stores   this   list  in
  3564. '<hom>.elements'.  In  parallel they computes and  sort a list of images,
  3565. and store this list in '<hom>.images'.
  3566.  
  3567. \vspace{5mm}
  3568. 'IsMapping( <map> )'
  3569.  
  3570. The mapping constructed by 'GroupHomomorphismByImages' is a single valued
  3571. mapping if for each  <i>  and for each  <k> the following equation  holds \\
  3572. '<map>.images[Position(<map>.elements,<map>.elements[<i>]\*<gens>[<k>])]  \\
  3573. = <map>.images[<i>] \*\ <imgs>[<k>]'.
  3574.  
  3575. \vspace{5mm}
  3576. 'Image( <map>, <elm> )'
  3577.  
  3578. If the mapping <map> is a single valued mapping, the image of  an element
  3579. <elm> is computed as '<map>.images[ Position(<map>.elements,<elm>) ]'.
  3580.  
  3581. \vspace{5mm}
  3582. 'ImagesRepresentative( <map>, <elm> )'
  3583.  
  3584. The representative of the  images of  an  element <elm> under the mapping
  3585. <map> is computed as '<map>.images[ Position(<map>.elements,<elm>) ]'.
  3586.  
  3587. \vspace{5mm}
  3588. 'InverseMapping( <map> )'
  3589.  
  3590. The    inverse    of    the    mapping   <map>    is    constructed    as
  3591. 'GroupHomomorphismByImages( <H>, <G>, <imgs>, <gens> )'.
  3592.  
  3593. \vspace{5mm}
  3594. 'CompositionMapping( <map1>, <map2> )'
  3595.  
  3596. If <map2> is  a  mapping  constructed by 'GroupHomomorphismByImages'  the
  3597. composition is constructed by making a copy of <map2> and replacing every
  3598. element in '<map2>.images' with its image under <map1>.
  3599.  
  3600. Look  under *GroupHomomorphismByImages* in  the index  to  see  for which
  3601. groups this function is overlaid.
  3602.  
  3603. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3604.  
  3605. \Section{Set Functions for Groups}%
  3606. \index{Elements!for groups}%
  3607. \index{IsSubset!for groups}%
  3608. \index{Intersection!for groups}
  3609.  
  3610. As already mentioned  in the  introduction  of  the  chapter,  groups are
  3611. domains.  Thus all  set  theoretic functions, for example  'Intersection'
  3612. and  'Size' can be applied  to groups.  This and the  following  sections
  3613. give  further comments on the  definition and  implementations  of  those
  3614. functions for groups.  All set theoretic functions not mentioned here not
  3615. treated specially for groups.  The last section describes the  format  of
  3616. the records that describe groups (see "Group Records").
  3617.  
  3618. \vspace{5mm}
  3619. 'Elements( <G> )'
  3620.  
  3621. The  elements of a  group  <G> are constructed  using a Dimino algorithm.
  3622. See "Elements for Groups".
  3623.  
  3624. \vspace{5mm}
  3625. 'IsSubset( <G>, <H> )'
  3626.  
  3627. If <G> and <H> are groups then 'IsSubset' tests whether the generators of
  3628. <H> are elements of <G>.  Otherwise 'DomainOps.IsSubset' is used.
  3629.  
  3630. \vspace{5mm}
  3631. 'Intersection( <G>, <H> )'
  3632.  
  3633. The intersection  of  groups  <G>  and  <H>  is  computed  using an orbit
  3634. algorithm.  See "Intersection for Groups".
  3635.  
  3636. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3637. \Section{Elements for Groups}
  3638.  
  3639. 'GroupOps.Elements( <G> )'
  3640.  
  3641. 'GroupOps.Elements' returns the sets of elements of <G> (see "Elements").
  3642. The function starts  with the trivial subgroup of <G>,  for which the set
  3643. of elements  is  known and constructs the  successive  closures with  the
  3644. generators of <G> using 'GroupOps.Closure' (see "Closure").
  3645.  
  3646. Note that  this  function  neither checks nor  sets  the record component
  3647. '<G>.elements'.  It recomputes the  set of elements  even it is  bound to
  3648. '<G>.elements'.
  3649.  
  3650. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3651. \Section{Intersection for Groups}
  3652.  
  3653. 'GroupOps.Intersection( <G>, <H> )'
  3654.  
  3655. 'GroupOps.Intersection' returns the intersection of <G> and <H> either as
  3656. set of elements or as a group record (see "Intersection").
  3657.  
  3658. If one argument, say <G>, is a set and the  other a  group, say <H>, then
  3659. 'GroupOps.Intersection' returns the subset  of elements of <G> which  lie
  3660. in <H>.
  3661.  
  3662. If <G> and <H> have  different parent groups then 'GroupOps.Intersection'
  3663. uses the function  'DomainOps.Intersection'  in   order to  compute   the
  3664. intersection.
  3665.  
  3666. Otherwise 'GroupOps.Intersection' computes the  stabilizer of the trivial
  3667. coset  of  the bigger group in  the  smaller group using 'Stabilizer' and
  3668. 'Coset'.
  3669.  
  3670. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3671. \Section{Operations for Groups}%
  3672. \index{operations!for groups}%
  3673. \index{conjugate!of a group}%
  3674. \index{membershiptest!for groups}%
  3675. \index{product!of a group and a group element}%
  3676. \index{quotient!of groups}
  3677.  
  3678. '<G> \^\ <s>'
  3679.  
  3680. The operator '\^' evaluates  to  the subgroup   conjugate to <G>  under a
  3681. group element <s> of the parent group of <G>.  See "ConjugateSubgroup".
  3682.  
  3683. |    gap> s4 := Group( (1,2,3,4), (1,2) );
  3684.     Group( (1,2,3,4), (1,2) )
  3685.     gap> s4.name := "s4";;
  3686.     gap> v4 := Subgroup( s4, [ (1,2), (1,2)(3,4) ] );
  3687.     Subgroup( s4, [ (1,2), (1,2)(3,4) ] )
  3688.     gap> v4 ^ (2,3);
  3689.     Subgroup( s4, [ (1,3), (1,3)(2,4) ] )
  3690.     gap> v4 ^ (2,5);
  3691.     Error, <g> must be an element of the parent group of <G> |
  3692.  
  3693. \vspace{5mm}
  3694. '<s> in <G>'
  3695.  
  3696. The operator 'in'  evaluates to  'true' if <s> is an  element of  <G> and
  3697. 'false' otherwise. <s> must be an element of the parent group of <G>.
  3698.  
  3699. |    gap> (1,2,3,4) in v4;
  3700.     false
  3701.     gap> (2,4) in v4^(2,3);
  3702.     true |
  3703.  
  3704. \vspace{5mm}
  3705. '<G> \*\ <s>'
  3706.  
  3707. The operator '\*' evaluates to the right coset of <G> with representative
  3708. <s>.   <s>  must  be  an  element  of  the  parent  group  of  <G>.   See
  3709. "RightCoset" for details about right cosets.
  3710.  
  3711. \vspace{5mm}
  3712. '<s> \*\ <G>'
  3713.  
  3714. The operator '\*' evaluates to the left coset of <G>  with representative
  3715. <s>.  <s> must be an element of the parent group of <G>.  See "LeftCoset"
  3716. for details about left cosets.
  3717.  
  3718. |    gap> v4 * (1,2,3,4);
  3719.     (Subgroup( s4, [ (1,2), (1,2)(3,4) ] )*(1,2,3))
  3720.     gap> (1,2,3,4) * v4;
  3721.     ((1,2,3,4)*Subgroup( s4, [ (1,2), (1,2)(3,4) ] )) |
  3722.  
  3723. \vspace{5mm}
  3724. '<G> / <N>'
  3725.  
  3726. The operator '/' evaluates to the factor group $<G> / <N>$ where <N> must
  3727. be a normal subgroup of <G>.   This is the same as 'FactorGroup(<G>,<N>)'
  3728. (see "FactorGroup").
  3729.  
  3730. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3731. \Section{Group Records}
  3732.  
  3733. As  for all domains (see "Domains" and "Domain Records") groups and their
  3734. subgroups are represented by  records that contain important  information
  3735. about groups.  Most of the following functions return  such  records.  Of
  3736. course it  is  possible to create  a  group record by hand but  generally
  3737. 'Group' (see "Group") and 'Subgroup' (see "Subgroup")  should be used for
  3738. such tasks.
  3739.  
  3740. Once  a group record is created you may add  record  components to it but
  3741. you   must   not  alter  informations  already  present, especially   not
  3742. 'generators' and 'identity'.
  3743.  
  3744. Group   records   must   always  contain  the    components 'generators',
  3745. 'identity',  'isDomain' and  'isGroup'.  Subgroups contain  an additional
  3746. component 'parent'.  The contents of  all components of  a group $G$  are
  3747. described below.
  3748.  
  3749. The following two components are the so-called *category components* used
  3750. to identify the category this domain belongs to.
  3751.  
  3752. 'isDomain': \\
  3753.         is always 'true' as a group is a domain.
  3754.  
  3755. 'isGroup': \\
  3756.         is of course 'true' as $G$ is a group.
  3757.  
  3758. The following three  components determine a group domain. These  are  the
  3759. so-called *identification components*.
  3760.  
  3761. 'generators': \\
  3762.         is a list group generators.  Duplicate generators are allowed but
  3763.         none of the generators may be the group identity.   The group $G$
  3764.         is the trivial group  if and only  if 'generators' is   the empty
  3765.         list. Note that once created this entry must never be changed, as
  3766.         most of the other entries depend on 'generators'.
  3767.  
  3768. 'identity': \\
  3769.         is the group identity of $G$.
  3770.  
  3771. 'parent': \\
  3772.         if present  this contains the group record of the parent group of
  3773.         a subgroup $G$, otherwise $G$ itself is a parent group.
  3774.  
  3775. The following components  are optional and  contain *knowledge* about the
  3776. group $G$.
  3777.  
  3778. 'abelianInvariants': \\
  3779.         a  list  of  integers  containing  the  abelian  invariants of an
  3780.         abelian group $G$.
  3781.  
  3782. 'centralizer': \\
  3783.         contains the centralizer of $G$ in its parent group.
  3784.  
  3785. 'centre': \\
  3786.         contains the centre of $G$. See "Centre".
  3787.  
  3788. 'commutatorFactorGroup': \\
  3789.         contains     the commutator   factor   group   of     $G$.    See
  3790.         "CommutatorFactorGroup" for details.
  3791.  
  3792. 'conjugacyClasses': \\
  3793.         contains   a  list  of   the conjugacy   classes   of  $G$.   See
  3794.         "ConjugacyClasses" for details.
  3795.  
  3796. 'core': \\
  3797.         contains the core of $G$ under the action of  its  parent  group.
  3798.         See "Core" for details.
  3799.  
  3800. 'derivedSubgroup':  \\   
  3801.         contains the derived subgroup of $G$. See "DerivedSubgroup".
  3802.  
  3803. 'elements': \\
  3804.         is the set of all elements of $G$. See "Elements".
  3805.  
  3806. 'fittingSubgroup': \\
  3807.         contains the Fitting subgroup of $G$. See "FittingSubgroup".
  3808.  
  3809. 'frattiniSubgroup': \\
  3810.         contains the Frattini subgroup of $G$. %N See "FrattiniSubgroup".
  3811.  
  3812. 'index': \\
  3813.         contains the index of $G$ in its parent group. See "Index".
  3814.  
  3815. 'lowerCentralSeries': \\
  3816.         contains the lower  central series of  $G$  as list of subgroups.
  3817.         See "LowerCentralSeries".
  3818.  
  3819. 'normalizer': \\
  3820.         contains  the   normalizer  of  $G$  in  its  parent  group.  See
  3821.         "Normalizer" for details.
  3822.  
  3823. 'normalClosure': \\
  3824.         contains the normal closure of  $G$  in  its  parent  group.  See
  3825.         "NormalClosure" for details.
  3826.  
  3827. 'upperCentralSeries': \\
  3828.         contains the  upper central series  of $G$ as  list of subgroups.
  3829.         See "UpperCentralSeries".
  3830.  
  3831. 'subnormalSeries': \\
  3832.         contains  a  subnormal series  from  the   parent of  $G$ down to
  3833.         $G$.  See "SubnormalSeries" for details.
  3834.  
  3835. 'sylowSubgroups': \\
  3836.         contains a list of  Sylow subgroups  of $G$.  See "SylowSubgroup"
  3837.         for details.
  3838.  
  3839. 'size': \\
  3840.         is either an integer containing the size of a finite group or the
  3841.         string {``infinity\'\'} if the group is infinite. See "Size".
  3842.  
  3843. 'perfectSubgroups': \\
  3844.         contains  the a  list of  subgroups  which includes at  least one
  3845.         representative   of  each  class   of  conjugate  proper  perfect
  3846.         subgroups of $G$. See "Lattice".
  3847.  
  3848. 'lattice': \\
  3849.         contains the subgroup lattice of $G$. See "Lattice".
  3850.  
  3851. 'conjugacyClassesSubgroups': \\
  3852.         identical  to   the  list  '$G$.lattice.classes',   contains  the
  3853.         conjugacy    classes     of     subgroups     of     $G$.     See
  3854.         "ConjugacyClassesSubgroups".
  3855.  
  3856. 'tableOfMarks': \\
  3857.         contains the table of narks of $G$. See "TableOfMarks".
  3858.  
  3859. The following components are  'true' if  the group  $G$ has the property,
  3860. 'false' if  not, and are not present  if it is unknown whether  the group
  3861. has the property or not.
  3862.  
  3863. 'isAbelian': \\
  3864.         is 'true' if the group $G$ is abelian. See "IsAbelian".
  3865.  
  3866. 'isCentral': \\
  3867.         is  'true'  if  the  group   $G$    is  central in   its   parent
  3868.         group.  See "IsCentral".
  3869.  
  3870. 'isCyclic': \\
  3871.         is 'true' if the group $G$ is cyclic. See "IsCyclic".
  3872.  
  3873. 'isElementaryAbelian': \\
  3874.         is  'true'  if   the  group  $G$    is   elementary  abelian. See
  3875.         "IsElementaryAbelian".
  3876.  
  3877. 'isFinite': \\
  3878.         is 'true' if the group $G$ is  finite.  If you  know that a group
  3879.         for which you want to use the generic low  level  group functions
  3880.         is  infinite, you  should   set  this component to 'false'.  This
  3881.         will avoid attempts to compute the set of elements.
  3882.  
  3883. 'isNilpotent': \\
  3884.         is 'true' if the group $G$ is nilpotent. See "IsNilpotent".
  3885.  
  3886. 'isNormal': \\
  3887.         is  'true' if the group  $G$ is normal in its parent group.   See
  3888.         "IsNormal".
  3889.  
  3890. 'isPerfect': \\
  3891.         is 'true' if the group $G$ is perfect. See "IsPerfect".
  3892.  
  3893. 'isSimple': \\
  3894.         is 'true' if the group $G$ is simple. See "IsSimple".
  3895.  
  3896. 'isSolvable': \\
  3897.         is 'true' if the group $G$ is solvable. See "IsSolvable".
  3898.  
  3899. 'isSubnormal': \\
  3900.         is 'true' if the group $G$ is subnormal in its  parent group. See
  3901.         "IsSubnormal".
  3902.  
  3903. The component 'operations' contains  the *operations record* (see "Domain
  3904. Records" and "Dispatchers").
  3905.  
  3906. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  3907. %%
  3908.  
  3909. %Emacs setup
  3910. %E Local Variables:
  3911. %E mode:           outline
  3912. %E outline-regexp: "\\\\Chapter\\|\\\\Section\\|\\%Emacs"
  3913. %E fill-column:    73
  3914. %E eval:           (hide-body)
  3915. %E End:
  3916. %%
  3917.  
  3918.  
  3919.  
  3920.