Quelle  quagroup.xml   Sprache: XML

From Section <Ref Sect="sec2.2"/> we recall that <Math>P</Math> denotes the weight 
lattice. Let <Math>P_{\mathbb{R}}</Math> be the vector space over <Math>\mathbb{R}</Math> spanned 
by <Math>P</Math>. Let <Math>\Pi</Math> be the set of all piecewise linear paths 
<Math>\xi : [0,1]\to P_{\mathbb{R}} </Math>, such that <Math>\xi(0)=0</Math>. For <Math>\alpha\in\Delta</Math> 
Littelmann defined operators <Math>f_{\alpha}, e_{\alpha} : \Pi \to \Pi\cup \{0\}</Math>. 
Let <Math>\lambda</Math> be a dominant weight and let <Math>\xi_{\lambda}</Math> be the path joining 
<Math>\lambda</Math> and the origin by a straight line. Let <Math>\Pi_{\lambda}</Math> be the set 
of all nonzero <Math>f_{\alpha_{i_1}}\cdots f_{\alpha_{i_m}}(\xi_{\lambda})</Math> for 
<Math>m\geq 0</Math>. Then <Math>\xi(1)\in P</Math> for all <Math>\xi\in \Pi_{\lambda}</Math>. Let <Math>\mu\in P</Math> 
be a weight, and let <Math>V(\lambda)</Math> be the highest-weight module over 
<Math>U_q(\mathfrak{g})</Math> of highest weight <Math>\lambda</Math>. A theorem of Littelmann 
states that the number of paths <Math>\xi\in \Pi_{\lambda}</Math> such that <Math>\xi(1)=\mu</Math> 
is equal to the dimension of the weight space of weight <Math>\mu</Math> in <Math>V(\lambda)</Math> 
(<Cite Key="L95"/>, Theorem 9.1).<P/> 
All paths appearing in <Math>\Pi_{\lambda}</Math> are so-called Lakshmibai-Seshadri 
paths (LS-paths for short). They are defined as follows. Let <Math>\leq</Math> denote 
the Bruhat order on <Math>W(\Phi)</Math>. For <Math>\mu,\nu\in W(\Phi)\cdot \lambda</Math> (the 
orbit of <Math>\lambda</Math> under the action of <Math>W(\Phi)</Math>), write <Math>\mu\leq \nu</Math> if 
<Math>\tau\leq\sigma</Math>, where <Math>\tau,\sigma\in W(\Phi)</Math> are the unique elements 
of minimal length such that <Math>\tau(\lambda)=\mu</Math>, <Math>\sigma(\lambda)= \nu</Math>. 
Now a rational path of shape <Math>\lambda</Math> is a pair <Math>\pi=(\nu,a)</Math>, where 
<Math>\nu=(\nu_1,\ldots, \nu_s)</Math> is a sequence of elements of <Math>W(\Phi)\cdot 
\lambda</Math>, such that <Math>\nu_i> \nu_{i+1}</Math> and <Math>a=(a_0=0, a_1, \cdots ,a_s=1)</Math> 
is a sequence of rationals such that <Math>a_i <a_{i+1}</Math>. The path <Math>\pi</Math> 
corresponding to these sequences is given by 
<Display> \pi(t) =\sum_{j=1}^{r-1} (a_j-a_{j-1})\nu_j + \nu_r(t-a_{r-1})</Display> 
for <Math>a_{r-1}\leq t\leq a_r</Math>. Now an LS-path of shape <Math>\lambda</Math> is a rational 
path satisfying a certain integrality condition (see 
<Cite Key="L94"/>, <Cite Key="L95"/>). We note that the path <Math>\xi_{\lambda} 
= ( (\lambda), (0,1) )</Math> joining the origin and <Math>\lambda</Math> by a straight line 
is an LS-path.<P/> 
Now from <Cite Key="L94"/>, <Cite Key="L95"/> we transcribe the following: 
<Enum> 
<Item> Let <Math>\pi</Math> be an LS-path. Then <Math>f_{\alpha}\pi</Math> is an LS-path or <Math>0</Math>; 
and the same holds for <Math>e_{\alpha}\pi</Math>. </Item>
<Item> The action of <Math>f_{\alpha},e_{\alpha}</Math> can easily be described 
combinatorially (see <Cite Key="L94"/>). </Item> 
<Item> The endpoint of an LS-path is an integral weight. </Item> 
<Item> Let <Math>\pi=(\nu,a)</Math> be an LS-path. Then by <Math>\phi(\pi)</Math> we denote the 
unique element <Math>\sigma</Math> of <Math>W(\Phi)</Math> of shortest length such that 
<Math>\sigma(\lambda)=\nu_1</Math>. </Item>
</Enum>
Let <Math>\lambda</Math> be a dominant weight. Then we define a labeled directed graph 
<Math>\Gamma</Math> as follows. The points of <Math>\Gamma</Math> are the paths in <Math>\Pi_{\lambda}</Math>. 
There is an edge with label <Math>\alpha\in\Delta</Math> from <Math>\pi_1</Math> to <Math>\pi_2</Math> if 
<Math>f_{\alpha}\pi_1 =\pi_2</Math>. Now by <Cite Key="K96"/> this graph <Math>\Gamma</Math> is 
isomorphic to the crystal graph of the highest-weight module with highest 
weight <Math>\lambda</Math>. So the path model provides an efficient way of computing 
the crystal graph of a highest-weight module, without constructing the module 
first. Also we see that <Math>f_{\alpha_{i_1}}\cdots f_{\alpha_{i_r}}\xi_{\lambda}
=0</Math> is equivalent to <Math>\widetilde{F}_{\alpha_{i_1}}\cdots \widetilde{F}_ 
{\alpha_{i_r}}v_{\lambda}=0</Math>, where <Math>v_{\lambda}\in V(\lambda)</Math> is a 
highest weight vector (or rather the image of it in <Math>\mathcal{L}(\lambda)/
q\mathcal{L} (\lambda)</Math>), and the <Math>\widetilde{F}_{\alpha_k}</Math> are the 
Kashiwara operators on <Math>\mathcal{B}(\lambda)</Math> (see Section 
<Ref Sect="sec2.6"/>).

