3. QuaGroup
  
  In this chapter we describe the functionality provided by QuaGroup.
  
  
  3.1 Global constants
  
  3.1-1 QuantumField
  
  > QuantumField_______________________________________________global variable
  
  This is the field Q(q) of rational functions in q, over Q.
  
  ---------------------------  Example  ----------------------------
    gap> QuantumField;
    QuantumField
  ------------------------------------------------------------------
  
  3.1-2 _q
  
  > _q_________________________________________________________global variable
  
  This is an indeterminate; QuantumField is the field of rational functions in
  this  indeterminate. The identifier _q is fixed once the package QuaGroup is
  loaded.  The  symbol _q is chosen (instead of q) in order to avoid potential
  name clashes. We note that _q is printed as q.
  
  ---------------------------  Example  ----------------------------
    gap> _q;
    q
    gap> _q in QuantumField;
    true
  ------------------------------------------------------------------
  
  
  3.2 Gaussian integers
  
  3.2-1 GaussNumber
  
  > GaussNumber( n, par ) ___________________________________________operation
  
  This function computes for the integer n the Gaussian integer [n]_v=par (cf.
  Section 2.1).
  
  ---------------------------  Example  ----------------------------
    gap> GaussNumber( 4, _q );
    q^-3+q^-1+q+q^3
  ------------------------------------------------------------------
  
  3.2-2 GaussianFactorial
  
  > GaussianFactorial( n, par ) _____________________________________operation
  
  This function computes for the integer n the Gaussian factorial [n]!_v=par.
  
  ---------------------------  Example  ----------------------------
    gap> GaussianFactorial( 3, _q );
    q^-3+2*q^-1+2*q+q^3
    gap> GaussianFactorial( 3, _q^2 );
    q^-6+2*q^-2+2*q^2+q^6
  ------------------------------------------------------------------
  
  3.2-3 GaussianBinomial
  
  > GaussianBinomial( n, k, par ) ___________________________________operation
  
  This  function  computes  for  two  integers n and k the Gaussian binomial n
  choose k, where the parameter v is replaced by par.
  
  ---------------------------  Example  ----------------------------
    gap> GaussianBinomial( 5, 2, _q^2 );
    q^-12+q^-8+2*q^-4+2+2*q^4+q^8+q^12
  ------------------------------------------------------------------
  
  
  3.3 Roots and root systems
  
  In  this  section  we describe some functions for dealing with root systems.
  These functions supplement the ones already present in the GAP library.
  
  3.3-1 RootSystem
  
  > RootSystem( type, rank ) ________________________________________operation
  > RootSystem( list ) ______________________________________________operation
  
  Here  type  is  a capital letter between "A" and "G", and rank is a positive
  integer (>= 1 if type="A", >= 2 if type="B", "C", >= 4 if type="D", 6,7,8 if
  type="E",  4 if type="F", and 2 if type="G"). This function returns the root
  system  of  type  type  and  rank rank. In the second form list is a list of
  types and ranks, e.g., [ "B", 2, "F", 4, "D", 7 ].
  
  The  root  system  constructed  by  this  function  comes with he attributes
  PositiveRoots,  NegativeRoots,  SimpleSystem, CartanMatrix, BilinearFormMat.
  Here  the  attribute SimpleSystem contains a set of simple roots, written as
  unit  vectors.  PositiveRoots  is  a  list of the positive roots, written as
  linear  combinations  of  the  simple roots, and likewise for NegativeRoots.
  CartanMatrix( R ) is the Cartan matrix of the root system R, where the entry
  on  position ( i, j ) is given by < alpha_i, alpha_j^v> where alpha_i is the
  i-th  simple  root. BilinearFormMat( R ) is the matrix of the bilinear form,
  where  the  entry on position ( i, j ) is given by ( alpha_i, alpha_j ) (see
  Section 2.2).
  
  WeylGroup(  R ) returns the Weyl group of the root system R. We refer to the
  GAP reference manual for an overview of the functions for Weyl groups in the
  GAP  library.  We  mention  the  functions  ConjugateDominantWeight( W, wt )
  (returns  the  dominant  weight  in  the  W-orbit  of  the  weight  wt), and
  WeylOrbitIterator(  W,  wt ) (returns an iterator for the W-orbit containing
  the  weight  wt).  We  write  weights  as  integral  linear  combinations of
  fundamental  weights, so in GAP weights are represented by lists of integers
  (of length equal to the rank of the root system).
  
  Also  we  mention  the function PositiveRootsAsWeights( R ) that returns the
  positive  roots of R written as weights, i.e., as linear combinations of the
  fundamental weights.
  
  ---------------------------  Example  ----------------------------
    gap> R:=RootSystem( [ "B", 2, "F", 4, "E", 6 ] );
    <root system of type B2 F4 E6>
    gap> R:= RootSystem( "A", 2 );
    <root system of type A2>
    gap> PositiveRoots( R );
    [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ] ]
    gap> BilinearFormMat( R );
    [ [ 2, -1 ], [ -1, 2 ] ]
    gap> W:= WeylGroup( R );
    Group([ [ [ -1, 1 ], [ 0, 1 ] ], [ [ 1, 0 ], [ 1, -1 ] ] ])
    gap> ConjugateDominantWeight( W, [-3,2] );
    [ 2, 1 ]
    gap> o:= WeylOrbitIterator( W, [-3,2] );
    <iterator>
    # Using the iterator we can loop over the orbit:
    gap> NextIterator( o );
    [ 2, 1 ]
    gap> NextIterator( o );
    [ -1, -2 ]
    gap> PositiveRootsAsWeights( R );
    [ [ 2, -1 ], [ -1, 2 ], [ 1, 1 ] ]
  ------------------------------------------------------------------
  
  3.3-2 BilinearFormMatNF
  
  > BilinearFormMatNF( R ) __________________________________________attribute
  
  This  is  the  matrix of the "normalized" bilinear form. This means that all
  diagonal  entries  are  even,  and  2  is the minimum value occurring on the
  diagonal. If R is a root system constructed by RootSystem (3.3-1), then this
  is equal to BilinearFormMat( R ).
  
  3.3-3 PositiveRootsNF
  
  > PositiveRootsNF( R ) ____________________________________________attribute
  
  This  is  the list of positive roots of the root system R, written as linear
  combinations  of the simple roots. This means that the simple roots are unit
  vectors.  If R is a root system constructed by RootSystem (3.3-1), then this
  is equal to PositiveRoots( R ).
  
  One  of  the  reasons  for  writing  the  positive  roots  like  this is the
  following.  Let  a,  b be two elements of PositiveRootsNF( R ), and let B be
  the  matrix  of  the bilinear form. Then a*( B*b ) is the result of applying
  the bilinear form to a, b.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( SimpleLieAlgebra( "B", 2, Rationals ) );;
    gap> PositiveRootsNF( R );
    [ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ], [ 1, 2 ] ]
    # We note that in this case PositiveRoots( R ) will give the positive roots in
    # a different format.
  ------------------------------------------------------------------
  
  3.3-4 SimpleSystemNF
  
  > SimpleSystemNF( R ) _____________________________________________attribute
  
  This  is  the list of simple roots of R, written as unit vectors (this means
  that  they  are  elements  of  PositiveRootsNF(  R )). If R is a root system
  constructed by RootSystem (3.3-1), then this is equal to SimpleSystem( R ).
  
  3.3-5 PositiveRootsInConvexOrder
  
  > PositiveRootsInConvexOrder( R ) _________________________________attribute
  
  This  function  returns  the  positive  roots  of  the root system R, in the
  "convex"  order. Let w_0=s_1cdots s_t be a reduced expression of the longest
  element  in  the  Weyl  group. Then the k-th element of the list returned by
  this function is s_1cdots s_k-1(alpha_k). (Where the reduced expression used
  is  the one returned by LongestWeylWord( R ).) If alpha, beta and alpha+beta
  are  positive  roots,  then alpha+beta occurs between alpha and beta (whence
  the name convex order).
  
  In  the  output all roots are written in "normal form", i.e., as elements of
  PositiveRootsNF( R ).
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> PositiveRootsInConvexOrder( R );
    [ [ 1, 0 ], [ 3, 1 ], [ 2, 1 ], [ 3, 2 ], [ 1, 1 ], [ 0, 1 ] ]
  ------------------------------------------------------------------
  
  3.3-6 SimpleRootsAsWeights
  
  > SimpleRootsAsWeights( R ) _______________________________________attribute
  
  Returns   the  simple  roots  of  the  root  system  R,  written  as  linear
  combinations of the fundamental weights.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 2 );;
    gap> SimpleRootsAsWeights( R );
    [ [ 2, -1 ], [ -1, 2 ] ]
  ------------------------------------------------------------------
  
  
  3.4 Weyl groups and their elements
  
  Now  we  describe  a  few functions that deal with reduced words in the Weyl
  group of the root system R. These words are represented as lists of positive
  integers  i,  denoting  the i-th simple reflection (which corresponds to the
  i-th element of SimpleSystem( R )). For example [ 3, 2, 1, 3, 1 ] represents
  the expression s_3 s_2 s_1 s_3 s_1.
  
  3.4-1 ApplyWeylElement
  
  > ApplyWeylElement( W, wt, wd ) ___________________________________operation
  
  Here wd is a (not necessarily reduced) word in the Weyl group W, and wt is a
  weight  (written as integral linear combination of the simple weights). This
  function returns the result of applying wd to wt. For example, if wt=mu, and
  wd = [ 1, 2 ] then this function returns s_1s_2(mu) (where s_i is the simple
  reflection corresponding to the i-th simple root).
  
  ---------------------------  Example  ----------------------------
    gap> W:= WeylGroup( RootSystem( "G", 2 ) ) ;;
    gap> ApplyWeylElement( W, [ -3, 7 ], [ 1, 1, 2, 1, 2 ] );
    [ 15, -11 ]
  ------------------------------------------------------------------
  
  3.4-2 LengthOfWeylWord
  
  > LengthOfWeylWord( W, wd ) _______________________________________operation
  
  Here  wd  is a word in the Weyl group W. This function returns the length of
  that word.
  
  ---------------------------  Example  ----------------------------
    gap> W:= WeylGroup( RootSystem( "F", 4 ) ) ;
    <matrix group with 4 generators>
    gap> LengthOfWeylWord( W, [ 1, 3, 2, 4, 2 ] );
    3
  ------------------------------------------------------------------
  
  3.4-3 LongestWeylWord
  
  > LongestWeylWord( R ) ____________________________________________attribute
  
  Here  R  is  a root system. LongestWeylWord( R ) returns the longest word in
  the Weyl group of R.
  
  If this function is called for a root system R, a reduced expression for the
  longest  element  in  the  Weyl  group  is  calculated (the one which is the
  smallest  in  the  lexicographical  ordering). However, if you would like to
  work  with  a different reduced expression, then it is possible to set it by
  SetLongestWeylWord( R, wd ), where wd is a reduced expression of the longest
  element in the Weyl group. Note that you will have to do this before calling
  LongestWeylWord,  or  any  function  that may call LongestWeylWord (once the
  attribute  is set, it will not be possible to change it). Note also that you
  must  be sure that the word you give is in fact a reduced expression for the
  longest  element  in  the  Weyl group, as this is not checked (you can check
  this with LengthOfWeylWord (3.4-2)).
  
  We  note  that  virtually  all  algorithms for quantized enveloping algebras
  depend  on  the  choice of reduced expression for the longest element in the
  Weyl group (as the PBW-type basis depends on this).
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> LongestWeylWord( R );
    [ 1, 2, 1, 2, 1, 2 ]
  ------------------------------------------------------------------
  
  3.4-4 ReducedWordIterator
  
  > ReducedWordIterator( W, wd ) ____________________________________operation
  
  Here  W  is  a  Weyl  group, and wd a reduced word. This function returns an
  iterator for the set of reduced words that represent the same element as wd.
  The elements are output in ascending lexicographical order.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "F", 4 );;
    gap> it:= ReducedWordIterator( WeylGroup(R), LongestWeylWord(R) );
    <iterator>
    gap> NextIterator( it );
    [ 1, 2, 1, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4 ]
    gap> k:= 1;;
    gap> while not IsDoneIterator( it ) do
    > k:= k+1; w:= NextIterator( it );
    > od;
    gap> k;
    2144892
  ------------------------------------------------------------------
  
  So there are 2144892 reduced expressions for the longest element in the Weyl
  group of type F_4.
  
  3.4-5 ExchangeElement
  
  > ExchangeElement( W, wd, ind ) ___________________________________operation
  
  Here  W  is a Weyl group, and wd is a reduced word in W, and ind is an index
  between  1  and  the rank of the root system. Let v denote the word obtained
  from wd by adding ind at the end. This function assumes that the length of v
  is  one  less  than the length of wd, and returns a reduced expression for v
  that is obtained from wd by deleting one entry. Nothing is guaranteed of the
  output if the length of v is bigger than the length of wd.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> wd:= LongestWeylWord( R );;
    gap> ExchangeElement( WeylGroup(R), wd, 1 );
    [ 2, 1, 2, 1, 2 ]
  ------------------------------------------------------------------
  
  3.4-6 GetBraidRelations
  
  > GetBraidRelations( W, wd1, wd2 ) ________________________________operation
  
  Here  W is a Weyl group, and wd1, wd2 are two reduced words representing the
  same  element in W. This function returns a list of braid relations that can
  be  applied  to wd1 to obtain wd2. Here a braid relation is represented as a
  list, with at the odd positions integers that represent positions in a word,
  and  at  the  even  positions  the indices that are on those positions after
  applying  the relation. For example, let wd be the word [ 1, 2, 1, 3, 2, 1 ]
  and  let  r = [ 3, 3, 4, 1 ] be a relation. Then the result of applying r to
  wd  is  [  1, 2, 3, 1, 2, 1] (i.e., on the third position we put a 3, and on
  the fourth position a 1).
  
  We note that the function does not check first whether wd1 and wd2 represent
  the  same  element  in  W. If this is not the case, then an error will occur
  during the execution of the function, or it will produce wrong output.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 3 );;
    gap> wd1:= LongestWeylWord( R );
    [ 1, 2, 1, 3, 2, 1 ]
    gap> wd2:= [ 1, 3, 2, 1, 3, 2 ];;
    gap> GetBraidRelations( WeylGroup(R), wd1, wd2 );
    [ [ 3, 3, 4, 1 ], [ 4, 2, 5, 1, 6, 2 ], [ 2, 3, 3, 2, 4, 3 ],
      [ 4, 1, 5, 3 ] ]
  ------------------------------------------------------------------
  
  3.4-7 LongWords
  
  > LongWords( R ) __________________________________________________attribute
  
  For  a  root system R this returns a list of triples (of length equal to the
  rank  of  R).  Let  t  be  the k-th triple occurring in this list. The first
  element  of  t  is  an expression for the longest element of the Weyl group,
  starting  with  k.  The  second element is a list of braid relations, moving
  this expression to the value of LongestWeylWord( R ). The third element is a
  list of braid relations performing the reverse transformation.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 3 );;
    gap> LongWords( R )[3];
    [ [ 3, 1, 2, 1, 3, 2 ],
      [ [ 3, 3, 4, 1 ], [ 4, 2, 5, 1, 6, 2 ], [ 2, 3, 3, 2, 4, 3 ],
          [ 4, 1, 5, 3 ], [ 1, 3, 2, 1 ] ],
      [ [ 4, 3, 5, 1 ], [ 1, 1, 2, 3 ], [ 2, 2, 3, 3, 4, 2 ],
          [ 4, 1, 5, 2, 6, 1 ], [ 3, 1, 4, 3 ] ] ]
  ------------------------------------------------------------------
  
  
  3.5 Quantized enveloping algebras
  
  In  QuaGroup  we  deal with two types of quantized enveloping algebra. First
  there   are  the  quantized  enveloping  algebras  defined  over  the  field
  QuantumField  (3.1-1).  We  say  that these algebras are "generic" quantized
  enveloping  algebras,  in  QuaGroup  they  have  the category IsGenericQUEA.
  Secondly,  we  deal  with the quantized enveloping algebras that are defined
  over a different field.
  
  3.5-1 QuantizedUEA
  
  > QuantizedUEA( R ) _______________________________________________attribute
  > QuantizedUEA( R, F, v ) _________________________________________operation
  > QuantizedUEA( L ) _______________________________________________attribute
  > QuantizedUEA( L, F, v ) _________________________________________operation
  
  In  the  first  two  forms  R  is  a  root system. With only R as input, the
  corresponding  generic  quantized  enveloping  algebra is constructed. It is
  stored as an attribute of R (so that constructing it twice for the same root
  system  yields  the  same  object).  Also  the  root system is stored in the
  quantized enveloping algebra as the attribute RootSystem.
  
  The  attribute  GeneratorsOfAlgebra  contains  the  generators of a PBW-type
  basis  (see  Section  2.4),  that  are  constructed  relative to the reduced
  expression  for  the  longest element in the Weyl group that is contained in
  LongestWeylWord(  R  ). We refer to ObjByExtRep (3.5-2) for a description of
  the construction of elements of a quantized enveloping algebra.
  
  The  call QuantizedUEA( R, F, v ) returns the quantized universal enveloping
  algebra  with  quantum  parameter  v, which must lie in the field F. In this
  case the elements of GeneratorsOfAlgebra are the images of the generators of
  the corresponding generic quantized enveloping algebra. This means that if v
  is a root of unity, then the generators will not generate the whole algebra,
  but  rather  a  finite dimensional subalgebra (as for instance E_i^k=0 for k
  large  enough). It is possible to construct elements that do not lie in this
  finite dimensional subalgebra using ObjByExtRep (3.5-2).
  
  In  the last two cases L must be a semisimple Lie algebra. The two calls are
  short for QuantizedUEA( RootSystem( L ) ) and QuantizedUEA( RootSystem( L ),
  F, v ) respectively.
  
  ---------------------------  Example  ----------------------------
    # We construct the generic quantized enveloping algebra corresponding
    # to the root system of type A2+G2:
    gap> R:= RootSystem( [ "A", 2, "G", 2 ] );;
    gap> U:= QuantizedUEA( R );
    QuantumUEA( <root system of type A2 G2>, Qpar = q )
    gap> RootSystem( U );
    <root system of type A2 G2>
    gap> g:= GeneratorsOfAlgebra( U );
    [ F1, F2, F3, F4, F5, F6, F7, F8, F9, K1, K1+(q^-1-q)*[ K1 ; 1 ], K2,
      K2+(q^-1-q)*[ K2 ; 1 ], K3, K3+(q^-1-q)*[ K3 ; 1 ], K4,
      K4+(q^-3-q^3)*[ K4 ; 1 ], E1, E2, E3, E4, E5, E6, E7, E8, E9 ]
    # These elements generate a PBW-type basis of U; the nine elements Fi,
    # and the nine elements Ei correspond to the roots listed in convex order:
    gap> PositiveRootsInConvexOrder( R );
    [ [ 1, 0, 0, 0 ], [ 1, 1, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ],
      [ 0, 0, 3, 1 ], [ 0, 0, 2, 1 ], [ 0, 0, 3, 2 ], [ 0, 0, 1, 1 ],
      [ 0, 0, 0, 1 ] ]
    # So, for example, F5 is an element of weight -[ 0, 0, 3, 1 ].
    # We can also multiply elements; the result is written on the PBW-basis:
    gap> g[17]*g[4];
    (q^-6-1)*F4*[ K4 ; 1 ]+(q^-3)*F4*K4
    # Now we construct a non-generic quantized enveloping algebra:
    gap> R:= RootSystem( "A", 2 );;
    gap> U:= QuantizedUEA( R, CF(3), E(3) );;
    gap> g:= GeneratorsOfAlgebra( U );
    [ F1, F2, F3, K1, K1+(-E(3)+E(3)^2)*[ K1 ; 1 ], K2,
      K2+(-E(3)+E(3)^2)*[ K2 ; 1 ], E1, E2, E3 ]
  ------------------------------------------------------------------
  
  As  can  be  seen  in the example, every element of U is written as a linear
  combination  of  monomials in the PBW-generators; the generators of U^- come
  first, then the generators of U^0, and finally the generators of U^+.
  
  3.5-2 ObjByExtRep
  
  > ObjByExtRep( fam, list ) ________________________________________operation
  
  Here  fam  is  the  elements  family  of  a  quantized enveloping algebra U.
  Secondly,  list  is  a  list describing an element of U. We explain how this
  description  works.  First we describe an indexing system for the generators
  of  U. Let R be the root system of U. Let t be the number of positive roots,
  and  rank  the  rank of the root system. Then the generators of U are Fk, Ki
  (and  its  inverse),  Ek,  for k=1...t, i=1..rank. (See Section 2.4; for the
  construction  of the Fk, Ek, the value of LongestWeylWord( R ) is used.) Now
  the index of Fk is k, and the index of Ek is t+rank+k. Furthermore, elements
  of  the  algebra generated by the Ki, and its inverse, are written as linear
  combinations of products of "binomials", as in Section 2.5. The element
  
  \[
       K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix}
  \]
  
  (where  d=0,1), is indexed as [ t+i, d ] (what happens to the s is described
  later). So an index is either an integer, or a list of two integers.
  
  A  monomial  is  a list of indices, each followed by an exponent. First come
  the  indices  of the Fk, (1..t), then come the lists of the form [ t+i, d ],
  and finally the indices of the Ek. Each index is followed by an exponent. An
  index of the form [ t+i, d ] is followed by the s in the above formula.
  
  The  second  argument  of  ObjByExtRep  is  a  list of monomials followed by
  coefficients. This function returns the element of U described by this list.
  
  Finally we remark that the element
  
  \[
       K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix}
  \]
  
  is printed as Ki[ Ki ; s ] if d=1, and as [ Ki ; s ] if d=0.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> fam:= ElementsFamily( FamilyObj( U ) );;
    gap> list:= [ [ 2, 3, [ 4, 0 ], 8, 6, 11 ], _q^2,    # monomial and coefficient
    > [ 1, 7, 3, 5, [ 5, 1 ], 3, 8, 9 ], _q^-1 + _q^2 ]; # monomial and coefficient
    [ [ 2, 3, [ 4, 0 ], 8, 6, 11 ], q^2, [ 1, 7, 3, 5, [ 5, 1 ], 3, 8, 9 ],
      q^-1+q^2 ]
    gap> ObjByExtRep( fam, list );
    (q^2)*F2^(3)*[ K1 ; 8 ]*E1^(11)+(q^-1+q^2)*F1^(7)*F3^(5)*K2[ K2 ; 3 ]*E3^(9)
  ------------------------------------------------------------------
  
  3.5-3 ExtRepOfObj
  
  > ExtRepOfObj( elm ) ______________________________________________operation
  
  For the element elm of a quantized enveloping algebra, this function returns
  the list that defines elm (see ObjByExtRep (3.5-2)).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> g:= GeneratorsOfAlgebra(U);
    [ F1, F2, F3, K1, K1+(q^-1-q)*[ K1 ; 1 ], K2, K2+(q^-1-q)*[ K2 ; 1 ], E1,
      E2, E3 ]
    gap> ExtRepOfObj( g[5] );
    [ [ [ 4, 1 ], 0 ], 1, [ [ 4, 0 ], 1 ], q^-1-q ]
  ------------------------------------------------------------------
  
  3.5-4 QuantumParameter
  
  > QuantumParameter( U ) ___________________________________________attribute
  
  Returns the quantum parameter used in the definition of U.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem("A",2);;
    gap> U0:= QuantizedUEA( R, CF(3), E(3) );;
    gap> QuantumParameter( U0 );
    E(3)
  ------------------------------------------------------------------
  
  3.5-5 CanonicalMapping
  
  > CanonicalMapping( U ) ___________________________________________attribute
  
  Here  U  is  a quantized enveloping algebra. Let U0 denote the corresponding
  "generic" quantized enveloping algebra. This function returns the mapping U0
  -->  U  obtained  by mapping q (which is the quantum parameter of U0) to the
  quantum parameter of U.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem("A", 3 );;
    gap> U:= QuantizedUEA( R, CF(5), E(5) );;
    gap> f:= CanonicalMapping( U );
    MappingByFunction( QuantumUEA( <root system of type A
    3>, Qpar = q ), QuantumUEA( <root system of type A3>, Qpar =
    E(5) ), function( u ) ... end )
    gap> U0:= Source( f );
    QuantumUEA( <root system of type A3>, Qpar = q )
    gap> g:= GeneratorsOfAlgebra( U0 );;
    gap> u:= g[18]*g[9]*g[6];
    (q^2)*F6*K2*E6+(q)*K2*[ K3 ; 1 ]
    gap> Image( f, u );
    (E(5)^2)*F6*K2*E6+(E(5))*K2*[ K3 ; 1 ]
  ------------------------------------------------------------------
  
  3.5-6 WriteQEAToFile
  
  > WriteQEAToFile( U, file ) _______________________________________operation
  
  Here  U  is  a quantized enveloping algebra, and file is a string containing
  the  name  of  a  file.  This function writes some data to file, that allows
  ReadQEAFromFile (3.5-7) to recover it.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",3) );;
    gap> WriteQEAToFile( U, "/home/wdg/A3" );
  ------------------------------------------------------------------
  
  3.5-7 ReadQEAFromFile
  
  > ReadQEAFromFile( file ) _________________________________________operation
  
  Here  file  is  a string containing the name of a file, to which a quantized
  enveloping algebra has been written by WriteQEAToFile (3.5-6). This function
  recovers the quantized enveloping algebra.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",3) );;
    gap> WriteQEAToFile( U, "/home/wdg/A3" );
    gap> U0:= ReadQEAFromFile( "/home/wdg/A3" );
    QuantumUEA( <root system of type A3>, Qpar = q )
  ------------------------------------------------------------------
  
  
  3.6 Homomorphisms and automorphisms
  
  Here    we    describe    functions    for    creating   homomorphisms   and
  (anti)-automorphisms of a quantized enveloping algebra.
  
  3.6-1 QEAHomomorphism
  
  > QEAHomomorphism( U, A, list ) ___________________________________operation
  
  Here  U  is  a  generic  quantized  enveloping  algebra  (i.e., with quantum
  parameter  _q),  A  is  an algebra with one over QuantumField, and list is a
  list  of  4*rank elements of A (where rank is the rank of the root system of
  U).  On  the first rank positions there are the images of the F_alpha (where
  the  alpha  are  simple  roots,  listed  in the order in which they occur in
  SimpleSystem(  R  )). On the positions rank+1...2*rank are the images of the
  K_alpha.   On   the  positions  2*rank+1...3*rank  are  the  images  of  the
  K_alpha^-1,  and finally on the positions 3*rank+1...4*rank occur the images
  of the E_alpha.
  
  This  function returns the homomorphism U -> A, defined by this data. In the
  example  below  we  construct  a  homomorphism from one quantized enveloping
  algebra into another. Both are constructed relative to the same root system,
  but  with  different reduced expressions for the longest element of the Weyl
  group.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> SetLongestWeylWord( R, [1,2,1,2,1,2] );
    gap> UR:= QuantizedUEA( R );;
    gap> S:= RootSystem( "G", 2 );;
    gap> SetLongestWeylWord( S, [2,1,2,1,2,1] );
    gap> US:= QuantizedUEA( S );;
    gap> gS:= GeneratorsOfAlgebra( US );
    [ F1, F2, F3, F4, F5, F6, K1, K1+(q^-1-q)*[ K1 ; 1 ], K2,
      K2+(q^-3-q^3)*[ K2 ; 1 ], E1, E2, E3, E4, E5, E6 ]
    gap> SimpleSystem( R );
    [ [ 1, 0 ], [ 0, 1 ] ]
    gap> PositiveRootsInConvexOrder( S );
    [ [ 0, 1 ], [ 1, 1 ], [ 3, 2 ], [ 2, 1 ], [ 3, 1 ], [ 1, 0 ] ]
    # We see that the simple roots of R occur on positions 6 and 1
    # in the list PositiveRootsInConvexOrder( S ); This means that we
    # get the following list of images of the homomorphism:
    gap> imgs:= [ gS[6], gS[1],      # the images of the F_{\alpha}
    > gS[7], gS[9],                  # the images of the K_{\alpha}
    > gS[8], gS[10],                 # the images of the K_{\alpha}^{-1}
    > gS[16], gS[11] ];              # the images of the E_{\alpha}
    [ F6, F1, K1, K2, K1+(q^-1-q)*[ K1 ; 1 ], K2+(q^-3-q^3)*[ K2 ; 1 ], E6, E1
     ]
    gap> h:= QEAHomomorphism( UR, US, imgs );
    <homomorphism: QuantumUEA( <root system of type G
    2>, Qpar = q ) -> QuantumUEA( <root system of type G2>, Qpar = q )>
    gap> Image( h, GeneratorsOfAlgebra( UR )[3] );
    (1-q^4-q^6+q^10)*F1*F6^(2)+(-q^2+q^6)*F2*F6+(q^4)*F4
  ------------------------------------------------------------------
  
  3.6-2 QEAAutomorphism
  
  > QEAAutomorphism( U, list ) ______________________________________operation
  > QEAAutomorphism( U, f ) _________________________________________operation
  
  In  the  first  form U is a generic quantized enveloping algebra (i.e., with
  quantum  parameter  _q),  and  list is a list of 4*rank elements of U (where
  rank  is  the  rank  of  the  corresponding  root system). On the first rank
  positions  there  are  the images of the F_alpha (where the alpha are simple
  roots, listed in the order in which they occur in SimpleSystem( R )). On the
  positions  rank+1...2*rank  are  the images of the K_alpha. On the positions
  2*rank+1...3*rank  are  the  images  of  the  K_alpha^-1, and finally on the
  positions 3*rank+1...4*rank occur the images of the E_alpha.
  
  In the second form U is a non-generic quantized enveloping algebra, and f is
  an  automorphism  of the corresponding generic quantized enveloping algebra.
  The  corresponding automorphism of U is constructed. In this case f must not
  be  the  bar-automorphism  of the corresponding generic quantized enveloping
  algebra  (cf. BarAutomorphism (3.6-6)), as this automorphism doesn't work in
  the non-generic case.
  
  The image of an element x under an automorphism f is computed by Image( f, x
  ).  Note  that  there  is no function for calculating pre-images (in general
  this  seems  to  be  a  very  hard  task).  If  you  want  the inverse of an
  automorphism, you have to construct it explicitly (e.g., by QEAAutomorphism(
  U, list ), where list is a list of pre-images).
  
  Below we construct the automorphism omega (cf. Section 2.2) of the quantized
  enveloping  of  type  A_3,  when  the  quantum parameter is _q, and when the
  quantum parameter is a fifth root of unity.
  
  ---------------------------  Example  ----------------------------
    # First we construct the quantized enveloping algebra:
    gap> R:= RootSystem( "A", 3 );;
    gap> U0:= QuantizedUEA( R );
    QuantumUEA( <root system of type A3>, Qpar = q )
    gap> g:= GeneratorsOfAlgebra( U0 );
    [ F1, F2, F3, F4, F5, F6, K1, K1+(q^-1-q)*[ K1 ; 1 ], K2,
      K2+(q^-1-q)*[ K2 ; 1 ], K3, K3+(q^-1-q)*[ K3 ; 1 ], E1, E2, E3, E4, E5, E6 ]
    # Now, for instance, we map F_{\alpha} to E_{\alpha}, where \alpha
    # is a simple root. In order to find where those F_{\alpha}, E_{\alpha}
    # are in the list of generators, we look at the list of positive roots
    # in convex order:
    gap> PositiveRootsInConvexOrder( R );
    [ [ 1, 0, 0 ], [ 1, 1, 0 ], [ 0, 1, 0 ], [ 1, 1, 1 ], [ 0, 1, 1 ],
      [ 0, 0, 1 ] ]
    # So the simple roots occur on positions 1, 3, 6. This means that we
    # have the following list of images:
    gap> imgs:= [ g[13], g[15], g[18], g[8], g[10], g[12], g[7], g[9], g[11],
    > g[1], g[3], g[6] ];
    [ E1, E3, E6, K1+(q^-1-q)*[ K1 ; 1 ], K2+(q^-1-q)*[ K2 ; 1 ],
      K3+(q^-1-q)*[ K3 ; 1 ], K1, K2, K3, F1, F3, F6 ]
    gap> f:= QEAAutomorphism( U0, imgs );
    <automorphism of QuantumUEA( <root system of type A3>, Qpar = q )>
    gap> Image( f, g[2] );
    (-q)*E2
    # f induces an automorphism of any non-generic quantized enveloping
    # algebra with the same root system R:
    gap> U1:= QuantizedUEA( R, CF(5), E(5) );
    QuantumUEA( <root system of type A3>, Qpar = E(5) )
    gap> h:= QEAAutomorphism( U1, f );
    <automorphism of QuantumUEA( <root system of type A3>, Qpar = E(5) )>
    gap> Image( h, GeneratorsOfAlgebra(U1)[7] );
    (-E(5)+E(5)^4)*[ K1 ; 1 ]+K1
  ------------------------------------------------------------------
  
  3.6-3 QEAAntiAutomorphism
  
  > QEAAntiAutomorphism( U, list ) __________________________________operation
  > QEAAntiAutomorphism( U, f ) _____________________________________operation
  
  These   are  functions  for  constructing  anti-automorphisms  of  quantized
  enveloping algebras. The same comments apply as for QEAAutomorphism (3.6-2).
  
  3.6-4 AutomorphismOmega
  
  > AutomorphismOmega( U ) __________________________________________attribute
  
  This is the automorphism omega (cf. Section 2.2).
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 3 );;
    gap> U:= QuantizedUEA( R, CF(5), E(5) );
    QuantumUEA( <root system of type A3>, Qpar = E(5) )
    gap> f:= AutomorphismOmega( U );
    <automorphism of QuantumUEA( <root system of type A3>, Qpar = E(5) )>
  ------------------------------------------------------------------
  
  3.6-5 AntiAutomorphismTau
  
  > AntiAutomorphismTau(  ) _________________________________________attribute
  
  This is the anti-automorphism tau (cf. Section 2.2).
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 3 );;
    gap> U:= QuantizedUEA( R, CF(5), E(5) );
    QuantumUEA( <root system of type A3>, Qpar = E(5) )
    gap> t:= AntiAutomorphismTau( U );
    <anti-automorphism of QuantumUEA( <root system of type A3>, Qpar = E(5) )>
  ------------------------------------------------------------------
  
  3.6-6 BarAutomorphism
  
  > BarAutomorphism( U ) ____________________________________________attribute
  
  This  is  the  automorphism  bar~  defined  in  Section 2.2 Here U must be a
  generic quantized enveloping algebra.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem(["A",2,"B",2]) );;
    gap> bar:= BarAutomorphism( U );
    <automorphism of QuantumUEA( <root system of type A2 B2>, Qpar = q )>
    gap> Image( bar, GeneratorsOfAlgebra( U )[5] );
    (-q^-2+q^2)*F4*F7+F5
  ------------------------------------------------------------------
  
  3.6-7 AutomorphismTalpha
  
  > AutomorphismTalpha( U, ind ) ____________________________________operation
  
  This  is  the  automorphism  T_alpha  (cf.  Section 2.4), where alpha is the
  ind-th simple root.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 3 ) );;
    gap> f:=AutomorphismTalpha( U, 1 );
    <automorphism of QuantumUEA( <root system of type B3>, Qpar = q )>
    gap> a:= GeneratorsOfAlgebra( U )[3];
    F3
    gap>  Image( f, a );
    F2
  ------------------------------------------------------------------
  
  3.6-8 DiagramAutomorphism
  
  > DiagramAutomorphism( U, perm ) __________________________________operation
  
  This  is  the  automorphism  of  U  induced by a diagram automorphism of the
  underlying  root  system.  The  diagram  automorphism  is represented by the
  permutation  perm, which is the permutation of the simple roots performed by
  the diagram automorphism.
  
  In  the  example  below  we  construct  the diagram automorphism of the root
  system of type A_3, which is represented by the permutation (1,3).
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 3 );;
    gap> U:= QuantizedUEA( R );;
    gap> f:= DiagramAutomorphism( U, (1,3) );
    <automorphism of QuantumUEA( <root system of type A3>, Qpar = q )>
    gap> g:= GeneratorsOfAlgebra( U );
    [ F1, F2, F3, F4, F5, F6, K1, K1+(q^-1-q)*[ K1 ; 1 ], K2,
      K2+(q^-1-q)*[ K2 ; 1 ], K3, K3+(q^-1-q)*[ K3 ; 1 ], E1, E2, E3, E4, E5, E6
     ]
    gap> Image( f, g[1] );
    F6
  ------------------------------------------------------------------
  
  3.6-9 \*
  
  > \*( f, h ) ______________________________________________________operation
  
  We  can  compose  automorphisms  and  anti-automorphisms  using  the infix *
  operator.  The result of composing two automorphisms is an automorphism. The
  result   of  composing  an  automorphism  and  an  anti-automorphism  is  an
  anti-automorphism.  The  result  of  composing  two anti-automorphisms is an
  automorphism.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 3 ) );;
    gap> f:=AutomorphismTalpha( U, 1 );
    <automorphism of QuantumUEA( <root system of type B3>, Qpar = q )>
    gap> h:= AutomorphismOmega( U );
    <automorphism of QuantumUEA( <root system of type B3>, Qpar = q )>
    gap> f*h;
    <automorphism of QuantumUEA( <root system of type B3>, Qpar = q )>
    gap> t:= AntiAutomorphismTau( U );;
    gap> T:= AutomorphismTalpha( U, 2 );;
    gap> Tinv:= t*T*t;
    <automorphism of QuantumUEA( <root system of type B3>, Qpar = q )>
    # (The last call may take a little while.)
    gap> x:= Image( T, GeneratorsOfAlgebra( U )[1] );
    (1-q^4)*F1*F3+(-q^2)*F2
    gap> Image( Tinv, x );
    F1
  ------------------------------------------------------------------
  
  According  to  [J96],  8.14(10), tau circ T_alpha circ tau is the inverse of
  T_alpha.
  
  
  3.7 Hopf algebra structure
  
  Here  we describe functions for dealing with the Hopf algebra structure of a
  quantized  enveloping algebra. This structure enables us to construct tensor
  products,  and  dual modules of modules over a quantized enveloping algebra.
  We  refer  to the next section (Section 3.8) for some functions for creating
  modules.
  
  3.7-1 TensorPower
  
  > TensorPower( U, d ) _____________________________________________operation
  
  Here  U  is  a  quantized universal enveloping algebra, and d a non-negative
  integer.  This  function  returns  the  associative  algebra with underlying
  vector  space  the  d-fold  tensor  product of U with itself. The product is
  defined component wise.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( [ "B", 2 ] ) );;
    gap> T:= TensorPower( U, 3 );
    <algebra over QuantumField, with 36 generators>
    gap> g:= GeneratorsOfAlgebra( T );;
    gap> x:= g[1];
    1*(1<x>1<x>F1)
    gap> y:= g[30];
    1*(E2<x>1<x>1)
    gap> x*y;
    1*(E2<x>1<x>F1)
  ------------------------------------------------------------------
  
  3.7-2 UseTwistedHopfStructure
  
  > UseTwistedHopfStructure( U, f, finv ) ___________________________operation
  
  Here  U  is  a  quantized  enveloping  algebra,  and  f,  finv  two  (anti-)
  automorphisms  of  U,  where  finv  is  the inverse of f. After calling this
  function  the Hopf structure on U is used that is obtained from the "normal"
  Hopf structure (see Section 2.3) by twisting it with f.
  
  A  call to this function sets the attribute HopfStructureTwist, which is the
  list [ f, finv ].
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2), CF(5), E(5) );;
    gap> t:= AntiAutomorphismTau( U );;
    gap> UseTwistedHopfStructure( U, t, t );
  ------------------------------------------------------------------
  
  3.7-3 ComultiplicationMap
  
  > ComultiplicationMap( U, d ) _____________________________________operation
  
  This is a homomorphism from the quantized enveloping algebra U to the d-fold
  tensor  power  of U with itself. It is obtained by a repeated application of
  the comultiplication of U. So for d=2 we get the comultiplication of U.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2), CF(5), E(5) );;
    gap> D:= ComultiplicationMap( U, 3 );
    <Comultiplication of QuantumUEA( <root system of type A2>, Qpar =
    E(5) ), degree 3>
    gap> Image( D, GeneratorsOfAlgebra(U)[4] );
    1*(K1<x>K1<x>K1)
  ------------------------------------------------------------------
  
  3.7-4 AntipodeMap
  
  > AntipodeMap( U ) ________________________________________________attribute
  
  This  is  the  antipode  map of the quantized enveloping algebra U, which is
  constructed as an anti-automorphism of U.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2), CF(5), E(5) );;
    gap> a:= AntipodeMap( U );
    <anti-automorphism of QuantumUEA( <root system of type A2>, Qpar = E(5) )>
  ------------------------------------------------------------------
  
  3.7-5 CounitMap
  
  > CounitMap( U ) __________________________________________________attribute
  
  This  is  the  counit  map  of  the quantized enveloping algebra U, which is
  constructed as a function from U to the ground field.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2), CF(5), E(5) );;
    gap> co:= CounitMap( U );
    function( u ) ... end
    gap> x:= GeneratorsOfAlgebra( U )[4];
    K1
    gap> co( x );
    1
  ------------------------------------------------------------------
  
  
  3.8 Modules
  
  Here we describe some functions for constructing left modules over quantized
  enveloping algebras. We refer to the GAP reference manual for an overview of
  basic  functions  for  algebra  modules,  which  are  also applicable to the
  modules  constructed  by the functions described in this section. We mention
  MatrixOfAction,  DirectSumOfAlgebraModules.  The action of an element of the
  algebra on an element of the module is calculated by the infix operator ^.
  
  3.8-1 HighestWeightModule
  
  > HighestWeightModule( U, wt ) ____________________________________operation
  
  Here U is a quantized universal enveloping algebra, and wt a dominant weight
  (i.e.,  a list of length equal to the rank of the root system, consisting of
  non-negative   integers).   This   function   returns  a  finite-dimensional
  highest-weight module of highest weight wt over U. If U is generic then this
  is  the unique irreducible highest-weight module over U. Otherwise it is the
  Weyl  module,  cf.  Section  2.5.  In  this  last  case  the  module  is not
  necessarily irreducible.
  
  Let  V  denote the module returned by this function. The first basis element
  of  the  attribute  Basis(  V ) is a highest-weight vector; it is written as
  1*v0.  Other  basis  elements  are  written as, for example, F2*F9*v0, which
  means  that  this vector is the result of letting the PBW-monomial F2*F9 act
  on the highest-weight vector.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( [ "A", 2, "G", 2 ] ) );;
    gap> V:= HighestWeightModule( U, [ 0, 1, 0, 2 ] );
    <231-dimensional left-module over QuantumUEA( <root system of type A2 G
    2>, Qpar = q )>
    gap> Basis( V )[1];
    1*v0
    gap> Basis(V)[23]+(_q^2+_q^-2)*Basis(V)[137];
    F3*F5*v0+(q^-2+q^2)*F8^(6)*v0
    # We compute the action of an element on a vector:
    gap> gg:= GeneratorsOfAlgebra( U );;
    gap> x:= gg[21]*gg[5];
    F5*E4+(-q^-1)*F6*K3
    gap> x^Basis(V)[1];
    (-q^-1)*F6*v0
  ------------------------------------------------------------------
  
  3.8-2 IrreducibleQuotient
  
  > IrreducibleQuotient( V ) ________________________________________attribute
  
  Here  V  is  a highest-weight module over a non-generic quantized enveloping
  algebra.  This  function  returns the quotient of V by the maximal submodule
  not containing the highest weight vector. This is not necessarily equal to V
  if the quantum parameter is a root of 1.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 2 );;
    gap> U:= QuantizedUEA( R, CF(3), E(3) );;
    gap> V:= HighestWeightModule( U, [1,1] );
    <8-dimensional left-module over QuantumUEA( <root system of type A2>, Qpar =
    E(3) )>
    gap> IrreducibleQuotient( V );
    <7-dimensional left-module over QuantumUEA( <root system of type A2>, Qpar =
    E(3) )>
  ------------------------------------------------------------------
  
  3.8-3 HWModuleByTensorProduct
  
  > HWModuleByTensorProduct( U, wt ) ________________________________operation
  
  Here  U  must  be  a generic quantized enveloping algebra, and wt a dominant
  weight.  This  function  returns  the irreducible highest-weight module with
  highest  weight wt. The algorithm uses tensor products (whence the name). On
  some   inputs   this   algorithm   is   faster   than   the   one   use  for
  HighestWeightModule:for  a quantized env. alg. (???HighestWeightModule:for a
  quantized env. alg.???), on some inputs it is slower. I do not know any good
  heuristics.
  
  The basis supplied with the module returned is the canonical basis.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("G",2) );;
    gap> V:= HWModuleByTensorProduct( U, [2,1] );
    <189-dimensional left-module over QuantumUEA( <root system of type G
    2>, Qpar = q )>
    # (This is a case where this algorithm is a lot faster.)
  ------------------------------------------------------------------
  
  3.8-4 DIYModule
  
  > DIYModule( U, V, acts ) _________________________________________operation
  
  Here  U  is  a generic quantized enveloping algebra, and V is a vector space
  over  the field QuantumField. U acts on V and the action is described by the
  data  in  the  list acts. acts is a list of lists, of length 4*l, where l is
  the  rank  of  the root system. acts describes the actions of the generators
  [F_1,...,F_l,K_1,...,K_l,K_1^-1,...,K_l^-1,  E_1,...,E_l ]. (Here F_k is the
  generator F_alpha_k, where alpha_k is the k-th simple root, and likewise for
  E_k.)  The  action of each generator is described by a list of length dim V,
  giving  the  images  of the basis elements of V. If an image is zero then it
  may  be  omitted:  in that case there is a "hole" in the list. This function
  returns the U-module defined by the input.
  
  Let  R  be  a  root  system  of  type A_1, and U the corresponding quantized
  enveloping  algebra  (generated  by  F, K, K^-1, E). In the example below we
  construct  the  2-dimensional  U-module  with  basis  vectors  v_1,v_2,  and
  U-action  given  by  Fv_1  = v_2, Fv_2=0, Kv_1 = qv_1, Kv_2=q^-1v_2, Ev_1=0,
  Ev_2=v_1.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",1) );
    QuantumUEA( <root system of type A1>, Qpar = q )
    gap> V:= QuantumField^2;
    ( QuantumField^2 )
    gap> v:= BasisVectors( Basis(V) );
    [ [ 1, 0 ], [ 0, 1 ] ]
    gap> acts:= [ [ v[2], 0*v[1] ], [ _q*v[1], _q^-1*v[2] ],
    > [ _q^-1*v[1], _q*v[2] ], [ 0*v[1], v[1] ] ];;
    gap> M:= DIYModule( U, V, acts );
    <2-dimensional left-module over QuantumUEA( <root system of type A
    1>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-5 TensorProductOfAlgebraModules
  
  > TensorProductOfAlgebraModules( V, W ) ___________________________operation
  > TensorProductOfAlgebraModules( V, W ) ___________________________operation
  
  Here  V  and W are two modules over the same quantized enveloping algebra U.
  This  function constructs the tensor product of V and W (as a U-module). For
  this  the  comultiplication  map  of  U  is  used  (see  ComultiplicationMap
  (3.7-3)).
  
  In  the  second  form list is a list of U-modules. In that case the iterated
  tensor product is constructed.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( [ "A", 2 ] ) );;
    gap> V1:= HighestWeightModule( U, [ 1, 0 ] );;
    gap> V2:= HighestWeightModule( U, [ 0, 1 ] );;
    gap> TensorProductOfAlgebraModules( V1, V2 );
    <9-dimensional left-module over QuantumUEA( <root system of type A2>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-6 HWModuleByGenerator
  
  > HWModuleByGenerator( V, v, hw ) _________________________________operation
  
  Here  V  is  a  module over a generic quantized enveloping algebra U, v is a
  highest-weight  vector  (i.e.,  all E_alphav=0), of weight hw, which must be
  dominant. This function returns a highest-weight module over U isomorphic to
  the submodule of V generated by v.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("B",2) );;
    gap> W1:= HighestWeightModule( U, [1,0] );;
    gap> W2:= HighestWeightModule( U, [0,1] );;
    gap> T:= TensorProductOfAlgebraModules( W1, W2 );
    <20-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = q )>
    gap> HWModuleByGenerator( T, Basis(T)[1], [1,1] );
    <16-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-7 InducedQEAModule
  
  > InducedQEAModule( U, V ) ________________________________________operation
  
  Here  U  is  a non-generic quantized enveloping algebra, and V a module over
  the  corresponding  generic  quantized  enveloping  algebra.  This  function
  returns  the  U-module  obtained  from  V by setting _q equal to the quantum
  parameter of U.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem("B",2);;
    gap> U:= QuantizedUEA( R );;
    gap> U0:= QuantizedUEA( R, CF(3), E(3) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> W:= InducedQEAModule( U0, V );
    <16-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = E(3) )>
    # This module is isomorphic to the one obtained by
    # HighestWeightModule( U0, [1,1] );
  ------------------------------------------------------------------
  
  3.8-8 GenericModule
  
  > GenericModule( W ) ______________________________________________attribute
  
  For  an  induced module (see InducedQEAModule (3.8-7)) this function returns
  the corresponding module over the generic quantized enveloping algebra.
  
  3.8-9 CanonicalMapping
  
  > CanonicalMapping( W ) ___________________________________________attribute
  
  Here  W  is  an  induced  module.  Let V be the corresponding generic module
  (GenericModule (3.8-8)). This function returns the map V --> W, that sets _q
  equal to the quantum parameter of the acting algebra of W.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem("B",2);;
    gap> U:= QuantizedUEA( R );;
    gap> U0:= QuantizedUEA( R, CF(3), E(3) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> W:= InducedQEAModule( U0, V );;
    gap> f:= CanonicalMapping( W );
    MappingByFunction( <
    16-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = q )>, <
    16-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = E(3) )>, function( v ) ... end )
    gap> Image( f, _q^2*Basis(V)[3] );
    (E(3)^2)*e.3
  ------------------------------------------------------------------
  
  3.8-10 U2Module
  
  > U2Module( U, hw ) _______________________________________________operation
  
  Here  U  must  be  a quantized enveloping algebra of type A_2. This function
  returns the highest-weight module over U of highest-weight hw (which must be
  dominant).    This    function    is    generally    a   lot   faster   than
  HighestWeightModule:for  a quantized env. alg. (???HighestWeightModule:for a
  quantized env. alg.???).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> A2Module( U, [4,7] );
    <260-dimensional left-module over QuantumUEA( <root system of type A
    2>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-11 MinusculeModule
  
  > MinusculeModule( U, hw ) ________________________________________operation
  
  Here  U  must  be a generic quantized enveloping algebra, and hw a minuscule
  dominant  weight.  This function returns the highest-weight module over U of
  highest-weight   hw.   This  function  is  generally  somewhat  faster  than
  HighestWeightModule:for  a quantized env. alg. (???HighestWeightModule:for a
  quantized env. alg.???).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",5) );;
    gap> MinusculeModule( U, [0,0,1,0,0] );
    <20-dimensional left-module over QuantumUEA( <root system of type A
    5>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-12 DualAlgebraModule
  
  > DualAlgebraModule( V ) __________________________________________attribute
  
  Here  V  is  a  finite-dimensional  left  module over a quantized enveloping
  algebra  U.  This function returns the dual space of V as an algebra module.
  For this the antipode map of U is used (see AntipodeMap (3.7-4)).
  
  Let  M  denote the module returned by this function. Then M has as basis the
  dual  basis  with respect to Basis( V ). An element of this basis is printed
  as  F@v,  where  v  is  an element of Basis( V ). This is the function which
  takes  the value 1 on v and 0 on all other basis elements. A general element
  of M is a linear combination of these basis elements.
  
  The  elements of M can be viewed as functions which take arguments. However,
  internally  the  elements  of M are represented as wrapped up functions. The
  function  corresponding to an element m of M is obtained by ExtRepOfObj( m )
  (the  result  of  which is printed in the same way as m, but is not equal to
  it).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> M:= DualAlgebraModule( V );
    <8-dimensional left-module over QuantumUEA( <root system of type A
    2>, Qpar = q )>
    gap> u:= GeneratorsOfAlgebra( U )[2];
    F2
    gap> vv:= BasisVectors( Basis( M ) );
    [ (1)*F@1*v0, (1)*F@F1*v0, (1)*F@F3*v0, (1)*F@F1*F3*v0, (1)*F@F2*v0,
      (1)*F@F1*F2*v0, (1)*F@F2*F3*v0, (1)*F@F2^(2)*v0 ]
    gap> u^vv[3];
    <zero function>
    # (The zero of the dual space is printed as <zero function>).
    gap> u^vv[4];
    (q^3-q^5)*F@1*v0
    # We get the function corresponding to a vector in M by using ExtRepOfObj:
    gap> f:= ExtRepOfObj( vv[1] );
    (1)*F@1*v0
    # We can calculate images of this function:
    gap> List( Basis(V), v -> Image( f, v ) );
    [ 1, 0, 0, 0, 0, 0, 0, 0 ]
  ------------------------------------------------------------------
  
  3.8-13 TrivialAlgebraModule
  
  > TrivialAlgebraModule( U ) _______________________________________attribute
  
  Returns the trivial module over the quantized enveloping algebra U. For this
  the counit map of U is used.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> V:= TrivialAlgebraModule( U );
    <left-module over QuantumUEA( <root system of type A2>, Qpar = q )>
  ------------------------------------------------------------------
  
  3.8-14 WeightsAndVectors
  
  > WeightsAndVectors( V ) __________________________________________operation
  
  Here   V   is   a   left   module   over  a  quantized  enveloping  algebra.
  WeightsAndVectors(  V ) is a list of two lists; the first of these is a list
  of  the  weights  of  V,  the second a list of corresponding weight vectors.
  These are again grouped in lists: if the multiplicity of a weight is m, then
  there  are  m  weight  vectors,  forming a basis of the corresponding weight
  space.
  
  Modules   constructed  by  HighestWeightModule:for  a  quantized  env.  alg.
  (???HighestWeightModule:for   a  quantized  env.  alg.???)  come  with  this
  attribute  set. There is a method installed for computing WeightsAndVectors(
  V  ),  for  modules V over a generic quantized enveloping algebra, such that
  all basis vectors (i.e., all elements of Basis( V )) are weight vectors.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "A", 2 ) );;
    gap> V:= HighestWeightModule( U, [ 1, 1 ] );;
    gap> WeightsAndVectors( V );
    [ [ [ 1, 1 ], [ -1, 2 ], [ 2, -1 ], [ 0, 0 ], [ -2, 1 ], [ 1, -2 ],
          [ -1, -1 ] ],
      [ [ 1*v0 ], [ F1*v0 ], [ F3*v0 ], [ F1*F3*v0, F2*v0 ], [ F1*F2*v0 ],
          [ F2*F3*v0 ], [ F2^(2)*v0 ] ] ]
  ------------------------------------------------------------------
  
  3.8-15 HighestWeightsAndVectors
  
  > HighestWeightsAndVectors( V ) ___________________________________attribute
  
  Is analogous to WeightsAndVectors (3.8-14); now only the highest weights are
  listed along with the corresponding highest-weight vectors.
  
  There is a method installed for this using WeightsAndVectors (3.8-14); which
  means that it works if and only if WeightsAndVectors( V ) works.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( [ "A", 2 ] ) );;
    gap> V:= HighestWeightModule( U, [ 1, 1 ] );;
    gap> HighestWeightsAndVectors( V );
    [ [ [ 1, 1 ] ], [ [ 1*v0 ] ] ]
  ------------------------------------------------------------------
  
  3.8-16 RMatrix
  
  > RMatrix( V ) ____________________________________________________attribute
  
  Here  V is a module over the a quantized enveloping algebra U. This function
  returns  the matrix of a linear map theta : Votimes V -> Votimes V that is a
  solution to the quantum Yang-Baxter equation. We have that thetacirc P is an
  isomorphism  of  U-modules, where P :Votimes V-> Votimes V is the linear map
  such  that  P(votimes  w)=wotimes  v.  For  more  details we refer to [J96],
  Chapter 7.
  
  This function works for modules for which WeightsAndVectors (3.8-14) works.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",1) );;
    gap> V:= HighestWeightModule( U, [1] );;
    gap> RMatrix( V );
    [ [ 1, 0, 0, 0 ], [ 0, q, 1-q^2, 0 ], [ 0, 0, q, 0 ], [ 0, 0, 0, 1 ] ]
  ------------------------------------------------------------------
  
  3.8-17 IsomorphismOfTensorModules
  
  > IsomorphismOfTensorModules( V, W ) ______________________________operation
  
  Here V, W are two modules over the same quantized enveloping algebra U. This
  function  returns  a  linear  map  theta  : Votimes W-> Wotimes V that is an
  isomorphism of U-modules.
  
  This  function  is  only  guaranteed  to  work correctly if the Hopf algebra
  structure is non-twisted (see UseTwistedHopfStructure (3.7-2)).
  
  This function works for modules for which WeightsAndVectors (3.8-14) works.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("B",2) );;
    gap> V:= HighestWeightModule( U, [1,0] );;
    gap> W:= HighestWeightModule( U, [0,1] );;
    gap> h:= IsomorphismOfTensorModules( V, W );;
    gap> VW:= Source( h );
    <20-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = q )>
    gap> Image( h, Basis(VW)[13] );
    q*(1*v0<x>F3*v0)+1-q^2*(F4*v0<x>F2*v0)+q^-1-q^3*(F3*v0<x>1*v0)
  ------------------------------------------------------------------
  
  3.8-18 WriteModuleToFile
  
  > WriteModuleToFile( V, file ) ____________________________________operation
  
  Here V is a module over a quantized enveloping algebra, and file is a string
  containing  the name of a file. This function writes some data to file, that
  allows ReadModuleFromFile (3.8-19) to recover it.
  
  We  remark  that  this  function  currently  is only implemented for generic
  quantized enveloping algebras.
  
  3.8-19 ReadModuleFromFile
  
  > ReadModuleFromFile( file ) ______________________________________operation
  
  Here  file is a string containing the name of a file, to which a module over
  a  quantized  enveloping  algebra  has  been  written  by  WriteModuleToFile
  (3.8-18). This function recovers the module. More precisely: a new module is
  constructed  that  is  isomorphic to the old one. In the process the algebra
  acting  on  the  module is constructed anew (from data written to the file).
  This algebra can be accessed by LeftActingAlgebra( V ).
  
  We  remark  that  this  function  currently  is only implemented for generic
  quantized enveloping algebras.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",3) );;
    gap> V:= HighestWeightModule( U, [1,1,1] );;
    gap> WriteModuleToFile( V, "/home/wdg/A3mod" );
    gap> W:= ReadModuleFromFile( "/home/wdg/A3mod" );
    <64-dimensional left-module over QuantumUEA( <root system of type A
    3>, Qpar = q )>
  ------------------------------------------------------------------
  
  
  3.9 The path model
  
  In  this  section  we describe functions for dealing with the path model. We
  work only with LS-paths, which are represented by two lists, one of weights,
  and one of rationals (see Section 2.7).
  
  3.9-1 DominantLSPath
  
  > DominantLSPath( R, wt ) _________________________________________operation
  
  Here  R  is a root system, and wt a dominant weight in the weight lattice of
  R. This function returns the LS-path that is the line from the origin to wt.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> DominantLSPath( R, [1,3] );
    <LS path of shape [ 1, 3 ] ending in [ 1, 3 ] >
  ------------------------------------------------------------------
  
  3.9-2 Falpha
  
  > Falpha( path, ind ) _____________________________________________operation
  
  Is the result of applying the path operator f_alpha_ind} to the LS-path path
  (where alpha_ind is the ind-th simple root).
  
  The result is fail if f_alpha_ind}(path)=0.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> p:=DominantLSPath( R, [1,3] );;
    gap> p1:=Falpha( p, 1 );
    <LS path of shape [ 1, 3 ] ending in [ -1, 4 ] >
    gap> Falpha( p1, 1 );
    fail
  ------------------------------------------------------------------
  
  3.9-3 Ealpha
  
  > Ealpha( path, ind ) _____________________________________________operation
  
  Is the result of applying the path operator e_alpha_ind} to the LS-path path
  (where alpha_ind is the ind-th simple root).
  
  The result is fail if e_alpha_ind}(path)=0.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> p:=DominantLSPath( R, [1,3] );;
    gap> Ealpha( p, 2 );
    fail
    gap> p1:=Falpha( p, 1 );;
    gap> Ealpha( p1, 1 );
    <LS path of shape [ 1, 3 ] ending in [ 1, 3 ] >
  ------------------------------------------------------------------
  
  3.9-4 LSSequence
  
  > LSSequence( path ) ______________________________________________attribute
  
  returns  the two sequences (of weights and rational numbers) that define the
  LS-path path.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> p:=DominantLSPath( R, [1,3] );;
    gap> p1:= Falpha( Falpha( p, 1 ), 2 );;
    gap> LSSequence( p1 );
    [ [ [ 11, -4 ], [ -1, 4 ] ], [ 0, 1/4, 1 ] ]
  ------------------------------------------------------------------
  
  3.9-5 WeylWord
  
  > WeylWord( path ) ________________________________________________attribute
  
  Here  path  is  an  LS-path  in  the  orbit  (under the root operators) of a
  dominant  LS-path  ending in the dominant weight lambda. This means that the
  first  direction  of  path  is  of the form w(lambda) for some w in the Weyl
  group.  This  function returns a list [i_1,..., i_m ] such that w=s_i_1cdots
  s_i_m.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> p:=DominantLSPath( R, [1,3] );;
    gap> p1:= Falpha( Falpha( Falpha( p, 1 ), 2 ), 1 );;
    gap> WeylWord( p1 );
    [ 1, 2, 1 ]
  ------------------------------------------------------------------
  
  3.9-6 EndWeight
  
  > EndWeight( path ) _______________________________________________attribute
  
  Here  path  is  an  LS-path;  this  function  returns the weight that is the
  endpoint of path
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "G", 2 );;
    gap> p:=DominantLSPath( R, [1,3] );;
    gap> p1:= Falpha( Falpha( Falpha( p, 1 ), 2 ), 1 );;
    gap> EndWeight( p1 );
    [ 0, 3 ]
  ------------------------------------------------------------------
  
  3.9-7 CrystalGraph
  
  > CrystalGraph( R, wt ) ____________________________________________function
  
  This  function  returns  a  record  describing  the  crystal  graph  of  the
  highest-weight  module with highest weight wt, over the quantized enveloping
  algebra  corresponding  to R. It is computed using the path model. Therefore
  the points in the graph are LS-paths.
  
  Denote  the  output  by r; then r.points is the list of points of the graph.
  Furthermore,  r.edges  is  a  list  of edges of the graph; this is a list of
  elements of the form [ [ i, j ], u ]. This means that there is an arrow from
  point  i  (i.e., the point on position i in r.points) to point j, with label
  u.
  
  ---------------------------  Example  ----------------------------
    gap> R:= RootSystem( "A", 2 );;
    gap> CrystalGraph( R, [1,1] );
    rec(
      points := [ <LS path of shape [ 1, 1 ] ending in [ 1, 1 ] >, <LS path of sha\
    pe [ 1, 1 ] ending in [ -1, 2 ] >, <LS path of shape [ 1, 1 ] ending in
            [ 2, -1 ] >, <LS path of shape [ 1, 1 ] ending in [ 0, 0 ] >,
          <LS path of shape [ 1, 1 ] ending in [ 0, 0 ] >,
          <LS path of shape [ 1, 1 ] ending in [ 1, -2 ] >,
          <LS path of shape [ 1, 1 ] ending in [ -2, 1 ] >,
          <LS path of shape [ 1, 1 ] ending in [ -1, -1 ] > ],
      edges := [ [ [ 1, 2 ], 1 ], [ [ 1, 3 ], 2 ], [ [ 2, 4 ], 2 ],
          [ [ 3, 5 ], 1 ], [ [ 4, 6 ], 2 ], [ [ 5, 7 ], 1 ], [ [ 6, 8 ], 1 ],
          [ [ 7, 8 ], 2 ] ] )
  ------------------------------------------------------------------
  
  
  3.10 Canonical bases
  
  Here we describe functions for computing the canonical basis of the negative
  part of a quantized enveloping algebra, and of a module.
  
  3.10-1 Falpha
  
  > Falpha( x, ind ) ________________________________________________operation
  
  Here  x  is  a  PBW-monomial  in U^- (i.e., a monomial in the F_alpha, where
  alpha  runs  over  the  positive roots). This function returns the result of
  applying  the  ind-th  Kashiwara  operator  widetildeF_alpha_ind}  to x (cf.
  Section 2.6).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> x:= One( U );
    1
    gap> Falpha( Falpha( x, 3 ), 2 );
    F3*F9
  ------------------------------------------------------------------
  
  3.10-2 Ealpha
  
  > Ealpha( x, ind ) ________________________________________________operation
  
  Here  x  is  a  PBW-monomial  in U^- (i.e., a monomial in the F_alpha, where
  alpha  runs  over  the  positive roots). This function returns the result of
  applying  the  ind-th  Kashiwara  operator  widetildeE_alpha_ind}  to x (cf.
  Section 2.6). The result is fail if widetildeE_alpha_ind}(x)=0.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> Ealpha( One( U ), 2 );
    fail
    gap> g:= GeneratorsOfAlgebra( U );;
    gap> x:= g[1]*g[4]*g[7]*g[17];
    F1*F4*F7*F17
    gap> Ealpha( x, 3 );
    F1*F2*F7*F17
    
  ------------------------------------------------------------------
  
  3.10-3 CanonicalBasis
  
  > CanonicalBasis( U ) _____________________________________________attribute
  
  Is the canonical basis of the quantized universal enveloping algebra U. When
  this  is  constructed  nothing  is  computed. By using PBWElements (3.10-4),
  MonomialElements  (3.10-5),  Strings  (3.10-6) information about elements of
  the canonical basis can be obtained.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> B:= CanonicalBasis( U );
    <canonical basis of QuantumUEA( <root system of type F4>, Qpar = q ) >
  ------------------------------------------------------------------
  
  3.10-4 PBWElements
  
  > PBWElements( B, rt ) ____________________________________________operation
  
  Here  B  is  the  canonical  basis  of  a  quantized  uea,  and rt a list of
  non-negative  integers representing an element of the root lattice (e.g., if
  the  simple  roots  are  alpha,  beta  and rt = [ 3, 2 ], then rt represents
  3alpha+2beta).
  
  It  is  possible  to  add  the option lowrank, as follows PBWElements( B, rt
  :lowrank  ).  In that case a somewhat different method will be used, that is
  significantly faster if the underlying root system has rank 2,3. It is about
  equally fast for ranks 4,5; and slower for ranks greater than 5.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> B:= CanonicalBasis( U );;
    gap> PBWElements( B, [1,2,1,0] );
    [ F1*F3^(2)*F9, F1*F3*F7+(q^4)*F1*F3^(2)*F9, (q^4)*F1*F3^(2)*F9+F2*F3*F9,
      (q^2)*F1*F3*F7+(q^2+q^6)*F1*F3^(2)*F9+(q^2)*F2*F3*F9+F2*F7,
      (q^4)*F1*F3*F7+(q^8)*F1*F3^(2)*F9+(q^4)*F2*F3*F9+(q^2)*F2*F7+F3*F4 ]
    gap> U:= QuantizedUEA( RootSystem("G",2) );;
    gap> B:= CanonicalBasis( U );;
    gap> PBWElements( B, [2,3] : lowrank );
    [ F1^(2)*F6^(3), F1*F5*F6^(2)+(q^8+q^10)*F1^(2)*F6^(3),
      (q^2)*F1*F5*F6^(2)+(q^6+q^12)*F1^(2)*F6^(3)+F3*F6^(2),
      (q^8)*F1*F5*F6^(2)+(q^18)*F1^(2)*F6^(3)+(q^6)*F3*F6^(2)+F5^(2)*F6 ]
  ------------------------------------------------------------------
  
  3.10-5 MonomialElements
  
  > MonomialElements( B, rt ) _______________________________________operation
  
  This  does  the  same  as PBWElements (3.10-4), except that the elements are
  written as linear combinations of monomials in the generators F_alpha, where
  alpha runs through the simple roots.
  
  We  remark  that  this information is also computed "behind the scenes" when
  calling  PBWElements(  B,  rt  ).  However, it is not computed if the option
  lowrank is present in the call to PBWElements.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> B:= CanonicalBasis( U );;
    gap> MonomialElements( B, [1,2,1,0] );
    [ F1*F3^(2)*F9, F1*F3*F9*F3+(-1)*F1*F3^(2)*F9, F3^(2)*F1*F9, F3*F1*F9*F3,
      F3*F9*F3*F1+(-1)*F3^(2)*F1*F9 ]
  ------------------------------------------------------------------
  
  3.10-6 Strings
  
  > Strings( B, rt ) ________________________________________________operation
  
  Here B, rt are the same as in PBWElements (3.10-4). This returns the list of
  strings  corresponding  to the elements of B of weight rt (cf. Section 2.6).
  For  example,  if on the k-th position of the list returned by this function
  we  have  [ 1, 2, 2, 3 ], then the principal monomial of the k-th element of
  PBWElements(  B, rt ) is widetildeF_1^2widetildeF_2^3(1) (where widetildeF_i
  is the i-th Kashiwara operator).
  
  We  remark  that  this information is also computed "behind the scenes" when
  calling  PBWElements(  B,  rt  ).  However, it is not computed if the option
  lowrank is present in the call to PBWElements.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "F", 4 ) );;
    gap> B:= CanonicalBasis( U );;
    gap> Strings( B, [1,2,1,0] );
    [ [ 1, 1, 2, 2, 3, 1 ], [ 1, 1, 2, 1, 3, 1, 2, 1 ], [ 2, 2, 1, 1, 3, 1 ],
      [ 2, 1, 1, 1, 3, 1, 2, 1 ], [ 2, 1, 3, 1, 2, 1, 1, 1 ] ]
    gap> Falpha( Falpha( Falpha( Falpha( One(U), 3 ), 1 ), 2 ), 2 );
    F2*F3*F9
    gap> PBWElements( B, [1,2,1,0] )[3];
    (q^4)*F1*F3^(2)*F9+F2*F3*F9
  ------------------------------------------------------------------
  
  3.10-7 PrincipalMonomial
  
  > PrincipalMonomial( u ) __________________________________________operation
  
  Here  u  is  an element of the output of PBWElements (3.10-4). This function
  returns the unique monomial of u that has coefficient 1.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("G",2) );;
    gap> B:= CanonicalBasis( U );;
    gap> p:= PBWElements( B, [4,4] : lowrank )[4];
    (q^9)*F1^(2)*F3*F6^(3)+F1^(2)*F5^(2)*F6^(2)+(q^9+q^11+q^13)*F1^(3)*F5*F6^(
    3)+(q^20+q^22+2*q^24+q^26+q^28)*F1^(4)*F6^(4)
    gap> PrincipalMonomial( p );
    F1^(2)*F5^(2)*F6^(2)
  ------------------------------------------------------------------
  
  3.10-8 StringMonomial
  
  > StringMonomial( u ) _____________________________________________operation
  
  Here u is a monomial in the negative part of a quantized enveloping algebra,
  e.g.,  as  output  by PrincipalMonomial (3.10-7). This function computes the
  corresponding "string" (see Section 2.6). The strings are output in the same
  way as in 3.10-6.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("G",2) );;
    gap> B:= CanonicalBasis( U );;
    gap> p:= PBWElements( B, [1,2] : lowrank )[2];;
    gap> m:=PrincipalMonomial( p );
    F5*F6
    gap> StringMonomial( m );
    [ 2, 2, 1, 1 ]
    gap> Falpha( Falpha( Falpha( One(U), 1 ), 2 ), 2 );
    F5*F6
  ------------------------------------------------------------------
  
  3.10-9 Falpha
  
  > Falpha( V, v, ind ) _____________________________________________operation
  
  Here  V is a module over a quantized enveloping algebra, v an element of it,
  and  ind  an  index  between 1 and the rank of the root system. The function
  returns  the result of applying the ind-th Kashiwara operator widetildeF_ind
  to  v. Here the Kashiwara operators are different from the ones described in
  Section 2.6. We refer to [J96], 9.2 for the definition of the operators used
  here.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("B",2) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> Falpha( V, Basis(V)[1], 1 );
    F1*v0
  ------------------------------------------------------------------
  
  3.10-10 Ealpha
  
  > Ealpha( V, v, ind ) _____________________________________________operation
  
  Here  V is a module over a quantized enveloping algebra, v an element of it,
  and  ind  an  index  between 1 and the rank of the root system. The function
  returns  the result of applying the ind-th Kashiwara operator widetildeE_ind
  to  v. Here the Kashiwara operators are different from the ones described in
  Section 2.6. We refer to [J96], 9.2 for the definition of the operators used
  here.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("B",2) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> v:= Falpha( V, Basis(V)[2], 2 );
    (q^2)*F1*F4*v0+F2*v0
    gap> Ealpha( V, v, 2 );
    F1*v0
  ------------------------------------------------------------------
  
  3.10-11 CrystalBasis
  
  > CrystalBasis( V ) _______________________________________________attribute
  
  Here  V  is  a  finite-dimensional  left  module over a quantized enveloping
  algebra.  This  function  returns  the canonical, or crystal basis of V (see
  Section 2.6).
  
  This  function  only  works for modules for which WeightsAndVectors (3.8-14)
  works.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 2 ) );;
     gap> V:= HighestWeightModule( U, [1,1] );
     <16-dimensional left-module over QuantumUEA( <root system of type B2>, Qpar
    = q )>
     gap>  CrystalBasis( V );
     Basis( <16-dimensional left-module over QuantumUEA( <root system of type B
     2>, Qpar = q )>, [ 1*v0, F1*v0, F4*v0, F1*F4*v0, (q^2)*F1*F4*v0+F2*v0, F2*F4*v0,
    (q)*F2*F4*v0+F3*v0, (-q^-4)*F1*F2*v0, (-q^-1)*F1*F3*v0+(-q^-3)*F2^(2)*v0,
    (-q^-2)*F2^(2)*v0, F3*F4*v0, (-q^-4)*F2*F3*v0+(-q^-2)*F2^(2)*F4*v0,
    (-q^-2)*F2*F3*v0, (q^-4)*F2^(3)*v0, (-q^-1)*F3^(2)*v0, (q^-5)*F2^(2)*F3*v0 ] )
  ------------------------------------------------------------------
  
  3.10-12 CrystalVectors
  
  > CrystalVectors( V ) _____________________________________________attribute
  
  Here  V  is  a  finite-dimensional  left  module over a quantized enveloping
  algebra.  Let  C  be  the  crystal  basis of V (i.e., output by CrystalBasis
  (3.10-11)).  This function returns a list of cosets of the basis elements of
  C modulo qL, where L is the Z[q]-lattice spanned by C.
  
  The coset of a vector v is printed as <v>.
  
  The crystal vectors are used to construct the point set of the crystal graph
  of V (CrystalGraph:for a module (???CrystalGraph:for a module???)).
  
  This  function  only  works for modules for which WeightsAndVectors (3.8-14)
  works.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 2 ) );;
    gap> V:= HighestWeightModule( U, [1,1] );
    <16-dimensional left-module over QuantumUEA( <root system of type B
    2>, Qpar = q )>
    gap> CrystalVectors( V );
    [ <1*v0>, <F1*v0>, <F4*v0>, <F2*v0>, <F1*F4*v0>, <F3*v0>,
      <(-q^-4)*F1*F2*v0>, <F2*F4*v0>, <F1*F3*v0>, <F3*F4*v0>,
      <(-q^-1)*F1*F3*v0+(-q^-3)*F2^(2)*v0>, <(-q^-4)*F2*F3*v0+(-q^-2)*F2^(2)*F
        4*v0>, <F2^(2)*F4*v0>, <(q^-4)*F2^(3)*v0>, <(-q^-1)*F3^(2)*v0>,
      <(q^-5)*F2^(2)*F3*v0> ]
  ------------------------------------------------------------------
  
  3.10-13 Falpha
  
  > Falpha( v, ind ) ________________________________________________operation
  
  Here v is a crystal vector, i.e., an element of CrystalVectors( V ), where V
  is  a left module over a quantized enveloping algebra. This function returns
  the  result  of applying the ind-th Kashiwara operator widetildeF_alpha_ind}
  to v. The result is fail if widetildeF_alpha_ind}(v)=0.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 2 ) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> c:=CrystalVectors( V );;
    gap> Falpha( c[2], 2 );
    <F2*v0>
    gap> Falpha( c[3], 2 );
    fail
    gap> Falpha( Falpha( Falpha( c[1], 1 ), 2 ), 1 );
    fail
    gap> p:= DominantLSPath( RootSystem( "B", 2 ), [1,1] );
    <LS path of shape [ 1, 1 ] ending in [ 1, 1 ] >
    gap> Falpha( Falpha( Falpha( p, 1 ), 2 ), 1 );
    fail
  ------------------------------------------------------------------
  
  The  last  part  of  this  example  is  an illustration of the fact that the
  crystal  graph of a highest-weight module can be obtained by the path method
  (see Section 2.7).
  
  3.10-14 Ealpha
  
  > Ealpha( v, ind ) ________________________________________________operation
  
  Here v is a crystal vector, i.e., an element of CrystalVectors( V ), where V
  is  a left module over a quantized enveloping algebra. This function returns
  the  result  of applying the ind-th Kashiwara operator widetildeE_alpha_ind}
  to v. The result is fail if widetildeE_alpha_ind}(v)=0.
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem( "B", 2 ) );;
    gap> V:= HighestWeightModule( U, [1,1] );;
    gap> c:=CrystalVectors( V );;
    gap> Ealpha( c[3], 1 );
    fail
    gap> Ealpha( c[3], 2 );
    <1*v0>
  ------------------------------------------------------------------
  
  3.10-15 CrystalGraph
  
  > CrystalGraph( V ) ________________________________________________function
  
  Returns  the crystal graph of the module V. The points of this graph are the
  cosets output by CrystalVectors (3.10-12). The edges work in the same way as
  in  CrystalGraph:for root system and weight (???CrystalGraph:for root system
  and weight???).
  
  ---------------------------  Example  ----------------------------
    gap> U:= QuantizedUEA( RootSystem("A",2) );;
    gap> V1:= HighestWeightModule( U, [1,0] );;
    gap> V2:= HighestWeightModule( U, [0,1] );;
    gap> W:= TensorProductOfAlgebraModules( V1, V2 );;
    gap> CrystalGraph( W );
    rec(
      points := [ <1*(1*v0<x>1*v0)>, <1*(F1*v0<x>1*v0)>, <1*(1*v0<x>F3*v0)>,
          <1*(1*v0<x>F2*v0)+q^-1*(F2*v0<x>1*v0)>,
          <-q^-1*(1*v0<x>F2*v0)+q^-1*(F1*v0<x>F3*v0)>, <1*(F2*v0<x>F3*v0)>,
          <-q^-1*(F1*v0<x>F2*v0)>, <-q^-1*(F2*v0<x>F2*v0)>,
          <-q^-3*(1*v0<x>F2*v0)+-q^-1*(F1*v0<x>F3*v0)+1*(F2*v0<x>1*v0)> ],
      edges := [ [ [ 1, 2 ], 1 ], [ [ 1, 3 ], 2 ], [ [ 2, 4 ], 2 ],
          [ [ 3, 5 ], 1 ], [ [ 4, 6 ], 2 ], [ [ 5, 7 ], 1 ], [ [ 6, 8 ], 1 ],
          [ [ 7, 8 ], 2 ] ] )
  ------------------------------------------------------------------
  
  
  3.11 Universal enveloping algebras
  
  Here  we describe functions for connecting a quantized enveloping algebra to
  the corresponding universal enveloping algebra.
  
  3.11-1 UEA
  
  > UEA( L ) ________________________________________________________attribute
  
  This  function  returns the universal enveloping algebra u of the semisimple
  Lie  algebra  L. The generators of u are the generators of a Kostant lattice
  in the universal enveloping algebra (these generators are obtained from L by
  LatticeGeneratorsInUEA( L ), see the GAP reference manual).
  
  ---------------------------  Example  ----------------------------
    gap> L:= SimpleLieAlgebra( "B", 2, Rationals );
    <Lie algebra of dimension 10 over Rationals>
    gap> u:= UEA( L );
    <algebra over Rationals, with 10 generators>
    gap> g:= GeneratorsOfAlgebra( u );
    [ y1, y2, y3, y4, x1, x2, x3, x4, ( h9/1 ), ( h10/1 ) ]
  ------------------------------------------------------------------
  
  3.11-2 UnderlyingLieAlgebra
  
  > UnderlyingLieAlgebra( u ) _______________________________________attribute
  
  For  a  universal  enveloping  algebra  u  constructed by UEA (3.11-1), this
  returns the corresponding semisimple Lie algebra
  
  ---------------------------  Example  ----------------------------
    gap> L:= SimpleLieAlgebra( "B", 2, Rationals );;
    gap> u:= UEA( L );;
    gap> UnderlyingLieAlgebra( u );
    <Lie algebra of dimension 10 over Rationals>
  ------------------------------------------------------------------
  
  3.11-3 HighestWeightModule
  
  > HighestWeightModule( u, hw ) ____________________________________operation
  
  For  a  universal  enveloping  algebra  u  constructed by UEA (3.11-1), this
  returns the irreducible highest weight module over u with highest weight hw,
  which must be dominant. This module is the same as the corresponding highest
  weight  module  over  the  semisimple  Lie  algebra,  but  in  this case the
  enveloping algebra u acts.
  
  ---------------------------  Example  ----------------------------
    gap> L:= SimpleLieAlgebra( "B", 2, Rationals );;
    gap> u:= UEA( L );;
    gap> HighestWeightModule( u, [2,3] );
    <140-dimensional left-module over <algebra over Rationals, with
    10 generators>>
  ------------------------------------------------------------------
  
  3.11-4 QUEAToUEAMap
  
  > QUEAToUEAMap( L ) _______________________________________________attribute
  
  Here  L  is  a  semisimple  Lie  algebra.  Set  u  :=  UEA(  L  ),  and U :=
  QuantizedUEA(  L  )  (so  u,  U  are  the  universal enveloping algebra, and
  "generic"   quantized   enveloping   algebra   of   L   respectively).  Then
  QUEAToUEAMap(  L  ) returns the algebra homomorphism from U to u obtained by
  mapping  q  to  1,  a  generator  Fi,  corresponding to a simple root to the
  generator  yi  (corresponding  to the same simple root), and likewise for Ei
  and xi. This means that Ki is mapped to one, and [ Ki : s ] to hi choose s.
  
  The canonical basis of U is mapped to the canonical basis of u.
  
  ---------------------------  Example  ----------------------------
    gap> L:= SimpleLieAlgebra( "B", 2, Rationals );;
    gap> f:= QUEAToUEAMap( L );
    <mapping: QuantumUEA( <root system of rank
    2>, Qpar = q ) -> Algebra( Rationals, [ y1, y2, y3, y4, x1, x2, x3, x4,
      ( h9/1 ), ( h10/1 ) ] ) >
    gap> U:= Source( f );
    QuantumUEA( <root system of rank 2>, Qpar = q )
    gap> u:= Range( f );
    <algebra over Rationals, with 10 generators>
    gap> B:= CanonicalBasis( U );;
    gap> p:= PBWElements( B, [1,2] );
    [ F1*F4^(2), (q+q^3)*F1*F4^(2)+F2*F4, (q^4)*F1*F4^(2)+(q)*F2*F4+F3 ]
    gap> pu:= List( p, x -> Image( f, x ) );
    [ y1*y2^(2), 2*y1*y2^(2)+y2*y3-2*y4, y1*y2^(2)+y2*y3-1*y4 ]
    gap> V:= HighestWeightModule( u, [2,1] );
    <40-dimensional left-module over <algebra over Rationals, with
    10 generators>>
    gap> List( pu, x -> x^Basis(V)[1] );
    [ 0*v0, y2*y3*v0+-2*y4*v0, y2*y3*v0+-1*y4*v0 ]
    # Which gives us a piece of the canonical basis of V.
  ------------------------------------------------------------------