4. LAGUNA functions
  
  
  4.1 General functions for group algebras
  
  4.1-1 IsGroupAlgebra
  
  > IsGroupAlgebra( KG ) _____________________________________________property
  
  A  group  ring  over a field is called a group algebra. For a group ring KG,
  IsGroupAlgebra  returns true, if the underlying ring of KG is a field; false
  is  returned  otherwise.  This  property will be set automatically for every
  group ring created by the function GroupRing.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsGroupAlgebra( GroupRing( GF( 2 ), DihedralGroup( 16 ) ) );
    true
    gap> IsGroupAlgebra( GroupRing( Integers, DihedralGroup( 16 ) ) );
    false      
    
  ------------------------------------------------------------------
  
  4.1-2 IsFModularGroupAlgebra
  
  > IsFModularGroupAlgebra( KG ) _____________________________________property
  
  A  group  algebra KG over a field K is called modular, if the characteristic
  of  the  field K divides the order of some element in G. For a group algebra
  KG of a finite group G, IsModularGroupAlgebra returns true, if KG is modular
  according  to  this  definition;  false is returned otherwise. This property
  will  be  set automatically for every group algebra, created by the function
  GroupRing.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsFModularGroupAlgebra( GroupRing( GF( 2 ), SymmetricGroup( 6 ) ) );
    true
    gap> IsFModularGroupAlgebra( GroupRing( GF( 2 ), CyclicGroup( 3 ) ) );
    false  
    
  ------------------------------------------------------------------
  
  4.1-3 IsPModularGroupAlgebra
  
  > IsPModularGroupAlgebra( KG ) _____________________________________property
  
  A  group  algebra  KG  is  said  to  be  p-modular,  if  K  is  a  field  of
  characteristic p and G is a finite p-group for the same prime p. For a group
  algebra  KG  of a finite group G, IsPModularGroupAlgebra returns true, if KG
  is p-modular according to this definition; false is returned otherwise. This
  property  will  be set automatically for every group algebra, created by the
  function GroupRing.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsPModularGroupAlgebra( GroupRing( GF( 2 ), DihedralGroup( 16 ) ) );
    true
    gap> IsPModularGroupAlgebra( GroupRing( GF( 2 ), SymmetricGroup( 6 ) ) );
    false        
    
  ------------------------------------------------------------------
  
  4.1-4 UnderlyingGroup
  
  > UnderlyingGroup( KG ) ___________________________________________attribute
  Returns:  the underlying group of a group ring
  
  This  attribute  stores the underlying group of a group ring KG. In fact, it
  refers  to  the attribute UnderlyingMagma which returns the same result, and
  was introduced for group rings for convenience, and for teaching purposes.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF ( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> G := UnderlyingGroup( KG );
    <pc group of size 16 with 4 generators>  
    
  ------------------------------------------------------------------
  
  4.1-5 UnderlyingRing
  
  > UnderlyingRing( KG ) ____________________________________________attribute
  Returns:  the underlying ring of a group ring
  
  This  attribute  stores  the underlying ring of a group ring KG. In fact, it
  refers  to the attribute LeftActingDomain which returns the same result, and
  was introduced for group rings for convenience, and for teaching purposes.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> UnderlyingRing( KG );
    GF(2)     
    
  ------------------------------------------------------------------
  
  4.1-6 UnderlyingField
  
  > UnderlyingField( KG ) ___________________________________________attribute
  Returns:  the underlying field of a group algebra
  
  This  attribute  stores the underlying field of a group algebra KG. In fact,
  it  refers  to the attribute LeftActingDomain which returns the same result,
  and  was  introduced  for  group  algebras for convenience, and for teaching
  purposes.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> UnderlyingField( KG );
    GF(2)    
    
  ------------------------------------------------------------------
  
  
  4.2 Operations with group algebra elements
  
  4.2-1 Support
  
  > Support( x ) ____________________________________________________attribute
  Returns:  support of x as a list of elements of the underlying group
  
  Returns  the  support  of  a group ring element x. The support of a non-zero
  element x = alpha_1 * g_1 + alpha_2 * g_2 + cdots + alpha_k * g_k of a group
  ring  is  the list of elements g_i in G for which the coefficient alpha_i is
  non-zero.  The  support of the zero element of a group ring is defined to be
  the empty list. This method is also applicable to elements of magma rings.
  
  ---------------------------  Example  ----------------------------
    
    # First we create an element x to use in in the series of examples.
    # We map the minimal generating system of the group G to its group algebra
    # and denote their images as a and b
    gap> G:=DihedralGroup(16);; KG:=GroupRing(GF(2),G);;
    gap> l := List( MinimalGeneratingSet( G ), g -> g^Embedding( G, KG ) );
    [ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
    gap> a := l[1]; b := l[2]; e := One( KG ); # we denote the identity by e
    (Z(2)^0)*f1
    (Z(2)^0)*f2
    (Z(2)^0)*<identity> of ...
    gap> x := ( e + a ) * ( e + b );
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> Support( x );
    [ <identity> of ..., f1, f2, f1*f2 ]     
    
  ------------------------------------------------------------------
  
  4.2-2 CoefficientsBySupport
  
  > CoefficientsBySupport( x ) ______________________________________attribute
  Returns:  coefficients  of  support  elements  as  list  of  elements of the
            underlying ring
  
  Returns  a list that contains the coefficients corresponding to the elements
  of  Support(  x  ) in the same order as the elements appear in Support( x ).
  This method is also applicable to elements of magma rings.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> CoefficientsBySupport( x );
    [ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ]   
    
  ------------------------------------------------------------------
  
  4.2-3 TraceOfMagmaRingElement
  
  > TraceOfMagmaRingElement( x ) ____________________________________attribute
  Returns:  an element of the underlying ring
  
  Returns  the trace of a group ring element x. By definition, the trace of an
  element  x = alpha_1 * 1 + alpha_2 * g_2 + cdots + alpha_k * g_k is equal to
  alpha_1, that is, the coefficient of the identity element in G. The trace of
  the  zero  element  is  zero.  This method is also applicable to elements of
  magma rings.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> TraceOfMagmaRingElement( x );
    Z(2)^0        
    
  ------------------------------------------------------------------
  
  4.2-4 Length
  
  > Length( x ) _____________________________________________________attribute
  
  The  length  of  an  element  of  a group ring x is defined as the number of
  elements in its support. This method is also applicable to elements of magma
  rings.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> Length( x );
    4     
    
  ------------------------------------------------------------------
  
  4.2-5 Augmentation
  
  > Augmentation( x ) _______________________________________________attribute
  Returns:  the sum of coefficients of a group ring element
  
  The augmentation of a group ring element x = alpha_1 * g_1 + alpha_2 * g_2 +
  cdots  +  alpha_k  *  g_k is the sum of its coefficients alpha_1 + alpha_2 +
  cdots + alpha_k. The method is also applicable to elements of magma rings.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> Augmentation( x );
    0*Z(2)     
    
  ------------------------------------------------------------------
  
  4.2-6 PartialAugmentations
  
  > PartialAugmentations( KG, x ) ___________________________________operation
  Returns:  a  list  of  partial  augmentations  and a list of conjugacy class
            representatives
  
  The  partial  augmentation of an element x = alpha_1 * g_1 + alpha_2 * g_2 +
  cdots  +  alpha_k * g_k of the group ring KG, corresponding to the conjugacy
  class of an element g from the underlying group G is the sum of coefficients
  alpha_i  taken  over  all g_i such that g_i is conjugated to g. The function
  returns  a  list  of  two  lists,  the  first  one  is  a  list  of  partial
  augmentations,  and  the  second is a list of representatives of appropriate
  conjugacy classes of elements of the group G.
  
  ---------------------------  Example  ----------------------------
    
    gap> y := x + a*b^2;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2+(Z(2)^
    0)*f1*f3
    gap> PartialAugmentations( KG, y );
    [ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ], [ <identity> of ..., f1, f2, f1*f2 ] ]    
    
  ------------------------------------------------------------------
  
  4.2-7 Involution
  
  > Involution( x, f ) ______________________________________________operation
  > Involution( x ) _________________________________________________operation
  Returns:  an element of a group ring
  
  Let  KG  be a group ring and let f be a mapping G -> G, such that f^2 is the
  identity  mapping on G. Then the involution of KG induced by f is defined by
  alpha_1  * g_1 + alpha_2 * g_2 + cdots + alpha_k * g_k -> alpha_1 * f(g_1) +
  alpha_2  *  f(g_2) + cdots + alpha_k * f(g_k). This method returns the image
  of x under the involution of KG with respect to f.
  
  In  the  second  form  the  function  returns  the  result  of the so-called
  classical involution, which is the involution induced by the map x -> x^-1.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> Involution( x );
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3*f4
    # let's check the action of involution on elements from the group G
    gap> l := List( MinimalGeneratingSet( G ), g -> g^Embedding( G, KG ) );
    [ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
    gap> List( l, Involution );
    [ (Z(2)^0)*f1, (Z(2)^0)*f2*f3*f4 ]
    gap> List( l, g -> g^-1 );
    [ (Z(2)^0)*f1, (Z(2)^0)*f2*f3*f4 ]     
    
  ------------------------------------------------------------------
  
  4.2-8 IsSymmetric
  
  > IsSymmetric( x ) ________________________________________________attribute
  
  An  element  of  a  group  ring is called symmetric if it is fixed under the
  classical involution. This property is checked here.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsSymmetric( x );
    false
    gap> IsSymmetric( x * Involution( x ) );
    true     
    
  ------------------------------------------------------------------
  
  4.2-9 IsUnitary
  
  > IsUnitary( x ) __________________________________________________attribute
  
  A unit of a group ring is called unitary if the classical involution inverts
  it. This property is checked here.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsUnitary(x);
    false
    # let's check that elements of the group G are unitary
    gap> l:=List(MinimalGeneratingSet(G),g -> g^Embedding(G,KG));
    [ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
    gap> List(l,IsUnitary);
    [ true, true ]   
    
  ------------------------------------------------------------------
  
  4.2-10 IsUnit
  
  > IsUnit( KG, x ) ____________________________________________________method
  > IsUnit( x ) ________________________________________________________method
  
  This  method  improves  a  standard  GAP  functionality  for  modular  group
  algebras.
  
  In  the  first form the method returns true if x is an invertible element of
  the  modular  group  algebra  KG  and false otherwise. This can be done very
  quickly by checking whether the augmentation of the element x is non-zero.
  
  In  the  second  form  LAGUNA  first constructs the group H generated by the
  support  of  x,  and, if this group is a finite p-group, then checks whether
  the  coefficients  of  x belong to a field F of characteristic p. If this is
  the  case, then IsUnit( FH, x ) is called; otherwise, standard GAP method is
  used.
  
  ---------------------------  Example  ----------------------------
    
    gap> x;
    (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> IsUnit( KG, x ); # clearly, is not a unit due to augmentation zero
    false
    gap> y := One( KG ) + x; # this should give a unit
    (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> IsUnit( KG, y );
    true       
    
  ------------------------------------------------------------------
  
  4.2-11 InverseOp
  
  > InverseOp( x ) _____________________________________________________method
  Returns:  the inverse element of an element of a group ring
  
  This  method  improves  a  standard  GAP  functionality  for  modular  group
  algebras. It calculates the inverse of a group algebra element. The user can
  also invoke this function by typing  x^-1 .
  
  ---------------------------  Example  ----------------------------
    
    gap> y;
    (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
    gap> y^-1;
    (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
    0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f4+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(
    Z(2)^0)*f1*f2*f3*f4
    gap> y * y^-1;
    (Z(2)^0)*<identity> of ...    
    
  ------------------------------------------------------------------
  
  4.2-12 BicyclicUnitOfType1
  
  > BicyclicUnitOfType1( KG, a, g ) _________________________________operation
  > BicyclicUnitOfType1( a, g ) _____________________________________operation
  > BicyclicUnitOfType2( KG, a, g ) _________________________________operation
  > BicyclicUnitOfType2( a, g ) _____________________________________operation
  Returns:  an element of a group ring
  
  let  a  be  an element of order n of a group G. We put alpha = 1 + a + a^2 +
  ...  +a^n-1. Then (a-1)*g*alpha and alpha*g*(a-1) are nilpotent of index two
  for  any  element  g of the group G not containing in the normalizer N_G(< a
  >),  and the units u_a,g = 1 + (a-1) * g * alpha and v_a,g = 1 + alpha * g *
  (a-1)  are called bicyclic units. Note that u_a,g and v_a,g may coincide for
  some  a  and  g,  but  in  general this does not hold. In the three-argument
  version  these  methods  construct bicyclic units of both types when a and g
  are  elements of the underlying group G of a group ring KG. The two-argument
  version  accepts images of elements a and g from the underlying group in the
  group ring KG obtained using the mapping Embedding( G, KG ). Note that it is
  not  actually checked that g is not contained in N_G(< a >), because this is
  verified in BicyclicUnitGroup (4.4-13).
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup(32,6);
    <pc group of size 32 with 5 generators>
    gap> KG := GroupRing( GF(2), G );
    <algebra-with-one over GF(2), with 5 generators>
    gap> g := MinimalGeneratingSet( G );
    [ f1, f2 ]
    gap> g[1] in Normalizer( G, Subgroup( G, [g[2]] ) );
    false
    gap> g[2] in Normalizer( G, Subgroup( G, [g[1]] ) );
    false
    gap> g := List( g, x -> x^Embedding( G, KG ) );
    [ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
    gap> BicyclicUnitOfType1(g[1],g[2]) = BicyclicUnitOfType2(g[1],g[2]);
    false                                                                       
    
  ------------------------------------------------------------------
  
  
  4.3 Important attributes of group algebras
  
  4.3-1 AugmentationHomomorphism
  
  > AugmentationHomomorphism( KG ) __________________________________attribute
  Returns:  a homomorphism from a group ring to the underlying ring
  
  The  mapping which maps an element of a group ring KG to its augmentation is
  a  homomorphism  from  KG  onto  the  ring K; see Augmentation (4.2-5). This
  attribute stores this homomorphism for the group ring KG.
  
  Please  note  that  for  calculation  of the augmentation of an element of a
  group  ring  the  user  is  strongly recommended to use Augmentation (4.2-5)
  which works much faster than AugmentationHomomorphism.
  
  ---------------------------  Example  ----------------------------
    
    gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
    GF(2)
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> e := Embedding( G,FG );
    <mapping: SymmetricGroup( [ 1 .. 3 ] ) -> AlgebraWithOne( GF(2), ... ) >
    gap> x := (1,2)^e; y := (1,3)^e;
    (Z(2)^0)*(1,2)
    (Z(2)^0)*(1,3)
    gap> a := AugmentationHomomorphism( FG );
    [ (Z(2)^0)*(1,2,3), (Z(2)^0)*(1,2) ] -> [ Z(2)^0, Z(2)^0 ]
    gap> x^a; y^a; ( x + y )^a; # this is slower
    Z(2)^0
    Z(2)^0
    0*Z(2)   
    gap> Augmentation(x); Augmentation(y); Augmentation( x + y ); # this is faster
    Z(2)^0
    Z(2)^0
    0*Z(2)   
    
  ------------------------------------------------------------------
  
  4.3-2 AugmentationIdeal
  
  > AugmentationIdeal( KG ) _________________________________________attribute
  Returns:  an ideal of a group ring
  
  If  KG  is  a  group ring, then its augmentation ideal A is generated by all
  elements  of  the  form  g-1,  where  g in G \ { 1 }. The augmentation ideal
  consists  of  all  elements  of  FG  with  augmentation  0; see Augmentation
  (4.2-5).  This method changes a standard GAP functionality for modular group
  algebras and returns the augmentation ideal of a modular group algebra KG.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> AugmentationIdeal( KG );
    <two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
      (dimension 15)>
    
  ------------------------------------------------------------------
  
  4.3-3 RadicalOfAlgebra
  
  > RadicalOfAlgebra( KG ) __________________________________________attribute
  Returns:  an ideal of a group algebra
  
  This method improves a standard GAP functionality for modular group algebras
  of  finite  p-groups.  Since  in  this case the radical of the group algebra
  coincides  with  its  augmentation  ideal,  this method simply checks if the
  algebra  KG  is  a  p-modular  group  algebra,  and,  if yes, it returns the
  augmentation ideal; otherwise, the standard GAP method will be used.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> RadicalOfAlgebra( KG );
    <two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
      (dimension 15)>
    gap> RadicalOfAlgebra( KG ) = AugmentationIdeal( KG );
    true     
    
  ------------------------------------------------------------------
  
  4.3-4 WeightedBasis
  
  > WeightedBasis( KG ) _____________________________________________attribute
  Returns:  a  record  of  two  components:  weighted basis elements and their
            weights
  
  The argument KG must be a p-modular group algebra.
  
  For a group algebra KG, let A denote the augmentation ideal, and assume that
  c  is  the  smallest  number such that A^c=0. Then a weighted basis of KG is
  some  basis  b_1, ..., b_n for the augmentation ideal A, for which there are
  indices  i_1=1, ..., i_c-1 such that b_i_k, ..., b_n is a basis for A^k. The
  weight  of  an  element b_i of a weighted basis is the unique integer w such
  that  b_i  belongs  to  w-th  power of A but does not belong to its (w+1)-th
  power.
  
  Note  that  this  function  actually constructs a basis for the augmentation
  ideal  of  KG  and  not  for  KG  itself.  Since  the augmentation ideal has
  co-dimension 1 in KG, a basis for KG can be easily obtained by adjoining the
  identity element of the group.
  
  The  method  returns a record whose basis entry is the basis and the weights
  entry  is  a  list  of  the corresponding weights the of basis elements. See
  Section 3.3 for more details.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), ElementaryAbelianGroup( 4 ) );
    <algebra-with-one over GF(2), with 2 generators>
    gap> WeightedBasis( KG );
    rec(
      weightedBasis := [ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f2, (Z(2)^0)*<identity>
            of ...+(Z(2)^0)*f1, (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(
            Z(2)^0)*f1*f2 ], weights := [ 1, 1, 2 ] )
    
  ------------------------------------------------------------------
  
  4.3-5 AugmentationIdealPowerSeries
  
  > AugmentationIdealPowerSeries( KG ) ______________________________attribute
  Returns:  a list of ideals of a group algebra
  
  The  argument  KG  is  a  p-modular group algebra. The method returns a list
  whose  elements  are  the  terms of the augmentation ideal filtration of KG,
  that   is  AugmentationIdealPowerSeries(A)[i]  is  the  i-th  power  of  the
  augmentation ideal of KG.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> AugmentationIdealPowerSeries( KG );
    [ <algebra of dimension 15 over GF(2)>, <algebra of dimension 13 over GF(2)>,
      <algebra of dimension 11 over GF(2)>, <algebra of dimension 9 over GF(2)>,
      <algebra of dimension 7 over GF(2)>, <algebra of dimension 5 over GF(2)>,
      <algebra of dimension 3 over GF(2)>, <algebra of dimension 1 over GF(2)>,
      <algebra over GF(2)> ]
    gap> Length(last);
    9      
    
  ------------------------------------------------------------------
  
  4.3-6 AugmentationIdealNilpotencyIndex
  
  > AugmentationIdealNilpotencyIndex( KG ) __________________________attribute
  
  For  the p-modular group algebra KG the method returns the smallest number n
  such  that  A^n=0, where A is the augmentation ideal of KG. This can be done
  using  Jenning's  theory  without the explicit calculations of the powers of
  the augmentation ideal.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> AugmentationIdealNilpotencyIndex( KG );
    9      
    
  ------------------------------------------------------------------
  
  4.3-7 AugmentationIdealOfDerivedSubgroupNilpotencyIndex
  
  > AugmentationIdealOfDerivedSubgroupNilpotencyIndex( KG ) _________attribute
  
  For  the  p-modular  group  algebra  KG this attribute stores the nilpotency
  index of the augmentation ideal of KG' where G' denotes the derived subgroup
  of G.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> AugmentationIdealOfDerivedSubgroupNilpotencyIndex( KG );
    4
    gap> D := DerivedSubgroup( UnderlyingGroup( KG ) );
    Group([ f3, f4 ])
    gap> KD := GroupRing( GF( 2 ), D );
    <algebra-with-one over GF(2), with 2 generators>
    gap> AugmentationIdealNilpotencyIndex( KD );
    4       
    
  ------------------------------------------------------------------
  
  4.3-8 LeftIdealBySubgroup
  
  > LeftIdealBySubgroup( KG, H ) ____________________________________operation
  > RightIdealBySubgroup( KG, H ) ___________________________________operation
  > TwoSidedIdalBySubgroup( KG, H ) _________________________________operation
  > LeftIdealBySubgroup( KG, H ) ____________________________________operation
  Returns:  an ideal of a group ring
  
  Let  KG be a group ring of a group G over the ring K, and H be a subgroup of
  G. Then the set J_l(H) of all elements of KG of the form
  
  \[
       \sum_{h \in H} x_h(h-1)
  \]
  
  is the left ideal in KG generated by all elements h-1 with h in H. The right
  ideal  J_r(H) is defined analogously. These operations are used to consrtuct
  such  ideals,  taking  into  account  the  fact,  that  the  ideal J_l(H) is
  two-sided  if  and  only  if  H  is  normal in G. An attempt of constructing
  two-sided ideal for a non-normal subgroup H will lead to an error message.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF(2), DihedralGroup(16) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> G := DihedralGroup(16);
    <pc group of size 16 with 4 generators>
    gap> KG := GroupRing( GF(2), G );
    <algebra-with-one over GF(2), with 4 generators>
    gap> D := DerivedSubgroup( G );
    Group([ f3, f4 ])
    gap> LeftIdealBySubgroup( KG, D );
    <two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
      (dimension 12)>                              
    gap> H := Subgroup( G, [ GeneratorsOfGroup(G)[1] ]);
    Group([ f1 ])
    gap> IsNormal( G, H );
    false
    gap> LeftIdealBySubgroup( KG, H );
    <left ideal in <algebra-with-one over GF(2), with 4 generators>,
      (dimension 8)>
    
  ------------------------------------------------------------------
  
  
  4.4 Computations with the unit group
  
  4.4-1 NormalizedUnitGroup
  
  > NormalizedUnitGroup( KG ) _______________________________________attribute
  Returns:  a group generated by group algebra elements
  
  Determines  the  normalized  unit group of a p-modular group algebra KG over
  the  field  of  p  elements.  Returns the normalized unit group as the group
  generated by certain elements of KG; see Section 3.3 for more details.
  
  For    efficient    computations    the   user   is   recommended   to   use
  PcNormalizedUnitGroup (4.4-2).
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> V := NormalizedUnitGroup( KG );
    <group of size 32768 with 15 generators>
    gap> u := GeneratorsOfGroup( V )[4];
    (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2  
    
  ------------------------------------------------------------------
  
  4.4-2 PcNormalizedUnitGroup
  
  > PcNormalizedUnitGroup( KG ) _____________________________________attribute
  Returns:  a group given by power-commutator presentation
  
  The  argument  KG is a p-modular group algebra over the field of p elements.
  PcNormalizedUnitGroup  returns  the  normalized  unit group of KG given by a
  power-commutator   presentation.   The   generators   in   this   polycyclic
  presentation  correspond  to  the  weighted  basis  elements of KG. For more
  details, see Section 3.3.
  
  ---------------------------  Example  ----------------------------
    
    gap> W := PcNormalizedUnitGroup( KG );
    <pc group of size 32768 with 15 generators>
    gap> w := GeneratorsOfGroup( W )[4];
    f4       
    
  ------------------------------------------------------------------
  
  4.4-3 NaturalBijectionToPcNormalizedUnitGroup
  
  > NaturalBijectionToPcNormalizedUnitGroup( KG ) ___________________attribute
  Returns:  a homomorphism of groups
  
  The  normalised unit group of a p-modular group algebra KG over the field of
  p  elements  can  be  computed using two methods, namely NormalizedUnitGroup
  (4.4-1)  and  PcNormalizedUnitGroup  (4.4-2).  These  two methods return two
  different objects, and they can be used for different types of computations.
  The  elements  of  NormalizedUnitGroup(KG)  are represented in their natural
  group algebra representation, and hence they can easily be identified in the
  group algebra. However, the more quickly constructed NormalizedUnitGroup(KG)
  is  often not suitable for further fast calculations. Hence one will have to
  use  PcNormalizedUnitGroup(KG)  if  one  wants  to find some group theoretic
  properties  of  the normalized unit group. This method returns the bijection
  from  NormalizedUnitGroup(KG) onto PcNormalizedUnitGroup(KG). This bijection
  can  be used to map the result of a computation in PcNormalizedUnitGroup(KG)
  into NormalizedUnitGroup(KG).
  
  ---------------------------  Example  ----------------------------
    
    gap> f := NaturalBijectionToPcNormalizedUnitGroup( KG );
    MappingByFunction( <group of size 32768 with
    15 generators>, <pc group of size 32768 with
    15 generators>, function( x ) ... end )
    gap> u := GeneratorsOfGroup( V )[4];;
    gap> u^f;
    f4   
    gap> GeneratorsOfGroup( V )[4]^f = GeneratorsOfGroup( W )[4];
    true      
    
  ------------------------------------------------------------------
  
  4.4-4 NaturalBijectionToNormalizedUnitGroup
  
  > NaturalBijectionToNormalizedUnitGroup( KG ) _____________________attribute
  Returns:  a homomorphism of groups
  
  For  a p-modular group algebra KG over the field of p elements this function
  returns  the  inverse of the mapping NaturalBijectionToPcNormalizedUnitGroup
  (4.4-3)
  
  ---------------------------  Example  ----------------------------
    
    gap> t := NaturalBijectionToNormalizedUnitGroup(KG);;
    gap> w := GeneratorsOfGroup(W)[4];;
    gap> w^t;
    (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2    
    gap> GeneratorsOfGroup( W )[4]^t = GeneratorsOfGroup( V )[4];
    true     
    
  ------------------------------------------------------------------
  
  4.4-5 Embedding
  
  > Embedding( H, V ) _______________________________________________operation
  Returns:  a homomorphism from an underlying group to a normalized unit group
            in pc-presentation
  
  Let  H  be a subgroup of a group G and V be the normalized unit group of the
  group   algebra   KG   given   by  the  power-commutator  presentation  (see
  PcNormalizedUnitGroup   (4.4-2).   Then   Embedding(  H,  V  )  returns  the
  homomorphism from H to V, which is the composition of Embedding( H, KG ) and
  NaturalBijectionToPcNormalizedUnitGroup( KG ).
  
  ---------------------------  Example  ----------------------------
    
    gap> G := DihedralGroup( 16 );
    <pc group of size 16 with 4 generators>
    gap> KG := GroupRing( GF( 2 ), G );
    <algebra-with-one over GF(2), with 4 generators>
    gap> V:=PcNormalizedUnitGroup( KG );
    <pc group of size 32768 with 15 generators>
    gap> ucs := UpperCentralSeries( V );
    [ <pc group of size 32768 with 15 generators>,
      <pc group of size 4096 with 12 generators>,
      Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15, f12,
          f9*f12, f10 ]),
      Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15 ]),
      Group([  ]) ]
    gap> f := Embedding( G, V );
    [ f1, f2, f3, f4 ] -> [ f2, f1, f3, f7 ]
    gap> G1 := Image( f, G ); 
    Group([ f2, f1, f3, f7 ])
    gap> H := Intersection( ucs[2], G1 ); 
    Group([ f3, f7, f3*f7 ])
    # H is the intersection of G and the 3rd centre of V(KG)
    gap> T:=PreImage( f, H );
    Group([ f3, f4, f3*f4 ])
    # and T is its preimage in G
    gap> IdGroup( T ); 
    [ 4, 1 ]
    
  ------------------------------------------------------------------
  
  4.4-6 Units
  
  > Units( KG ) _____________________________________________________attribute
  Returns:  the unit group of a group ring
  
  This  improves  a  standard  GAP functionality for modular group algebras of
  finite  p-groups  over the field of p elements. It returns the unit group of
  KG  as  a  direct product of Units(K) and NormalizedUnitGroup(KG), where the
  latter  is  generated  by  certain  elements  of KG; see Chapter 3. for more
  details.
  
  ---------------------------  Example  ----------------------------
    
    gap> U := Units( KG );
    #I  LAGUNA package: Computing the unit group ...
    <group of size 32768 with 15 generators>
    # now elements of U are already in KG
    gap> GeneratorsOfGroup( U )[5];
    (Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3 
    # in the next example the direct product structure is more clear 
    gap> FH := GroupRing( GF(3), SmallGroup(27,3) );
    <algebra-with-one over GF(3), with 3 generators>
    gap> T := Units( FH );
    #I  LAGUNA package: Computing the unit group ...
    <group of size 5083731656658 with 27 generators>
    gap> x := GeneratorsOfGroup( T )[1];
    Tuple( [ Z(3), (Z(3)^0)*<identity> of ... ] ) 
    gap> x in FH;
    false
    gap> x[1] * x[2] in FH; 
    true # this is the way to get the corresponding element of FH
    
  ------------------------------------------------------------------
  
  4.4-7 PcUnits
  
  > PcUnits( KG ) ___________________________________________________attribute
  Returns:  a group given by power-commutator presentation
  
  Returns  the  unit  group  of  KG  as  a  direct  product  of  Units(K)  and
  PcNormalizedUnitGroup(KG), where the latter is a group given by a polycyclic
  presentation. See Section 3.4 for more details.
  
  ---------------------------  Example  ----------------------------
    
    gap> W := PcUnits( KG );
    <pc group of size 32768 with 15 generators>
    gap> GeneratorsOfGroup( W )[5];
    f5   
    # in the next example the direct product structure is more clear 
    gap> FH := GroupRing( GF(3), SmallGroup(27,3) );
    <algebra-with-one over GF(3), with 3 generators>
    gap> T := PcUnits(FH);
    <group of size 5083731656658 with 27 generators>
    gap> x := GeneratorsOfGroup( T )[2];
    Tuple( [ Z(3)^0, f1 ] )                       
    
  ------------------------------------------------------------------
  
  4.4-8 IsGroupOfUnitsOfMagmaRing
  
  > IsGroupOfUnitsOfMagmaRing( U ) ___________________________________property
  
  This  property  will be automatically set true, if U is a group generated by
  some units of a magma ring, including Units(KG) and NormalizedUnitgroup(KG).
  Otherwise this property will not be bound.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsGroupOfUnitsOfMagmaRing( NormalizedUnitGroup( KG ) );
    true
    gap> IsGroupOfUnitsOfMagmaRing( Units( KG ) );
    true     
    
  ------------------------------------------------------------------
  
  4.4-9 IsUnitGroupOfGroupRing
  
  > IsUnitGroupOfGroupRing( U ) ______________________________________property
  
  This  property  will  be automatically set true, if U is the unit group of a
  p-modular  group  algebra,  obtained  either by Units(KG) or by PcUnits(KG).
  Otherwise this property will not be bound.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsUnitGroupOfGroupRing( Units( KG ) );
    true
    gap> IsUnitGroupOfGroupRing( PcUnits( KG ) );
    true     
    
  ------------------------------------------------------------------
  
  4.4-10 IsNormalizedUnitGroupOfGroupRing
  
  > IsNormalizedUnitGroupOfGroupRing( U ) ____________________________property
  
  This  property  will  be automatically set true, if U is the normalized unit
  group    of    a    p-modular    group    algebra,    obtained   either   by
  NormalizedUnitGroup(KG)  or  by  PcNormalizedUnitGroup(KG).  Otherwise  this
  property will not be bound.
  
  ---------------------------  Example  ----------------------------
    
    gap> IsNormalizedUnitGroupOfGroupRing( NormalizedUnitGroup( KG ) );
    true
    gap> IsNormalizedUnitGroupOfGroupRing( PcNormalizedUnitGroup( KG ) );
    true     
    
  ------------------------------------------------------------------
  
  4.4-11 UnderlyingGroupRing
  
  > UnderlyingGroupRing( U ) ________________________________________attribute
  Returns:  a group ring
  
  If U is the (normalized) unit group of a p-modular group algebra KG obtained
  using  one  of the functions Units(KG), PcUnits(KG), NormalizedUnitGroup(KG)
  or  PcNormalizedUnitGroup(KG), then the attribute UnderlyingGroupRing stores
  KG.
  
  ---------------------------  Example  ----------------------------
    
    gap> UnderlyingGroupRing( Units( KG ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> UnderlyingGroupRing( PcUnits( KG ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> UnderlyingGroupRing( NormalizedUnitGroup( KG ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> UnderlyingGroupRing( PcNormalizedUnitGroup( KG ) );
    <algebra-with-one over GF(2), with 4 generators>
    
  ------------------------------------------------------------------
  
  4.4-12 UnitarySubgroup
  
  > UnitarySubgroup( U ) ____________________________________________attribute
  Returns:  the subgroup of the unit group
  
  Let  U  be  the normalized unit group of a group ring in either natural (see
  NormalizedUnitGroup  (4.4-1)) or power-commutator (see PcNormalizedUnitGroup
  (4.4-2))  presentation.  The  attribute  stores  the  unitary subgroup of U,
  generated  by  all unitary units of U (see IsUnitary (4.2-9)). The method is
  straightforward, so it is not recommended to run it for large groups.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
    <algebra-with-one over GF(2), with 3 generators>
    gap> U := NormalizedUnitGroup( KG );
    <group of size 128 with 7 generators>
    gap> HU := UnitarySubgroup( U );
    <group with 5 generators>
    gap> IdGroup( HU );
    [ 64, 261 ]
    gap> V := PcNormalizedUnitGroup( KG );
    <pc group of size 128 with 7 generators>
    gap> HV := UnitarySubgroup( V );
    Group([ f1, f2, f5, f6, f7 ])
    gap> IdGroup( HV );
    [ 64, 261 ]
    gap> Image(NaturalBijectionToPcNormalizedUnitGroup( KG ), HU ) = HV;
    true
    
  ------------------------------------------------------------------
  
  4.4-13 BicyclicUnitGroup
  
  > BicyclicUnitGroup( U ) __________________________________________attribute
  Returns:  the subgroup of the unit group, generated by bicyclic units
  
  Let  U  be  the normalized unit group of a group ring in either natural (see
  NormalizedUnitGroup  (4.4-1)) or power-commutator (see PcNormalizedUnitGroup
  (4.4-2))  presentation. The attribute stores the subgroup of U, generated by
  all  bicyclic  units  u_g,h  and v_g,h (see BicyclicUnitOfType1 (4.2-12) and
  BicyclicUnitOfType1  (4.2-12)),  where  g and h run over the elements of the
  underlying group, and h do not belongs to the normalizer of < g > in G.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
    <algebra-with-one over GF(2), with 3 generators>
    gap> U := NormalizedUnitGroup( KG );
    <group of size 128 with 7 generators>
    gap> BU := BicyclicUnitGroup( U );
    <group with 2 generators>
    gap> IdGroup( BU );
    [ 4, 2 ]
    gap> V := PcNormalizedUnitGroup( KG );
    <pc group of size 128 with 7 generators>
    gap> BV := BicyclicUnitGroup( V );
    Group([ f5*f6, f6*f7 ])
    gap> IdGroup( BV );
    [ 4, 2 ]
    gap> Image( NaturalBijectionToPcNormalizedUnitGroup( KG ), BU ) = BV;
    true
    
  ------------------------------------------------------------------
  
  4.4-14 AugmentationIdealPowerFactorGroup
  
  > AugmentationIdealPowerFactorGroup( KG, n ) ______________________operation
  Returns:  PcGroup
  
  ????????????????????????????????????????
  
  ---------------------------  Example  ----------------------------
    
    
  ------------------------------------------------------------------
  
  4.4-15 GroupBases
  
  > GroupBases( KG ) ________________________________________________attribute
  Returns:  a list of lists of group rings elements
  
  The  subgroup  B  of  the  normalized  unit group of the group algebra KG is
  called a group basis, if the elements of B are linearly independent over the
  field  K  and  KB=KG.  If  KG  is a p-modular group algebra, then GroupBases
  returns  a  list  of  representatives  of the conjugacy classes of the group
  bases of the group algebra KG in its normalised unit group.
  
  ---------------------------  Example  ----------------------------
    
    gap> D8 := DihedralGroup( 8 );
    <pc group of size 8 with 3 generators>
    gap> K := GF(2);
    GF(2)
    gap> KD8 := GroupRing( GF( 2 ), D8 );
    <algebra-with-one over GF(2), with 3 generators>
    gap> gb := GroupBases( KD8 );;
    gap> Length( gb );
    32
    gap> gb[1];
    [ (Z(2)^0)*<identity> of ..., (Z(2)^0)*f3,
      (Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3+(Z(2)^0)*f1*f2*f3,
      (Z(2)^0)*f2+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f2*f3,
      (Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3+(Z(2)^
        0)*f1*f2*f3, (Z(2)^0)*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f2*f3,
      (Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^
        0)*f2*f3, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f2*f3 ]
    gap> Length( last );
    8    
    
  ------------------------------------------------------------------
  
  
  4.5 The Lie algebra of a group algebra
  
  4.5-1 LieAlgebraByDomain
  
  > LieAlgebraByDomain( A ) ____________________________________________method
  
  This  method  takes  a  group  algebra  as  its argument, and constructs its
  associated  Lie  algebra  in  which  the  product  is the bracket operation:
  [a,b]=ab-ba.  It  is  recommended that the user never calls this method. The
  Lie  algebra  for  an  associative  algebra should normally be created using
  LieAlgebra(  A  ).  When  LieAlgebra is first invoked, it constructs the Lie
  algebra  for  A  using  LieAlgebraByDomain.  After  that  it stores this Lie
  algebra and simply returns it if LieAlgebra is called again.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup(3);; FG := GroupRing( GF( 2 ), G );
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    
  ------------------------------------------------------------------
  
  4.5-2 IsLieAlgebraByAssociativeAlgebra
  
  > IsLieAlgebraByAssociativeAlgebra( L ) ____________________________Category
  
  This  category  signifies  that the Lie algebra L was constructed as the Lie
  algebra  associated  with  an associative algebra (this piece of information
  cannot be obtained later).
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF(3), DihedralGroup(16) );
    <algebra-with-one over GF(3), with 4 generators>
    gap> L := LieAlgebra ( KG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(3)>
    gap> IsLieAlgebraByAssociativeAlgebra( L );
    true
    
  ------------------------------------------------------------------
  
  4.5-3 UnderlyingAssociativeAlgebra
  
  > UnderlyingAssociativeAlgebra( L ) _______________________________attribute
  Returns:  the underlying associative algebra of a Lie algebra
  
  If  a  Lie  algebra  L  is  constructed from an associative algebra, then it
  remembers this underlying associative algebra as one of its attributes.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF(2), DihedralGroup(16) ); 
    <algebra-with-one over GF(2), with 4 generators>
    gap> L := LieAlgebra ( KG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> UnderlyingAssociativeAlgebra( L );
    <algebra-with-one over GF(2), with 4 generators>
    gap> last = KG;
    true  
    
  ------------------------------------------------------------------
  
  4.5-4 NaturalBijectionToLieAlgebra
  
  > NaturalBijectionToLieAlgebra( A ) _______________________________attribute
  Returns:  a mapping
  
  The  natural  linear  bijection  between  the  (isomorphic,  but  not equal)
  underlying  vector spaces of an associative algebra A and its associated Lie
  algebra  is  stored  as  an attribute of A. Note that this is a vector space
  isomorphism between two algebras, but not an algebra isomorphism.
  
  ---------------------------  Example  ----------------------------
    
    gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
    GF(2)
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> t := NaturalBijectionToLieAlgebra( FG ); 
    MappingByFunction( <algebra-with-one over GF(2), with 
    2 generators>, <Lie algebra over GF(
    2)>, <Operation "LieObject">, function( y ) ... end )
    gap> a := Random( FG );
    (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3)
    gap> a * a;                     # product in the associative algebra
    (Z(2)^0)*()+(Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)
    gap> b := a^t;
    LieObject( (Z(2)^0)*(1,2,3)+(Z(2)^0)*(1,3,2)+(Z(2)^0)*(1,3) )
    gap> b * b;                     # product in the Lie algebra (commutator) ...
    LieObject( <zero> of ... )      # ... must be zero!   
    
  ------------------------------------------------------------------
  
  4.5-5 NaturalBijectionToAssociativeAlgebra
  
  > NaturalBijectionToAssociativeAlgebra( L ) _______________________attribute
  
  This is the inverse of the previous linear bijection, stored as an attribute
  of the Lie algebra L.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup(3); FG := GroupRing( GF( 2 ), G );
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> s := NaturalBijectionToAssociativeAlgebra( L );
    MappingByFunction( <Lie algebra over GF(2)>, <algebra-with-one over GF(
    2), with 2 generators>, function( y ) ... end, <Operation "LieObject"> )
    gap> InverseGeneralMapping( s ) = NaturalBijectionToLieAlgebra( FG );
    true   
    
  ------------------------------------------------------------------
  
  4.5-6 IsLieAlgebraOfGroupRing
  
  > IsLieAlgebraOfGroupRing( L ) _____________________________________property
  
  If  a Lie algebra L is constructed from an associative algebra which happens
  to be in fact a group ring, it has many nice properties that can be used for
  fast algorithms, so this information is stored as a property.
  
  ---------------------------  Example  ----------------------------
    
    gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
    GF(2)
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsLieAlgebraOfGroupRing( L );
    true   
    
  ------------------------------------------------------------------
  
  4.5-7 UnderlyingGroup
  
  > UnderlyingGroup( L ) ____________________________________________attribute
  Returns:  the underlying group
  
  The  underlying  group  of  a Lie algebra L that is constructed from a group
  ring   is   defined  as  the  underlying  group  of  this  group  ring;  see
  UnderlyingGroup (4.1-4).
  
  ---------------------------  Example  ----------------------------
    
    gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
    GF(2)
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> UnderlyingGroup( L );
    Sym( [ 1 .. 3 ] )
    gap> LeftActingDomain( L );
    GF(2)   
    
  ------------------------------------------------------------------
  
  4.5-8 Embedding
  
  > Embedding( U, L ) _______________________________________________operation
  Returns:  a mapping, which is a composition of two mappings
  
  Let  FG  be  a  group  ring,  let U be a submagma of G, and let L be the Lie
  algebra  associated  with  FG.  Then  Embedding(U,  L  ) returns the obvious
  mapping  from  U to L (as the composition of the mappings Embedding( U, FG )
  and NaturalBijectionToLieAlgebra( FG )).
  
  ---------------------------  Example  ----------------------------
    
    gap> F := GF( 2 ); G := SymmetricGroup( 3 ); FG := GroupRing( F, G );
    GF(2)
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> f := Embedding( G, L );
    CompositionMapping( MappingByFunction( <algebra-with-one over GF(2), with 
    2 generators>, <Lie algebra over GF(
    2)>, <Operation "LieObject">, function( y ) ... end ), <mapping: SymmetricGrou\
    p( [ 1 .. 3 ] ) -> AlgebraWithOne( GF(2), ... ) > )
    gap> (1,2)^f + (1,3)^f;
    LieObject( (Z(2)^0)*(1,2)+(Z(2)^0)*(1,3) )   
    
  ------------------------------------------------------------------
  
  4.5-9 LieCentre
  
  > LieCentre( L ) _____________________________________________________method
  Returns:  a Lie algebra
  
  The  centre  of  the Lie algebra associated with a group ring corresponds to
  the  centre of the underlying group ring, and it can be calculated very fast
  by  considering  the conjugacy classes of the group. This method returns the
  centre of L using this idea.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 256 with 8 generators>
    <algebra-with-one over GF(2), with 8 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> C := LieCentre( L );
    <Lie algebra of dimension 28 over GF(2)>
    gap> D := LieDerivedSubalgebra( L );
    #I  LAGUNA package: Computing the Lie derived subalgebra ...
    <Lie algebra of dimension 228 over GF(2)>
    gap> c := Dimension( C ); d := Dimension( D ); l := Dimension( L );
    28
    228
    256
    gap> c + d = l;
    true  # This is always the case for Lie algebras of group algebras!   
    
  ------------------------------------------------------------------
  
  4.5-10 LieDerivedSubalgebra
  
  > LieDerivedSubalgebra( L ) __________________________________________method
  Returns:  a Lie algebra
  
  If  L  is  the  Lie  algebra  associated with a group ring, then this method
  returns  the  Lie  derived subalgebra of L. This can be done very fast using
  the conjugacy classes of the underlying group.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 256 with 8 generators>
    <algebra-with-one over GF(2), with 8 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> C := LieCentre( L );
    <Lie algebra of dimension 28 over GF(2)>
    gap> D := LieDerivedSubalgebra( L );
    #I  LAGUNA package: Computing the Lie derived subalgebra ...    
    <Lie algebra of dimension 228 over GF(2)>
    gap> l := Dimension( L ); c := Dimension( C ); d := Dimension( D );
    256
    28
    228
    gap> c + d = l;
    true  # This is always the case for Lie algebras of group algebras!   
    
  ------------------------------------------------------------------
  
  4.5-11 IsLieAbelian
  
  > IsLieAbelian( L ) __________________________________________________method
  
  The Lie algebra L of an associative algebra A is Lie abelian, if and only if
  A is abelian, so this method refers to IsAbelian( A ).
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G); 
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );          
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsAbelian( G );
    false
    gap> IsAbelian( L );    # This command should never be used for Lie algebras!
    true                    # It gives a result, but (probably) not the desired one.
    gap> IsLieAbelian( L ); # Instead, IsLieAbelian is the correct command.
    false   
    
  ------------------------------------------------------------------
  
  4.5-12 IsLieSolvable
  
  > IsLieSolvable( L ) _________________________________________________method
  
  In [PPS73] Passi, Passman, and Sehgal have classified all groups G such that
  the Lie algebra associated with the group ring is solvable. This method uses
  their classification, making it considerably faster than the more elementary
  method which just calculates Lie commutators.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 256 with 8 generators>
    <algebra-with-one over GF(2), with 8 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsLieSolvable( L );                       # This is very fast.
    true
    gap> List( LieDerivedSeries( L ), Dimension ); # This is very slow.
    [ 256, 228, 189, 71, 0 ]   
    
  ------------------------------------------------------------------
  
  4.5-13 IsLieNilpotent
  
  > IsLieNilpotent( L ) ________________________________________________method
  
  In [PPS73] Passi, Passman, and Sehgal have classified all groups G such that
  the Lie algebra associated with the group ring is Lie nilpotent. This method
  uses  their  classification,  making  it  considerably  faster than the more
  elementary method which just calculates Lie commutators.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 256 with 8 generators>
    <algebra-with-one over GF(2), with 8 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsLieNilpotent( L );                           # This is very fast.
    true
    gap> List( LieLowerCentralSeries( L ), Dimension ); # This is very slow.
    [ 256, 228, 222, 210, 191, 167, 138, 107, 76, 54, 29, 15, 6, 0 ]   
    
  ------------------------------------------------------------------
  
  4.5-14 IsLieMetabelian
  
  > IsLieMetabelian( L ) _____________________________________________property
  
  In  [LR86]  Levin and Rosenberger have classified all groups G such that the
  Lie  algebra  associated  with the group ring is Lie metabelian. This method
  uses  their  classification,  making  it  considerably  faster than the more
  elementary method which just calculates Lie commutators.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SmallGroup( 256, 400 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 256 with 8 generators>
    <algebra-with-one over GF(2), with 8 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsLieMetabelian( L );
    false   
    
  ------------------------------------------------------------------
  
  4.5-15 IsLieCentreByMetabelian
  
  > IsLieCentreByMetabelian( L ) _____________________________________property
  
  In  [R02] the third author of this package classified all groups G such that
  the  Lie algebra associated with the group ring is Lie centre-by-metabelian.
  This  method uses the classification, making it considerably faster than the
  more elementary method which just calculates Lie commutators.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G ); 
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );       
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> IsLieMetabelian( L );                                             
    false
    gap> IsLieCentreByMetabelian( L );
    true   
    
  ------------------------------------------------------------------
  
  4.5-16 CanonicalBasis
  
  > CanonicalBasis( L ) ________________________________________________method
  Returns:  basis of a Lie algebra
  
  The  canonical  basis  of a group algebra FG is formed by the elements of G.
  Here  L  is  the  Lie algebra associated with FG, and the method returns the
  images of the elements of G in L.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G ); 
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );       
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> B := CanonicalBasis( L );
    CanonicalBasis( <Lie algebra of dimension 6 over GF(2)> )
    gap> Elements( B );
    [ LieObject( (Z(2)^0)*() ), LieObject( (Z(2)^0)*(2,3) ),
      LieObject( (Z(2)^0)*(1,2) ), LieObject( (Z(2)^0)*(1,2,3) ),
      LieObject( (Z(2)^0)*(1,3,2) ), LieObject( (Z(2)^0)*(1,3) ) ]
    
  ------------------------------------------------------------------
  
  4.5-17 IsBasisOfLieAlgebraOfGroupRing
  
  > IsBasisOfLieAlgebraOfGroupRing( B ) ______________________________property
  
  A  basis  B  has  this property if the preimages of the basis vectors in the
  group algebra form a group. It can be verified if a basis has this property.
  This  is  important  for  the  speed  of  the  calculation  of the structure
  constants table; see StructureConstantsTable (4.5-18).
  
  ---------------------------  Example  ----------------------------
    
    gap> G := SymmetricGroup( 3 ); FG := GroupRing( GF( 2 ), G ); 
    Sym( [ 1 .. 3 ] )
    <algebra-with-one over GF(2), with 2 generators>
    gap> L := LieAlgebra( FG );    
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> B := CanonicalBasis( L );
    CanonicalBasis( <Lie algebra of dimension 6 over GF(2)> )
    gap> IsBasisOfLieAlgebraOfGroupRing( B );
    true   
    
  ------------------------------------------------------------------
  
  4.5-18 StructureConstantsTable
  
  > StructureConstantsTable( B ) _______________________________________method
  
  A very fast implementation for calculating the structure constants table for
  the Lie algebra L associated with a group ring with respect to its canonical
  basis B using its special structure; see CanonicalBasis (4.5-16).
  
  ---------------------------  Example  ----------------------------
    
    gap> G := CyclicGroup( 2 ); FG := GroupRing( GF( 2 ), G ); 
    <pc group of size 2 with 1 generators>
    <algebra-with-one over GF(2), with 1 generators>
    gap> L := LieAlgebra( FG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> B := CanonicalBasis( L );
    CanonicalBasis( <Lie algebra of dimension 2 over GF(2)> )
    gap> StructureConstantsTable( B );       
    [ [ [ [  ], [  ] ], [ [  ], [  ] ] ], [ [ [  ], [  ] ], [ [  ], [  ] ] ], -1, 
      0*Z(2) ]  
    
  ------------------------------------------------------------------
  
  4.5-19 LieUpperNilpotencyIndex
  
  > LieUpperNilpotencyIndex( KG ) ___________________________________attribute
  
  In  a  modular  group  algebra  KG  the upper Lie power series is defined as
  follows:   KG^(1)=KG,  KG^(n+1)  is  the  associative  ideal,  generated  by
  [KG^(n),KG].  The  upper Lie nilpotency index t^L(G) of the group algebra KG
  is  defined  to  be  the  smallest  number  n  such that KG^(n)=0. It can be
  calculated  very  fast  using  Lie dimension subgroups [S91], that is, using
  only  information  about  the  underlying  group;  see LieDimensionSubgroups
  (4.6-4).  This  is  why it is stored as an attribute of the group algebra KG
  rather than that of its associated Lie algebra.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> LieUpperNilpotencyIndex( KG );
    5      
    
  ------------------------------------------------------------------
  
  4.5-20 LieLowerNilpotencyIndex
  
  > LieLowerNilpotencyIndex( KG ) ___________________________________attribute
  
  In  a  modular  group  algebra  KG  the lower Lie power series is defined as
  follows:  KG^[n]  is  the  associative ideal, generated by all (left-normed)
  Lie-products  [x_1,  x_2,  dots,  x_n],  x_i in KG. The lower Lie nilpotency
  index t_L(G) of the group algebra KG is defined to be the minimal smallest n
  such  that  KG^[n]=0.  In  [D92]  the Jennings' conjecture was proved, which
  means  that the nilpotency class of the normalized unit group of the modular
  group algebra KG is equal to t_L(G)-1.
  
  This  allows  to express lower Lie nilpotency index via the nilpotency class
  of the normalized unit group, and with its polycyclic presentation, provided
  by  LAGUNA,  this  will  be  faster  than  elementary  calculations with Lie
  commutators.  As  the  previous  attribute,  this index is also stored as an
  attribute of the group algebra KG.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF( 2 ), DihedralGroup( 16 ) );
    <algebra-with-one over GF(2), with 4 generators>
    gap> LieLowerNilpotencyIndex( KG );
    5     
    
  ------------------------------------------------------------------
  
  4.5-21 LieDerivedLength
  
  > LieDerivedLength( L ) ___________________________________________attribute
  
  Let  L  be a Lie algebra. The Lie derived series of L is defined as follows:
  delta^[0](L)  =  L and delta^[n](L) = [delta^[n-1](L), delta^[n-1](L)]. L is
  called Lie solvable if there exists an integer m such that delta^[m](L) = 0.
  In  this case the integer m is called the Lie derived length of L, and it is
  returned by this function.
  
  ---------------------------  Example  ----------------------------
    
    gap> KG := GroupRing( GF ( 2 ), DihedralGroup( 16 ) );;
    gap> L := LieAlgebra( KG );
    #I  LAGUNA package: Constructing Lie algebra ...
    <Lie algebra over GF(2)>
    gap> LieDerivedLength( L );
    #I  LAGUNA package: Computing the Lie derived subalgebra ...
    3                                                            
    
  ------------------------------------------------------------------
  
  
  4.6 Other commands
  
  4.6-1 SubgroupsOfIndexTwo
  
  > SubgroupsOfIndexTwo( G ) ________________________________________attribute
  
  Returns  a  list  of  subgroups  of  G  with  index  two. Such subgroups are
  important for the investigation of the Lie structure of the group algebra KG
  in the case of characteristic 2.
  
  ---------------------------  Example  ----------------------------
    
    gap> SubgroupsOfIndexTwo( DihedralGroup( 16) );
    [ Group([ f1, f1*f3, f1*f4, f1*f3*f4 ]), Group([ f2, f2*f3, f2*f4, f2*f3*f4 ]),
      Group([ f1*f2, f1*f2*f3, f1*f2*f4, f1*f2*f3*f4 ]) ]     
    
  ------------------------------------------------------------------
  
  4.6-2 DihedralDepth
  
  > DihedralDepth( U ) _________________________________________________method
  
  For  a  finite  2-group U, the function returns its dihedral depth, which is
  defined  to  be  the  maximal  number  d  such  that  U  contains a subgroup
  isomorphic to the dihedral group of order 2^d+1.
  
  ---------------------------  Example  ----------------------------
    
    gap> KD8 := GroupRing( GF(2), DihedralGroup( 8 ) );
    <algebra-with-one over GF(2), with 3 generators>
    gap> UD8 := PcNormalizedUnitGroup( KD8 );
    <pc group of size 128 with 7 generators>
    gap> DihedralDepth( UD8 );
    2      
    
  ------------------------------------------------------------------
  
  4.6-3 DimensionBasis
  
  > DimensionBasis( G ) ________________________________________________method
  Returns:  record  with  two  components:  `dimensionBasis'  (list  of  group
            elements) and `weights' (list of weights)
  
  For  a  finite  p-group G, returns its Jennings basis as it was described in
  Section 3.3.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := DihedralGroup( 16 );
    <pc group of size 16 with 4 generators>  
    gap> DimensionBasis( G );
    rec( dimensionBasis := [ f1, f2, f3, f4 ], weights := [ 1, 1, 2, 4 ] )    
    
  ------------------------------------------------------------------
  
  4.6-4 LieDimensionSubgroups
  
  > LieDimensionSubgroups( G ) ______________________________________attribute
  Returns:  list of subgroups
  
  For  a  finite p-group G, returns the series of its Lie dimension subgroups.
  The m-th Lie dimension subgroup D_(m) is the intersection of the group G and
  1+KG^(m), where KG^(m) is the m-th term of the upper Lie power series of KG;
  see LieUpperNilpotencyIndex (4.5-19)
  
  ---------------------------  Example  ----------------------------
    
    gap> G := DihedralGroup( 16 );
    <pc group of size 16 with 4 generators>  
    gap> LieDimensionSubgroups( G );
    [ <pc group of size 16 with 4 generators>, Group([ f3, f4 ]), Group([ f4 ]),
      Group([ <identity> of ... ]) ]     
    
  ------------------------------------------------------------------
  
  4.6-5 LieUpperCodimensionSeries
  
  > LieUpperCodimensionSeries( KG ) _________________________________attribute
  > LieUpperCodimensionSeries( G ) __________________________________attribute
  Returns:  list of subgroups
  
  A  notion of upper Lie codimension subgroups was introduced in [CS06]. For a
  finite  p-group  G, C_i is the set of all elements g in G, such that the Lie
  commutator  [  g, g_1, ..., g_i ] of the length i+1 is equal to zero for all
  g_1,  ...,  g_i  from  G,  and  C_0  =  1.  By Du's theorem (see [D92]), C_i
  coincides  with the intersection of G and the i-th term of the upper central
  series  1=Z_0  <  Z_1 < Z_2 < ... < Z_n = V(KG) of the normalized unit group
  V(KG).  This  fact is used in LAGUNA to speed up computation of this series.
  Since  V(KG)  is  involved  in  computation, for the first time the argiment
  should  be the group ring KG, but later you can also apply it to the group G
  itself.
  
  ---------------------------  Example  ----------------------------
    
    gap> G := DihedralGroup(16);
    <pc group of size 16 with 4 generators>
    gap> KG := GroupRing( GF(2), G );
    <algebra-with-one over GF(2), with 4 generators>
    gap> LieUpperCodimensionSeries( KG );
    [ Group([ f1, f2, f3, f4 ]), Group([ f3, f4, f3*f4 ]), Group([ f4 ]), 
      Group([ f4 ]), Group([  ]) ]
    gap> LieUpperCodimensionSeries( G );
    [ Group([ f1, f2, f3, f4 ]), Group([ f3, f4, f3*f4 ]), Group([ f4 ]), 
      Group([ f4 ]), Group([  ]) ]
    
  ------------------------------------------------------------------
  
  4.6-6 LAGInfo
  
  > LAGInfo_________________________________________________________info class
  
  LAGInfo is a special Info class for LAGUNA algorithms. It has 5 levels: 0, 1
  (default),   2,   3   and  4.  To  change  info  level  to  k,  use  command
  SetInfoLevel(LAGInfo, k).
  
  ---------------------------  Example  ----------------------------
    
    gap> SetInfoLevel( LAGInfo, 2 );
    gap> KD8 := GroupRing( GF( 2 ), DihedralGroup( 8 ) );
    <algebra-with-one over GF(2), with 3 generators>
    gap> UD8 := PcNormalizedUnitGroup( KD8 );
    #I  LAGInfo: Computing the pc normalized unit group ...
    #I  LAGInfo: Calculating weighted basis ...
    #I  LAGInfo: Calculating dimension basis ...
    #I  LAGInfo: dimension basis finished !
    #I  LAGInfo: Weighted basis finished !
    #I  LAGInfo: Computing the augmentation ideal filtration...
    #I  LAGInfo: Filtration finished !
    #I  LAGInfo: finished, converting to PcGroup
    <pc group of size 128 with 7 generators>     
    
  ------------------------------------------------------------------
  
  4.6-7 LAGUNABuildManual
  
  > LAGUNABuildManual(  ) ____________________________________________function
  
  This  function  is  used  to build the manual in the following formats: DVI,
  PDF,  PS,  HTML  and text for online help. We recommend that the user should
  have  a  recent  and  fairly  complete  TeX  distribution.  Since  LAGUNA is
  distributed  together  with  its manual, it is not necessary for the user to
  use  this  function.  Normally  it  is intended to be used by the developers
  only.  This  is  the  only  function  of  LAGUNA  which  requires UNIX/Linux
  environment.
  
  4.6-8 LAGUNABuildManualHTML
  
  > LAGUNABuildManualHTML(  ) ________________________________________function
  
  This  fuction is used to build the manual only in HTML format. This does not
  depend  on  the availability of the TeX installation and works under Windows
  and  MacOS as well. Since LAGUNA is distributed together with its manual, it
  is  not necessary for the user to use this function. Normally it is intended
  to be used by the developers only.