</Section>

<Section> <Heading> Notes</Heading>

I refer to <Cite Key="H90"/> for more information on Weyl groups, and to 
<Cite Key="S01"/> for an overview of algorithms for computing with weights, 
Weyl groups and their elements.<P/> 
For general introductions into the theory of quantized enveloping algebras I 
refer to <Cite Key="C98"/>, <Cite Key="J96"/> (from where most of the material 
of this chapter is taken), <Cite Key="L92"/>, <Cite Key="L93"/>, 
<Cite Key="R91"/>. I refer to the papers by Littelmann (<Cite Key="L94"/>, 
<Cite Key="L95"/>, <Cite Key="L98"/>) for more information on the path model. 
The paper by Kashiwara (<Cite Key="K96"/>) contains a proof of the connection 
between path operators and Kashiwara operators.<P/> 
Finally, I refer to <Cite Key="G01"/> (on computing with PBW-type bases), 
<Cite Key="G02"/> (computation of elements of the canonical basis) for an 
account of some of the algorithms used in <Package>QuaGroup</Package>.

</Section>

</Chapter>

<Chapter Label="chap3"> <Heading>QuaGroup</Heading>

In this chapter we describe the functionality provided by 
<Package>QuaGroup</Package>.

<Section Label="sec:globcst"> <Heading>Global constants</Heading>

<ManSection> 
        
<Var Name="QuantumField"/>
<Description>
This is the field <M>Q(q)</M> of rational functions in <M>q</M>,
over <M>Q</M>.
<Example><![CDATA[
gap> QuantumField;
QuantumField
]]></Example>
</Description>
</ManSection>
   
<ManSection> 
        
<Var Name="_q"/>
<Description>
This is an indeterminate; <A>QuantumField</A> is the field of rational 
functions in this  indeterminate. The identifier <A>&uscore;q</A> is fixed 
once the package <Package>QuaGroup</Package> is loaded.  The  symbol 
<A>&uscore;q</A> is chosen (instead of <A>q</A>) in order to avoid potential
name clashes. We note that <A>&uscore;q</A> is printed as <A>q</A>.
<Example><![CDATA[
gap> _q;
q
gap> _q in QuantumField;
true
]]></Example>
</Description>
</ManSection>

</Section>

    
<Section> <Heading>Gaussian integers</Heading>
      
<ManSection> 
        
<Oper Name="GaussNumber" Arg="n, par"/>
<Description>
This function computes for the integer <A>n</A> the Gaussian integer 
<M>[n]_{v=<A>par</A>}</M> (cf. Section <Ref Sect="sec2.1"/>).
<Example><![CDATA[
gap> GaussNumber( 4, _q );
q^3+q+q^-1+q^-3
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="GaussianFactorial" Arg="n, par"/>
<Description>
This function computes for the integer <A>n</A> the Gaussian factorial
<M>[n]!_{v=<A>par</A>}</M>.
<Example><![CDATA[
gap> GaussianFactorial( 3, _q );
q^3+2*q+2*q^-1+q^-3
gap> GaussianFactorial( 3, _q^2 );
q^6+2*q^2+2*q^-2+q^-6
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="GaussianBinomial" Arg="n, k, par"/>
<Description>
This  function  computes  for  two  integers <A>n</A> and <A>k</A> the 
Gaussian binomial <A>n</A> choose <A>k</A>, where the parameter <M>v</M> 
is replaced by <A>par</A>.
<Example><![CDATA[
gap> GaussianBinomial( 5, 2, _q^2 );
q^12+q^8+2*q^4+2+2*q^-4+q^-8+q^-12
]]></Example>
</Description>
</ManSection>

</Section>
  
<Section> <Heading>Roots and root systems</Heading>

In  this  section  we describe some functions for dealing with root systems.
These functions supplement the ones already present in the &GAP; library.

<ManSection> 
<Oper Name="RootSystem" Arg="type, rank"/>
<Oper Name="RootSystem" Arg="list"/>
<Description>
Here  <A>type</A>  is  a capital letter between <A>"A"</A> and <A>"G"</A>, 
and <A>rank</A> is a positive integer (<M>\geq 1</M> if <A>type="A"</A>, 
<M>\geq 2</M> if <A>type="B"</A>, <A>"C"</A>, <M>\geq 4</M> if 
<A>type="D"</A>, <M>6,7,8</M> if <A>type="E"</A>,  <M>4</M> if 
<A>type="F"</A>, and <M>2</M> if <A>type="G"</A>). This function returns 
the root system  of  type  <A>type</A>  and  rank <A>rank</A>. In the second 
form <A>list</A> is a list of types and ranks, e.g.,  
<A>[ "B", 2, "F", 4, "D", 7 ]</A>. <P/>
The root system constructed by this function comes with he attributes
<A>PositiveRoots</A>, <A>NegativeRoots</A>, <A>SimpleSystem</A>, 
<A>CartanMatrix</A>, <A>BilinearFormMat</A>. Here the attribute 
<A>SimpleSystem</A> contains a set of simple roots, written as
unit vectors. <A>PositiveRoots</A> is a list of the positive roots, written as
linear combinations of the simple roots, and likewise for <A>NegativeRoots</A>.
<A>CartanMatrix( R )</A> is the Cartan matrix of the root system <A>R</A>, 
where the entry on position <M>( i, j )</M> is given by <M>\langle \alpha_i, 
\alpha_j^{\vee}\rangle</M> where <M>\alpha_i</M> is the <M>i</M>-th simple root. 
<A>BilinearFormMat( R )</A> is the matrix of the bilinear form,
where the entry on position <M>( i, j )</M> is given by <M>( \alpha_i, 
\alpha_j )</M> (see Section <Ref Sect="sec2.2"/>).<P/>
<A>WeylGroup( R )</A> returns the Weyl group of the root system <A>R</A>. 
We refer to the &GAP; reference manual for an overview of the functions for 
Weyl groups in the &GAP; library. We mention the functions 
<A>ConjugateDominantWeight( W, wt )</A> (returns the dominant weight in the 
<A>W</A>-orbit of the weight <A>wt</A>), and <A>WeylOrbitIterator( W, wt )</A>
(returns an iterator for the <A>W</A>-orbit containing the weight <A>wt</A>). 
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). <P/>
Also we mention the function <A>PositiveRootsAsWeights( R )</A> that returns 
the positive roots of <A>R</A> written as weights, i.e., as linear 
combinations of the fundamental weights.
<Example><![CDATA[
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>
gap> # 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 ] ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="BilinearFormMatNF" Arg="R"/>
<Description>
This  is  the  matrix of the <Q>normalized</Q> bilinear form. This means 
that all diagonal  entries  are  even,  and  2  is the minimum value 
occurring on the diagonal. If <A>R</A> is a root system constructed by 
<Ref Oper="RootSystem"/>, then this is equal to <A>BilinearFormMat( R )</A>.
</Description>
</ManSection>

<ManSection>         
<Attr Name="PositiveRootsNF" Arg="R"/>
<Description>
This  is  the list of positive roots of the root system <A>R</A>, written 
as linear combinations  of the simple roots. This means that the simple roots 
are unit vectors. If <A>R</A> is a root system constructed by 
<Ref Oper="RootSystem"/>, then this is equal to <A>PositiveRoots( R )</A>. <P/>
One  of  the  reasons  for  writing  the  positive  roots  like  this is the
following.  Let  <A>a, b</A> be two elements of <A>PositiveRootsNF( R )</A>, 
and let <A>B</A> be the  matrix  of  the bilinear form. Then 
<A>a*( B*b )</A> is the result of applying the bilinear form to <A>a, b</A>.

<Example><![CDATA[
gap> R:= RootSystem( SimpleLieAlgebra( "B", 2, Rationals ) );;
gap> PositiveRootsNF( R );
[ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ], [ 1, 2 ] ]
gap> # We note that in this case PositiveRoots( R ) will give the
gap> # positive roots in a different format.
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="SimpleSystemNF" Arg="R"/>
<Description>
This  is  the list of simple roots of <A>R</A>, written as unit vectors 
(this means that  they  are  elements  of  <A>PositiveRootsNF(  R )</A>). 
If <A>R</A> is a root system constructed by <Ref Oper="RootSystem"/>, then 
this is equal to <A>SimpleSystem( R )</A>.
</Description>
</ManSection>

<ManSection>         
<Attr Name="PositiveRootsInConvexOrder" Arg="R"/>
<Description>
This  function  returns  the  positive  roots  of  the root system <A>R</A>, 
in the <Q>convex</Q>  order. Let <M>w_0=s_1\cdots s_t</M> be a reduced 
expression of the longest element  in  the  Weyl  group. Then the <M>k</M>-th 
element of the list returned by this function is <M>s_1\cdots s_{k-1}(\alpha_k)
</M>. (Where the reduced expression used is  the one returned by 
<A>LongestWeylWord( R )</A>.) If <M>\alpha</M>, <M>\beta</M> and 
<M>\alpha+\beta</M> are  positive  roots,  then <M>\alpha+\beta</M> occurs 
between <M>\alpha</M> and <M>\beta</M> (whence the name convex order).<P/>
In  the  output all roots are written in <Q>normal form</Q>, i.e., as 
elements of <A>PositiveRootsNF( R )</A>.

<Example><![CDATA[
gap> R:= RootSystem( "G", 2 );;
gap> PositiveRootsInConvexOrder( R );
[ [ 1, 0 ], [ 3, 1 ], [ 2, 1 ], [ 3, 2 ], [ 1, 1 ], [ 0, 1 ] ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="SimpleRootsAsWeights" Arg="R"/>
<Description>
Returns   the  simple  roots  of  the  root  system  <A>R</A>,  written  as  
linear combinations of the fundamental weights.
<Example><![CDATA[
gap> R:= RootSystem( "A", 2 );;
gap> SimpleRootsAsWeights( R );
[ [ 2, -1 ], [ -1, 2 ] ]
]]></Example>
</Description>
</ManSection>

</Section>

<Section> <Heading>Weyl groups and their elements</Heading>

Now  we  describe  a  few functions that deal with reduced words in the Weyl
group of the root system <A>R</A>. These words are represented as lists of 
positive integers <M>i</M>,  denoting  the  <M>i</M>-th simple reflection 
(which corresponds to the <M>i</M>-th element of <A>SimpleSystem( R )</A>). 
For example <A>[ 3, 2, 1, 3, 1 ]</A> represents
the expression <M>s_3 s_2 s_1 s_3 s_1</M>.

<ManSection>         
<Oper Name="ApplyWeylElement" Arg="W, wt, wd"/>
<Description>
Here <A>wd</A> is a (not necessarily reduced) word in the Weyl group <A>W</A>, 
and <A>wt</A> is a weight  (written as integral linear combination of the 
simple weights). This function returns the result of applying <A>wd</A> to 
<A>wt</A>. For example, if <A>wt=</A><M>\mu</M>, and
<A>wd = [ 1, 2 ]</A> then this function returns <M>s_1s_2(\mu)</M> (where 
<M>s_i</M> is the simple reflection corresponding to the <M>i</M>-th simple 
root).

<Example><![CDATA[
gap> W:= WeylGroup( RootSystem( "G", 2 ) ) ;;
gap> ApplyWeylElement( W, [ -3, 7 ], [ 1, 1, 2, 1, 2 ] );
[ 15, -11 ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="LengthOfWeylWord" Arg="W, wd"/>
<Description>
Here  <A>wd</A>  is a word in the Weyl group <A>W</A>. This function returns 
the length of that word.

<Example><![CDATA[
gap> W:= WeylGroup( RootSystem( "F", 4 ) ) ;
<matrix group with 4 generators>
gap> LengthOfWeylWord( W, [ 1, 3, 2, 4, 2 ] );
3
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="LongestWeylWord" Arg="R"/>
<Description>
Here  <A>R</A>  is  a root system. <A>LongestWeylWord( R )</A> returns the 
longest word in the Weyl group of <A>R</A>. <P/>
If this function is called for a root system <A>R</A>, 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 <A>SetLongestWeylWord( R, wd )</A>, where <A>wd</A> is a reduced 
expression of the longest element in the Weyl group. Note that you will have 
to do this before calling <A>LongestWeylWord</A>,  or  any  function  that 
may call <A>LongestWeylWord</A> (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 <Ref Oper="LengthOfWeylWord"/>). <P/>
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><![CDATA[
gap> R:= RootSystem( "G", 2 );;
gap> LongestWeylWord( R );
[ 1, 2, 1, 2, 1, 2 ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="ReducedWordIterator" Arg="W, wd"/>
<Description>
Here  <A>W</A>  is  a  Weyl  group, and <A>wd</A> a reduced word. This 
function returns an iterator for the set of reduced words that represent the 
same element as <A>wd</A>. The elements are output in ascending 
lexicographical order.

<Example><![CDATA[
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
]]></Example>
So there are 2144892 reduced expressions for the longest element in the Weyl
group of type <M>F_4</M>.
</Description>
</ManSection>

<ManSection>         
<Oper Name="ExchangeElement" Arg="W, wd, ind"/>
<Description>
Here  <A>W</A>  is a Weyl group, and <A>wd</A> is a <E>reduced</E> word in 
<A>W</A>, and <A>ind</A> is an index between  1  and  the rank of the root 
system. Let <A>v</A> denote the word obtained from <A>wd</A> by adding 
<A>ind</A> at the end. This function <E>assumes</E> that the length of <A>v</A>
is  one  less  than the length of <A>wd</A>, and returns a reduced expression 
for <A>v</A> that is obtained from <A>wd</A> by deleting one entry. Nothing is 
guaranteed of the output if the length of <A>v</A> is bigger than the length 
of <A>wd</A>.

<Example><![CDATA[
gap> R:= RootSystem( "G", 2 );;
gap> wd:= LongestWeylWord( R );;
gap> ExchangeElement( WeylGroup(R), wd, 1 );
[ 2, 1, 2, 1, 2 ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="GetBraidRelations" Arg="W, wd1, wd2"/>
<Description>
Here  <A>W</A> is a Weyl group, and <A>wd1</A>, <A>wd2</A> are two reduced 
words representing the same  element in <A>W</A>. This function returns a 
list of braid relations that can be  applied  to <A>wd1</A> to obtain 
<A>wd2</A>. 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 <A>wd</A> be the word 
<A>[ 1, 2, 1, 3, 2, 1 ]</A> and  let  <A>r = [ 3, 3, 4, 1 ]</A> be a relation. 
Then the result of applying <A>r</A> to <A>wd</A>  is  
<A>[ 1, 2, 3, 1, 2, 1]</A>  (i.e., on the third position we put a 3, and on
the fourth position a 1).<P/>
We  note that the function does not check first whether <A>wd1</A> and 
<A>wd2</A> represent the  same  element  in  <A>W</A>. If this is not the 
case, then an error will occur during the execution of the function, or it 
will produce wrong output.

<Example><![CDATA[
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 ] ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="LongWords" Arg="R"/>
<Description>
For  a  root system <A>R</A> this returns a list of triples (of length equal 
to the rank  of  <A>R</A>).  Let  <A>t</A>  be  the <A>k</A>-th triple 
occurring in this list. The first element  of  <A>t</A>  is  an expression 
for the longest element of the Weyl group, starting  with  <A>k</A>.  The  
second element is a list of braid relations, moving
this expression to the value of <A>LongestWeylWord( R )</A>. The third 
element is a list of braid relations performing the reverse transformation.

<Example><![CDATA[
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 ] ] ]
]]></Example>
</Description>
</ManSection>

</Section>

<Section> <Heading>Quantized enveloping algebras </Heading>

In  <Package>QuaGroup</Package>  we  deal with two types of quantized 
enveloping algebra. First there   are  the  quantized  enveloping  algebras  
defined  over  the  field <Ref Var="QuantumField"/>.  We  say that these 
algebras are <Q>generic</Q> quantized enveloping  algebras,  in  
<Package>QuaGroup</Package>  they  have  the category <A>IsGenericQUEA</A>.
Secondly,  we  deal  with the quantized enveloping algebras that are defined
over a different field.

<ManSection>         
<Attr Name="QuantizedUEA" Arg="R"/>
<Oper Name="QuantizedUEA" Arg="R, F, v"/>
<Attr Name="QuantizedUEA" Arg="L"/>
<Oper Name="QuantizedUEA" Arg="L, F, v"/>
<Description>
In  the  first  two  forms  <A>R</A>  is  a  root system. With only 
<A>R</A> as input, the corresponding  generic  quantized  enveloping  
algebra is constructed. It is stored as an attribute of <A>R</A> (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 <A>RootSystem</A>. <P/>
The  attribute  <A>GeneratorsOfAlgebra</A>  contains  the  generators of a 
PBW-type basis  (see  Section  <Ref Sect="sec2.4"/>),  that  are  constructed  
relative to the reduced expression  for  the  longest element in the Weyl 
group that is contained in <A>LongestWeylWord(  R  )</A>.
We  refer  to  <Ref Oper="ObjByExtRep"/>  for a
description  of  the  construction  of  elements  of  a quantized enveloping
algebra. <P/>
The  call <A>QuantizedUEA( R, F, v )</A> returns the quantized universal 
enveloping algebra  with  quantum  parameter  <A>v</A>, which must lie in the 
field <A>F</A>. In this case the elements of <A>GeneratorsOfAlgebra</A> are 
the images of the generators of the corresponding generic quantized 
enveloping algebra. This means that if <A>v</A> is a root of unity, then the 
generators will not generate the whole algebra, but  rather  a  finite 
dimensional subalgebra (as for instance <M>E_i^k=0</M> for <M>k</M>
large  enough). It is possible to construct elements that do not lie in this
finite dimensional subalgebra using <Ref Oper="ObjByExtRep"/>. <P/>
In  the last two cases <A>L</A> must be a semisimple Lie algebra. The two 
calls are short for <A>QuantizedUEA( RootSystem( L ) )</A> and 
<A>QuantizedUEA( RootSystem( L ), F, v )</A> respectively.
<Example><![CDATA[
gap> # We construct the generic quantized enveloping algebra corresponding
gap> # 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, (-q+q^-1)*[ K1 ; 1 ]+K1, K2, 
  (-q+q^-1)*[ K2 ; 1 ]+K2, K3, (-q+q^-1)*[ K3 ; 1 ]+K3, K4, 
  (-q^3+q^-3)*[ K4 ; 1 ]+K4, E1, E2, E3, E4, E5, E6, E7, E8, E9 ]
gap> # These elements generate a PBW-type basis of U; the nine elements Fi,
gap> # 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 ] ]
gap> # So, for example, F5 is an element of weight -[ 0, 0, 3, 1 ].
gap> # We can also multiply elements; the result is written on the PBW-basis:
gap> g[17]*g[4];
(-1+q^-6)*F4*[ K4 ; 1 ]+(q^-3)*F4*K4
gap> # 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, (-E(3)+E(3)^2)*[ K1 ; 1 ]+K1, K2, 
  (-E(3)+E(3)^2)*[ K2 ; 1 ]+K2, E1, E2, E3 ]
]]></Example>
As  can  be  seen  in the example, every element of <M>U</M> is written as a 
linear combination  of  monomials in the PBW-generators; the generators of 
<M>U^-</M> come first, then the generators of <M>U^0</M>, and finally the 
generators of <M>U^+</M>.
</Description>
</ManSection>

<ManSection>         
<Oper Name="ObjByExtRep" Arg="fam, list"/>
<Description>
Here  <A>fam</A>  is  the  elements  family  of  a  quantized enveloping 
algebra <A>U</A>. Secondly,  <A>list</A>  is  a  list describing an element of 
<A>U</A>. We explain how this description  works.  First we describe an 
indexing system for the generators of  <A>U</A>. Let <A>R</A> be the root 
system of <A>U</A>. 
Let <A>t</A> be the number of positive roots, and  <A>rank</A>  the  rank of 
the root system. Then the generators of <A>U</A> are <A>Fk</A>, <A>Ki</A>
(and  its  inverse),  <A>Ek</A>,  for <A>k=1...t</A>, <A>i=1..rank</A>. 
(See Section <Ref Sect="sec2.4"/>; for the construction  of the <A>Fk</A>, 
<A>Ek</A>, the value of  <A>LongestWeylWord( R )</A> is used.) Now the index 
of <A>Fk</A> is <A>k</A>, and the 
index of <A>Ek</A> is <A>t+rank+k</A>. Furthermore, elements
of  the  algebra generated by the <A>Ki</A>, and its inverse, are written as 
linear combinations of products of <Q>binomials</Q>, as in Section  
<Ref Sect="sec2.5"/>. The element
<Display> K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix} </Display>
(where  <M>d=0,1</M>), is indexed as <A>[ t+i, d ]</A> (what happens to the 
<A>s</A> is described later). So an index is either an integer, or a list of 
two integers. <P/>
A  monomial  is  a list of indices, each followed by an exponent. First come
the  indices  of the <A>Fk</A>, (<A>1..t</A>), then come the lists of the form 
<A>[ t+i, d ]</A>, and finally the indices of the <A>Ek</A>. Each index is 
followed by an exponent. An index of the form <A>[ t+i, d ]</A> is followed 
by the <A>s</A> in the above formula. <P/>
The  second  argument  of  <A>ObjByExtRep</A>  is  a  list of monomials 
followed by coefficients. This function returns the element of <A>U</A> 
described by this list.<P/>
Finally we remark that the element
<Display> K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix} </Display>
is printed as <A>Ki[ Ki ; s ]</A> if <A>d=1</A>, and as <A>[ Ki ; s ]</A> 
if <A>d=0</A>.
<Example><![CDATA[
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^2+q^-1 ]
gap> ObjByExtRep( fam, list );
(q^2)*F2^(3)*[ K1 ; 8 ]*E1^(11)+(q^2+q^-1)*F1^(7)*F3^(5)*K2[ K2 ; 3 ]*E3^(9)
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="ExtRepOfObj" Arg="elm"/>
<Description>
For the element <A>elm</A> of a quantized enveloping algebra, this function 
returns the list that defines <A>elm</A> (see <Ref Oper="ObjByExtRep"/>).
<Example><![CDATA[
gap> U:= QuantizedUEA( RootSystem("A",2) );;
gap> g:= GeneratorsOfAlgebra(U);
[ F1, F2, F3, K1, (-q+q^-1)*[ K1 ; 1 ]+K1, K2, (-q+q^-1)*[ K2 ; 1 ]+K2, E1, 
  E2, E3 ]
gap> ExtRepOfObj( g[5] );
[ [ [ 4, 0 ], 1 ], -q+q^-1, [ [ 4, 1 ], 0 ], 1 ]
]]></Example>
</Description>
</ManSection>


<ManSection>         
<Attr Name="QuantumParameter" Arg="U"/>
<Description>
Returns the quantum parameter used in the definition of <A>U</A>.
<Example><![CDATA[
gap> R:= RootSystem("A",2);;
gap> U0:= QuantizedUEA( R, CF(3), E(3) );;
gap> QuantumParameter( U0 );
E(3)
]]></Example>
</Description>
</ManSection>


<ManSection>         
<Attr Name="CanonicalMapping" Arg="U"/>
<Description>
Here  <A>U</A>  is  a quantized enveloping algebra. Let <A>U0</A> denote
the corresponding <Q>generic</Q> quantized enveloping algebra. This function 
returns the mapping <A>U0 --> U</A>  obtained by mapping <A>q</A> (which is 
the quantum parameter of <A>U0</A>) to the quantum parameter of <A>U</A>.
<Example><![CDATA[
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 ]
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="WriteQEAToFile" Arg="U, file"/>
<Description>
Here  <A>U</A> is a quantized enveloping algebra, and file is a string 
containing the  name  of  a  file.  This function writes some data to 
<A>file</A>, that allows <Ref Oper="ReadQEAFromFile"/> to recover it.
<Example><![CDATA[
gap> U:= QuantizedUEA( RootSystem("A",3) );;
gap> WriteQEAToFile( U, "A3" );
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="ReadQEAFromFile" Arg="file"/>
<Description>
Here  <A>file</A>  is  a string containing the name of a file, to which a 
quantized enveloping algebra has been written by <Ref Oper="WriteQEAToFile"/>. 
This function recovers the quantized enveloping algebra.
<Example><![CDATA[
gap> U:= QuantizedUEA( RootSystem("A",3) );;
gap> WriteQEAToFile( U, "A3" );
gap> U0:= ReadQEAFromFile( "A3" );
QuantumUEA( <root system of type A3>, Qpar = q )
]]></Example>
</Description>
</ManSection>

</Section>


<Section> <Heading> Homomorphisms and automorphisms </Heading>

Here we describe functions for creating homomorphisms and
(anti)-automorphisms of a quantized enveloping algebra.

<ManSection>         
<Oper Name="QEAHomomorphism" Arg="U, A, list"/>
<Description>
Here  <A>U</A>  is  a  generic  quantized  enveloping  algebra  (i.e., 
with quantum parameter  <A>&uscore;q</A>),  <A>A</A>  is  an algebra with one 
over <A>QuantumField</A>, and <A>list</A> is a list  of  <A>4*rank</A> 
elements of <A>A</A> (where <A>rank</A> is the rank of the root system of
<A>U</A>).  On  the first rank positions there are the images of the 
<M>F_{\alpha}</M> (where the <M>\alpha</M>  are  simple  roots,  listed  
in the order in which they occur in <A>SimpleSystem(  R  )</A>). On the 
positions <A>rank+1...2*rank</A> are the images of the <M>K_{\alpha}</M>.   
On   the  positions  <A>2*rank+1...3*rank</A>  are  the  images  of  the
<M>K_{\alpha}^{-1}</M>,  and finally on the positions <A>3*rank+1...4*rank</A> 
occur the images of the <M>E_{\alpha}</M>. <P/>
This  function returns the homomorphism <A>U -> A</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><![CDATA[
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, (-q+q^-1)*[ K1 ; 1 ]+K1, K2, 
  (-q^3+q^-3)*[ K2 ; 1 ]+K2, 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 ] ]
gap> # We see that the simple roots of R occur on positions 6 and 1
gap> # in the list PositiveRootsInConvexOrder( S ); This means that we
gap> # 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, (-q+q^-1)*[ K1 ; 1 ]+K1, (-q^3+q^-3)*[ K2 ; 1 ]+K2, 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] );
(q^10-q^6-q^4+1)*F1*F6^(2)+(q^6-q^2)*F2*F6+(q^4)*F4
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="QEAAutomorphism" Arg="U, list"/>
<Oper Name="QEAAutomorphism" Arg="U, f"/>
<Description>
In  the  first  form <A>U</A> is a generic quantized enveloping algebra 
(i.e., with quantum  parameter  <A>&uscore;q</A>),  and  <A>list</A> is a 
list of <A>4*rank</A> elements of <A>U</A> (where <A>rank</A>  is  the  
rank  of  the  corresponding  root system). On the first <A>rank</A>
positions  there  are  the images of the <M>F_{\alpha}</M> (where the 
<M>\alpha</M> are simple roots, listed in the order in which they occur in 
<A>SimpleSystem( R )</A>). On the positions  <A>rank+1...2*rank</A>  are  
the images of the <M>K_{\alpha}</M>. On the positions
<A>2*rank+1...3*rank</A>  are  the  images  of  the  <M>K_{\alpha}^{-1}</M>, 
and finally on the positions <A>3*rank+1...4*rank</A> occur the images of 
the <M>E_{\alpha}</M>.<P/>
In the second form <A>U</A> is a non-generic quantized enveloping algebra, 
and <A>f</A> is an  automorphism  of the corresponding generic quantized 
enveloping algebra. The  corresponding automorphism of <A>U</A> is 
constructed. In this case <A>f</A> must not be  the  bar-automorphism  of the 
corresponding generic quantized enveloping algebra  (cf. 
<Ref Attr="BarAutomorphism"/>), as this automorphism doesn't work in the
non-generic case.<P/>
The image of an element <A>x</A> under an automorphism <A>f</A> is computed 
by <A>Image( f, x )</A>.  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 <A>QEAAutomorphism( U, list )</A>, where <A>list</A> is a list of 
pre-images). <P/>
Below we construct the automorphism <M>\omega</M> (cf. Section 
<Ref Sect="sec2.2"/>) of the quantized
enveloping  of  type  <M>A_3</M>,  when  the  quantum parameter is 
<A>&uscore;q</A>, and when the quantum parameter is a fifth root of unity.
<Example><![CDATA[
gap> # 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, (-q+q^-1)*[ K1 ; 1 ]+K1, K2, 
  (-q+q^-1)*[ K2 ; 1 ]+K2, K3, (-q+q^-1)*[ K3 ; 1 ]+K3, E1, E2, E3, E4, E5, 
  E6 ]
gap> # Now, for instance, we map F_{\alpha} to E_{\alpha}, where \alpha
gap> # is a simple root. In order to find where those F_{\alpha}, E_{\alpha}
gap> # are in the list of generators, we look at the list of positive roots
gap> # in convex order:
gap> PositiveRootsInConvexOrder( R );
[ [ 1, 0, 0 ], [ 1, 1, 0 ], [ 0, 1, 0 ], [ 1, 1, 1 ], [ 0, 1, 1 ], 
  [ 0, 0, 1 ] ]
gap> # So the simple roots occur on positions 1, 3, 6. This means that we
gap> # 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, (-q+q^-1)*[ K1 ; 1 ]+K1, (-q+q^-1)*[ K2 ; 1 ]+K2, 
  (-q+q^-1)*[ K3 ; 1 ]+K3, 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
gap> # f induces an automorphism of any non-generic quantized enveloping
gap> # 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
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="QEAAntiAutomorphism" Arg="U, list"/>
<Oper Name="QEAAntiAutomorphism" Arg="U, f"/>
<Description>
These   are  functions  for  constructing  anti-automorphisms  of  quantized
enveloping algebras. The same comments apply as for 
<Ref Oper="QEAAutomorphism"/>.
</Description>
</ManSection>

<ManSection>         
<Attr Name="AutomorphismOmega" Arg="U"/>
<Description>
This is the automorphism <M>\omega</M> (cf. Section <Ref Sect="sec2.2"/>).
<Example><![CDATA[
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) )>
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="AntiAutomorphismTau" Arg=""/>
<Description>
This is the anti-automorphism <M>\tau</M> (cf. Section <Ref Sect="sec2.2"/>).
<Example><![CDATA[
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) )>
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Attr Name="BarAutomorphism" Arg="U"/>
<Description>
This  is  the  automorphism <M>\bar{~}</M> defined in Section 
<Ref Sect="sec2.2"/>  Here <A>U</A> must be a generic quantized enveloping 
algebra.
<Example><![CDATA[
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
]]></Example>
</Description>
</ManSection>

<ManSection>         
<Oper Name="AutomorphismTalpha" Arg="U, ind"/>
<Description>
--> --------------------

--> maximum size reached

--> --------------------