Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/GAP/pkg/quagroup/doc/   (Algebra von RWTH Aachen Version 4.15.1©)  Datei vom 11.0.2024 mit Größe 153 kB image not shown  

SSL chap3.html   Sprache: HTML

 
 products/sources/formale Sprachen/GAP/pkg/quagroup/doc/chap3.html


<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (quagroup) - Chapter 3: QuaGroup</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap3"  onload="jscontent()">


<div class="chlinktop"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a>  <a href="chap1.html">1</a>  <a href="chap2.html">2</a>  <a href="chap3.html">3</a>  <a href="chapBib.html">Bib</a>  <a href="chapInd.html">Ind</a>  </div>

<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a>   <a href="chap0.html#contents">[Contents]</a>    <a href="chap2.html">[Previous Chapter]</a>    <a href="chapBib.html">[Next Chapter]</a>   </div>

<p id="mathjaxlink" class="pcenter"><a href="chap3_mj.html">[MathJax on]</a></p>
<p><a id="X80C9BD6584865157" name="X80C9BD6584865157"></a></p>
<div class="ChapSects"><a href="chap3.html#X80C9BD6584865157">3 <span class="Heading">QuaGroup</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7C202C54806653DE">3.1 <span class="Heading">Global constants</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8748A60A7AB09B0C">3.1-1 QuantumField</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87FCF1537A81E11D">3.1-2 _q</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X83804A6F84BB2387">3.2 <span class="Heading">Gaussian integers</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7985B6A67A30FDA1">3.2-1 GaussNumber</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7EF34AC07BDFEF20">3.2-2 GaussianFactorial</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F1A5A457926F3CF">3.2-3 GaussianBinomial</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X87064F787DEA9E21">3.3 <span class="Heading">Roots and root systems</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X80D15C027BB8029B">3.3-1 RootSystem</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79E8AE3A8739D11A">3.3-2 BilinearFormMatNF</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X853E620A79D796E7">3.3-3 PositiveRootsNF</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D2E78B678C73E69">3.3-4 SimpleSystemNF</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A5DFEAB7EC0D945">3.3-5 PositiveRootsInConvexOrder</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7A5BD2D77ED1BEDD">3.3-6 SimpleRootsAsWeights</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X798CE6777FC473DD">3.4 <span class="Heading">Weyl groups and their elements</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D738A0E85CD5C14">3.4-1 ApplyWeylElement</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X792A49A8808D1C64">3.4-2 LengthOfWeylWord</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X83851E7D7ED84A48">3.4-3 LongestWeylWord</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81FC70FA84F1B6E9">3.4-4 ReducedWordIterator</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8264626678D9F39A">3.4-5 ExchangeElement</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X84138DD47BBEA4E0">3.4-6 GetBraidRelations</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X800BB9837DCF1DBD">3.4-7 LongWords</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X81394E207F6AA6CF">3.5 <span class="Heading">Quantized enveloping algebras </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C263EA87C6E4F8A">3.5-1 QuantizedUEA</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E3D93D47AFDE8D4">3.5-2 ObjByExtRep</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8542B32A8206118C">3.5-3 ExtRepOfObj</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7879B74F7C77E930">3.5-4 QuantumParameter</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82B42CD279854DFC">3.5-5 CanonicalMapping</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87C302567A9B2AD3">3.5-6 WriteQEAToFile</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X874B8E4A83180063">3.5-7 ReadQEAFromFile</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X847A0459844B7A59">3.6 <span class="Heading"> Homomorphisms and automorphisms </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8185FE54820AA950">3.6-1 QEAHomomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81214E9B8532B06F">3.6-2 QEAAutomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79D886AB7B248F75">3.6-3 QEAAntiAutomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X851AE6987871E0E8">3.6-4 AutomorphismOmega</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E288BFE7FDF8BEA">3.6-5 AntiAutomorphismTau</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8576A5987AD999F0">3.6-6 BarAutomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8277D87D7D81AE75">3.6-7 AutomorphismTalpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DC17C2D8540FCED">3.6-8 DiagramAutomorphism</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7857704878577048"><code>3.6-9 \*</code></a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X832B6D897BDBC8A3">3.7 <span class="Heading">Hopf algebra structure</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8245FA64874E085D">3.7-1 TensorPower</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X783144818681D2E6">3.7-2 UseTwistedHopfStructure</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X811565FF83FA4847">3.7-3 ComultiplicationMap</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7985B7EF7E31C4DF">3.7-4 AntipodeMap</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8361876D8770FC06">3.7-5 CounitMap</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X8183A6857B0C3633">3.8 <span class="Heading">Modules</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7ED0FA2980330CE1">3.8-1 HighestWeightModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7B00688F82AACDD0">3.8-2 IrreducibleQuotient</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7B080C0078370E99">3.8-3 HWModuleByTensorProduct</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C03DC018016B93B">3.8-4 DIYModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X854FA09F7E07D2D0">3.8-5 TensorProductOfAlgebraModules</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7F0AED7A85D603A2">3.8-6 HWModuleByGenerator</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8565D4CD82EB2503">3.8-7 InducedQEAModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8680D0D67BACAE16">3.8-8 GenericModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82B42CD279854DFC">3.8-9 CanonicalMapping</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DCD17BF7B76E7CA">3.8-10 U2Module</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E1B059780BB2E09">3.8-11 MinusculeModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X79C8F1317C2E8C60">3.8-12 DualAlgebraModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87EBE47D86292754">3.8-13 TrivialAlgebraModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7929063E7C428331">3.8-14 WeightsAndVectors</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7EEEBA347A816827">3.8-15 HighestWeightsAndVectors</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X799E7D5981B9F14A">3.8-16 RMatrix</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X78E533D2813BDA9E">3.8-17 IsomorphismOfTensorModules</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X87FF182B86367CC4">3.8-18 WriteModuleToFile</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7DD49D8282C516B9">3.8-19 ReadModuleFromFile</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X83BBB99685FB9FB7">3.9 <span class="Heading">The path model</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8025E1918067B03C">3.9-1 DominantLSPath</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82EDAFAB7E81BD1F">3.9-2 Falpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X855C478587112804">3.9-3 Ealpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X820413E57DEDB0D1">3.9-4 LSSequence</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8573A4077DB4659F">3.9-5 WeylWord</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D06353282BE96C6">3.9-6 EndWeight</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8637218B80BDC906">3.9-7 CrystalGraph</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X827A177C8416C576">3.10 <span class="Heading"> Canonical bases </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8215C71E8361EE62">3.10-1 Falpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X814B1C7B7AF17B79">3.10-2 Ealpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C8EBFF5805F8C51">3.10-3 CanonicalBasis</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8233212A79D722FB">3.10-4 PBWElements</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X81631585816C4CCD">3.10-5 MonomialElements</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X782174177D696504">3.10-6 Strings</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X842A5CC07C3E5848">3.10-7 PrincipalMonomial</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7C04F75683D0A512">3.10-8 StringMonomial</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E67BE5D856C77DC">3.10-9 Falpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X855EFC817CFCE2C7">3.10-10 Ealpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X85A9229678572948">3.10-11 CrystalBasis</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X82CE52AB7E798902">3.10-12 CrystalVectors</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X80A534637D8F3210">3.10-13 Falpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7B9C76BF841FA70B">3.10-14 Ealpha</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7D7607BB81ADF579">3.10-15 CrystalGraph</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap3.html#X7875070C85DD4E8E">3.11 <span class="Heading"> Universal enveloping algebras </span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7E7B25307E6478CD">3.11-1 UEA</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7CA021E28527763E">3.11-2 UnderlyingLieAlgebra</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X8707EE2C8145701F">3.11-3 HighestWeightModule</a></span>
<span class="ContSS"><br /><span class="nocss">  </span><a href="chap3.html#X7AD80E5C7E015859">3.11-4 QUEAToUEAMap</a></span>
</div></div>
</div>

<h3>3 <span class="Heading">QuaGroup</span></h3>

<p>In this chapter we describe the functionality provided by <strong class="pkg">QuaGroup</strong>.</p>

<p><a id="X7C202C54806653DE" name="X7C202C54806653DE"></a></p>

<h4>3.1 <span class="Heading">Global constants</span></h4>

<p><a id="X8748A60A7AB09B0C" name="X8748A60A7AB09B0C"></a></p>

<h5>3.1-1 QuantumField</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantumField</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p>This is the field <span class="SimpleMath">Q(q)</span> of rational functions in <span class="SimpleMath">q</span>, over <span class="SimpleMath">Q</span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">QuantumField;</span>
QuantumField
</pre></div>

<p><a id="X87FCF1537A81E11D" name="X87FCF1537A81E11D"></a></p>

<h5>3.1-2 _q</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ _q</code></td><td class="tdright">( global variable )</td></tr></table></div>
<p>This is an indeterminate; <var class="Arg">QuantumField</var> is the field of rational functions in this indeterminate. The identifier <var class="Arg">_q</var> is fixed once the package <strong class="pkg">QuaGroup</strong> is loaded. The symbol <var class="Arg">_q</var> is chosen (instead of <var class="Arg">q</var>) in order to avoid potential name clashes. We note that <var class="Arg">_q</var> is printed as <var class="Arg">q</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">_q;</span>
q
<span class="GAPprompt">gap></span> <span class="GAPinput">_q in QuantumField;</span>
true
</pre></div>

<p><a id="X83804A6F84BB2387" name="X83804A6F84BB2387"></a></p>

<h4>3.2 <span class="Heading">Gaussian integers</span></h4>

<p><a id="X7985B6A67A30FDA1" name="X7985B6A67A30FDA1"></a></p>

<h5>3.2-1 GaussNumber</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GaussNumber</code>( <var class="Arg">n</var>, <var class="Arg">par</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This function computes for the integer <var class="Arg">n</var> the Gaussian integer <span class="SimpleMath">[n]_v=<var class="Arg">par</var></span> (cf. Section <a href="chap2.html#X7AAC838B7CEB5E54"><span class="RefLink">2.1</span></a>).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">GaussNumber( 4, _q );</span>
q^3+q+q^-1+q^-3
</pre></div>

<p><a id="X7EF34AC07BDFEF20" name="X7EF34AC07BDFEF20"></a></p>

<h5>3.2-2 GaussianFactorial</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GaussianFactorial</code>( <var class="Arg">n</var>, <var class="Arg">par</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This function computes for the integer <var class="Arg">n</var> the Gaussian factorial <span class="SimpleMath">[n]!_v=<var class="Arg">par</var></span>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">GaussianFactorial( 3, _q );</span>
q^3+2*q+2*q^-1+q^-3
<span class="GAPprompt">gap></span> <span class="GAPinput">GaussianFactorial( 3, _q^2 );</span>
q^6+2*q^2+2*q^-2+q^-6
</pre></div>

<p><a id="X7F1A5A457926F3CF" name="X7F1A5A457926F3CF"></a></p>

<h5>3.2-3 GaussianBinomial</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GaussianBinomial</code>( <var class="Arg">n</var>, <var class="Arg">k</var>, <var class="Arg">par</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This function computes for two integers <var class="Arg">n</var> and <var class="Arg">k</var> the Gaussian binomial <var class="Arg">n</var> choose <var class="Arg">k</var>, where the parameter <span class="SimpleMath">v</span> is replaced by <var class="Arg">par</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">GaussianBinomial( 5, 2, _q^2 );</span>
q^12+q^8+2*q^4+2+2*q^-4+q^-8+q^-12
</pre></div>

<p><a id="X87064F787DEA9E21" name="X87064F787DEA9E21"></a></p>

<h4>3.3 <span class="Heading">Roots and root systems</span></h4>

<p>In this section we describe some functions for dealing with root systems. These functions supplement the ones already present in the <strong class="pkg">GAP</strong> library.</p>

<p><a id="X80D15C027BB8029B" name="X80D15C027BB8029B"></a></p>

<h5>3.3-1 RootSystem</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RootSystem</code>( <var class="Arg">type</var>, <var class="Arg">rank</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ RootSystem</code>( <var class="Arg">list</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">type</var> is a capital letter between <var class="Arg">"A"</var> and <var class="Arg">"G"</var>, and <var class="Arg">rank</var> is a positive integer (<span class="SimpleMath">≥ 1</span> if <var class="Arg">type="A"</var>, <span class="SimpleMath">≥ 2</span> if <var class="Arg">type="B"</var>, <var class="Arg">"C"</var>, <span class="SimpleMath">≥ 4</span> if <var class="Arg">type="D"</var>, <span class="SimpleMath">6,7,8</span> if <var class="Arg">type="E"</var>, <span class="SimpleMath">4</span> if <var class="Arg">type="F"</var>, and <span class="SimpleMath">2</span> if <var class="Arg">type="G"</var>). This function returns the root system of type <var class="Arg">type</var> and rank <var class="Arg">rank</var>. In the second form <var class="Arg">list</var> is a list of types and ranks, e.g., <var class="Arg">[ "B", 2, "F", 4, "D", 7 ]</var>.</p>

<p>The root system constructed by this function comes with he attributes <var class="Arg">PositiveRoots</var>, <var class="Arg">NegativeRoots</var>, <var class="Arg">SimpleSystem</var>, <var class="Arg">CartanMatrix</var>, <var class="Arg">BilinearFormMat</var>. Here the attribute <var class="Arg">SimpleSystem</var> contains a set of simple roots, written as unit vectors. <var class="Arg">PositiveRoots</var> is a list of the positive roots, written as linear combinations of the simple roots, and likewise for <var class="Arg">NegativeRoots</var>. <var class="Arg">CartanMatrix( R )</var> is the Cartan matrix of the root system <var class="Arg">R</var>, where the entry on position <span class="SimpleMath">( i, j )</span> is given by <span class="SimpleMath">⟨ α_i, α_j^∨⟩</span> where <span class="SimpleMath">α_i</span> is the <span class="SimpleMath">i</span>-th simple root. <var class="Arg">BilinearFormMat( R )</var> is the matrix of the bilinear form, where the entry on position <span class="SimpleMath">( i, j )</span> is given by <span class="SimpleMath">( α_i, α_j )</span> (see Section <a href="chap2.html#X81394E207F6AA6CF"><span class="RefLink">2.2</span></a>).</p>

<p><var class="Arg">WeylGroup( R )</var> returns the Weyl group of the root system <var class="Arg">R</var>. We refer to the <strong class="pkg">GAP</strong> reference manual for an overview of the functions for Weyl groups in the <strong class="pkg">GAP</strong> library. We mention the functions <var class="Arg">ConjugateDominantWeight( W, wt )</var> (returns the dominant weight in the <var class="Arg">W</var>-orbit of the weight <var class="Arg">wt</var>), and <var class="Arg">WeylOrbitIterator( W, wt )</var> (returns an iterator for the <var class="Arg">W</var>-orbit containing the weight <var class="Arg">wt</var>). We write weights as integral linear combinations of fundamental weights, so in <strong class="pkg">GAP</strong> weights are represented by lists of integers (of length equal to the rank of the root system).</p>

<p>Also we mention the function <var class="Arg">PositiveRootsAsWeights( R )</var> that returns the positive roots of <var class="Arg">R</var> written as weights, i.e., as linear combinations of the fundamental weights.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:=RootSystem( [ "B", 2, "F", 4, "E", 6 ] );</span>
<root system of type B2 F4 E6>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "A", 2 );</span>
<root system of type A2>
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRoots( R );</span>
[ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">BilinearFormMat( R );</span>
[ [ 2, -1 ], [ -1, 2 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">W:= WeylGroup( R );</span>
Group([ [ [ -1, 1 ], [ 0, 1 ] ], [ [ 1, 0 ], [ 1, -1 ] ] ])
<span class="GAPprompt">gap></span> <span class="GAPinput">ConjugateDominantWeight( W, [-3,2] );</span>
[ 2, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">o:= WeylOrbitIterator( W, [-3,2] );</span>
<iterator>
<span class="GAPprompt">gap></span> <span class="GAPinput"># Using the iterator we can loop over the orbit:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">NextIterator( o );</span>
[ 2, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">NextIterator( o );</span>
[ -1, -2 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRootsAsWeights( R );</span>
[ [ 2, -1 ], [ -1, 2 ], [ 1, 1 ] ]
</pre></div>

<p><a id="X79E8AE3A8739D11A" name="X79E8AE3A8739D11A"></a></p>

<h5>3.3-2 BilinearFormMatNF</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ BilinearFormMatNF</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>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 <var class="Arg">R</var> is a root system constructed by <code class="func">RootSystem</code> (<a href="chap3.html#X80D15C027BB8029B"><span class="RefLink">3.3-1</span></a>), then this is equal to <var class="Arg">BilinearFormMat( R )</var>.</p>

<p><a id="X853E620A79D796E7" name="X853E620A79D796E7"></a></p>

<h5>3.3-3 PositiveRootsNF</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PositiveRootsNF</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This is the list of positive roots of the root system <var class="Arg">R</var>, written as linear combinations of the simple roots. This means that the simple roots are unit vectors. If <var class="Arg">R</var> is a root system constructed by <code class="func">RootSystem</code> (<a href="chap3.html#X80D15C027BB8029B"><span class="RefLink">3.3-1</span></a>), then this is equal to <var class="Arg">PositiveRoots( R )</var>.</p>

<p>One of the reasons for writing the positive roots like this is the following. Let <var class="Arg">a, b</var> be two elements of <var class="Arg">PositiveRootsNF( R )</var>, and let <var class="Arg">B</var> be the matrix of the bilinear form. Then <var class="Arg">a*( B*b )</var> is the result of applying the bilinear form to <var class="Arg">a, b</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( SimpleLieAlgebra( "B", 2, Rationals ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRootsNF( R );</span>
[ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ], [ 1, 2 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># We note that in this case PositiveRoots( R ) will give the</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># positive roots in a different format.</span>
</pre></div>

<p><a id="X7D2E78B678C73E69" name="X7D2E78B678C73E69"></a></p>

<h5>3.3-4 SimpleSystemNF</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimpleSystemNF</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This is the list of simple roots of <var class="Arg">R</var>, written as unit vectors (this means that they are elements of <var class="Arg">PositiveRootsNF( R )</var>). If <var class="Arg">R</var> is a root system constructed by <code class="func">RootSystem</code> (<a href="chap3.html#X80D15C027BB8029B"><span class="RefLink">3.3-1</span></a>), then this is equal to <var class="Arg">SimpleSystem( R )</var>.</p>

<p><a id="X7A5DFEAB7EC0D945" name="X7A5DFEAB7EC0D945"></a></p>

<h5>3.3-5 PositiveRootsInConvexOrder</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PositiveRootsInConvexOrder</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>This function returns the positive roots of the root system <var class="Arg">R</var>, in the "convex" order. Let <span class="SimpleMath">w_0=s_1⋯ s_t</span> be a reduced expression of the longest element in the Weyl group. Then the <span class="SimpleMath">k</span>-th element of the list returned by this function is <span class="SimpleMath">s_1⋯ s_k-1(α_k)</span>. (Where the reduced expression used is the one returned by <var class="Arg">LongestWeylWord( R )</var>.) If <span class="SimpleMath">α</span>, <span class="SimpleMath">β</span> and <span class="SimpleMath">α+β</span> are positive roots, then <span class="SimpleMath">α+β</span> occurs between <span class="SimpleMath">α</span> and <span class="SimpleMath">β</span> (whence the name convex order).</p>

<p>In the output all roots are written in "normal form", i.e., as elements of <var class="Arg">PositiveRootsNF( R )</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "G", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRootsInConvexOrder( R );</span>
[ [ 1, 0 ], [ 3, 1 ], [ 2, 1 ], [ 3, 2 ], [ 1, 1 ], [ 0, 1 ] ]
</pre></div>

<p><a id="X7A5BD2D77ED1BEDD" name="X7A5BD2D77ED1BEDD"></a></p>

<h5>3.3-6 SimpleRootsAsWeights</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SimpleRootsAsWeights</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns the simple roots of the root system <var class="Arg">R</var>, written as linear combinations of the fundamental weights.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "A", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SimpleRootsAsWeights( R );</span>
[ [ 2, -1 ], [ -1, 2 ] ]
</pre></div>

<p><a id="X798CE6777FC473DD" name="X798CE6777FC473DD"></a></p>

<h4>3.4 <span class="Heading">Weyl groups and their elements</span></h4>

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

<p><a id="X7D738A0E85CD5C14" name="X7D738A0E85CD5C14"></a></p>

<h5>3.4-1 ApplyWeylElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ApplyWeylElement</code>( <var class="Arg">W</var>, <var class="Arg">wt</var>, <var class="Arg">wd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">wd</var> is a (not necessarily reduced) word in the Weyl group <var class="Arg">W</var>, and <var class="Arg">wt</var> is a weight (written as integral linear combination of the simple weights). This function returns the result of applying <var class="Arg">wd</var> to <var class="Arg">wt</var>. For example, if <var class="Arg">wt=</var><span class="SimpleMath">μ</span>, and <var class="Arg">wd = [ 1, 2 ]</var> then this function returns <span class="SimpleMath">s_1s_2(μ)</span> (where <span class="SimpleMath">s_i</span> is the simple reflection corresponding to the <span class="SimpleMath">i</span>-th simple root).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">W:= WeylGroup( RootSystem( "G", 2 ) ) ;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ApplyWeylElement( W, [ -3, 7 ], [ 1, 1, 2, 1, 2 ] );</span>
[ 15, -11 ]
</pre></div>

<p><a id="X792A49A8808D1C64" name="X792A49A8808D1C64"></a></p>

<h5>3.4-2 LengthOfWeylWord</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LengthOfWeylWord</code>( <var class="Arg">W</var>, <var class="Arg">wd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">wd</var> is a word in the Weyl group <var class="Arg">W</var>. This function returns the length of that word.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">W:= WeylGroup( RootSystem( "F", 4 ) ) ;</span>
<matrix group with 4 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">LengthOfWeylWord( W, [ 1, 3, 2, 4, 2 ] );</span>
3
</pre></div>

<p><a id="X83851E7D7ED84A48" name="X83851E7D7ED84A48"></a></p>

<h5>3.4-3 LongestWeylWord</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LongestWeylWord</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Here <var class="Arg">R</var> is a root system. <var class="Arg">LongestWeylWord( R )</var> returns the longest word in the Weyl group of <var class="Arg">R</var>.</p>

<p>If this function is called for a root system <var class="Arg">R</var>, 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 <var class="Arg">SetLongestWeylWord( R, wd )</var>, where <var class="Arg">wd</var> is a reduced expression of the longest element in the Weyl group. Note that you will have to do this before calling <var class="Arg">LongestWeylWord</var>, or any function that may call <var class="Arg">LongestWeylWord</var> (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 <code class="func">LengthOfWeylWord</code> (<a href="chap3.html#X792A49A8808D1C64"><span class="RefLink">3.4-2</span></a>)).</p>

<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).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "G", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">LongestWeylWord( R );</span>
[ 1, 2, 1, 2, 1, 2 ]
</pre></div>

<p><a id="X81FC70FA84F1B6E9" name="X81FC70FA84F1B6E9"></a></p>

<h5>3.4-4 ReducedWordIterator</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ReducedWordIterator</code>( <var class="Arg">W</var>, <var class="Arg">wd</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">W</var> is a Weyl group, and <var class="Arg">wd</var> a reduced word. This function returns an iterator for the set of reduced words that represent the same element as <var class="Arg">wd</var>. The elements are output in ascending lexicographical order.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "F", 4 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">it:= ReducedWordIterator( WeylGroup(R), LongestWeylWord(R) );</span>
<iterator>
<span class="GAPprompt">gap></span> <span class="GAPinput">NextIterator( it );</span>
[ 1, 2, 1, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4, 3, 2, 1, 3, 2, 3, 4 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">k:= 1;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">while not IsDoneIterator( it ) do</span>
<span class="GAPprompt">></span> <span class="GAPinput">k:= k+1; w:= NextIterator( it );</span>
<span class="GAPprompt">></span> <span class="GAPinput">od;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">k;</span>
2144892
</pre></div>

<p>So there are 2144892 reduced expressions for the longest element in the Weyl group of type <span class="SimpleMath">F_4</span>.</p>

<p><a id="X8264626678D9F39A" name="X8264626678D9F39A"></a></p>

<h5>3.4-5 ExchangeElement</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ExchangeElement</code>( <var class="Arg">W</var>, <var class="Arg">wd</var>, <var class="Arg">ind</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">W</var> is a Weyl group, and <var class="Arg">wd</var> is a <em>reduced</em> word in <var class="Arg">W</var>, and <var class="Arg">ind</var> is an index between 1 and the rank of the root system. Let <var class="Arg">v</var> denote the word obtained from <var class="Arg">wd</var> by adding <var class="Arg">ind</var> at the end. This function <em>assumes</em> that the length of <var class="Arg">v</var> is one less than the length of <var class="Arg">wd</var>, and returns a reduced expression for <var class="Arg">v</var> that is obtained from <var class="Arg">wd</var> by deleting one entry. Nothing is guaranteed of the output if the length of <var class="Arg">v</var> is bigger than the length of <var class="Arg">wd</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "G", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">wd:= LongestWeylWord( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">ExchangeElement( WeylGroup(R), wd, 1 );</span>
[ 2, 1, 2, 1, 2 ]
</pre></div>

<p><a id="X84138DD47BBEA4E0" name="X84138DD47BBEA4E0"></a></p>

<h5>3.4-6 GetBraidRelations</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ GetBraidRelations</code>( <var class="Arg">W</var>, <var class="Arg">wd1</var>, <var class="Arg">wd2</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">W</var> is a Weyl group, and <var class="Arg">wd1</var>, <var class="Arg">wd2</var> are two reduced words representing the same element in <var class="Arg">W</var>. This function returns a list of braid relations that can be applied to <var class="Arg">wd1</var> to obtain <var class="Arg">wd2</var>. 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 <var class="Arg">wd</var> be the word <var class="Arg">[ 1, 2, 1, 3, 2, 1 ]</var> and let <var class="Arg">r = [ 3, 3, 4, 1 ]</var> be a relation. Then the result of applying <var class="Arg">r</var> to <var class="Arg">wd</var> is <var class="Arg">[ 1, 2, 3, 1, 2, 1]</var> (i.e., on the third position we put a 3, and on the fourth position a 1).</p>

<p>We note that the function does not check first whether <var class="Arg">wd1</var> and <var class="Arg">wd2</var> represent the same element in <var class="Arg">W</var>. If this is not the case, then an error will occur during the execution of the function, or it will produce wrong output.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "A", 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">wd1:= LongestWeylWord( R );</span>
[ 1, 2, 1, 3, 2, 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">wd2:= [ 1, 3, 2, 1, 3, 2 ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">GetBraidRelations( WeylGroup(R), wd1, wd2 );</span>
[ [ 3, 3, 4, 1 ], [ 4, 2, 5, 1, 6, 2 ], [ 2, 3, 3, 2, 4, 3 ], [ 4, 1, 5, 3 ] ]
</pre></div>

<p><a id="X800BB9837DCF1DBD" name="X800BB9837DCF1DBD"></a></p>

<h5>3.4-7 LongWords</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LongWords</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>For a root system <var class="Arg">R</var> this returns a list of triples (of length equal to the rank of <var class="Arg">R</var>). Let <var class="Arg">t</var> be the <var class="Arg">k</var>-th triple occurring in this list. The first element of <var class="Arg">t</var> is an expression for the longest element of the Weyl group, starting with <var class="Arg">k</var>. The second element is a list of braid relations, moving this expression to the value of <var class="Arg">LongestWeylWord( R )</var>. The third element is a list of braid relations performing the reverse transformation.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "A", 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">LongWords( R )[3];</span>
[ [ 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 ] ] ]
</pre></div>

<p><a id="X81394E207F6AA6CF" name="X81394E207F6AA6CF"></a></p>

<h4>3.5 <span class="Heading">Quantized enveloping algebras </span></h4>

<p>In <strong class="pkg">QuaGroup</strong> we deal with two types of quantized enveloping algebra. First there are the quantized enveloping algebras defined over the field <code class="func">QuantumField</code> (<a href="chap3.html#X8748A60A7AB09B0C"><span class="RefLink">3.1-1</span></a>). We say that these algebras are "generic" quantized enveloping algebras, in <strong class="pkg">QuaGroup</strong> they have the category <var class="Arg">IsGenericQUEA</var>. Secondly, we deal with the quantized enveloping algebras that are defined over a different field.</p>

<p><a id="X7C263EA87C6E4F8A" name="X7C263EA87C6E4F8A"></a></p>

<h5>3.5-1 QuantizedUEA</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantizedUEA</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantizedUEA</code>( <var class="Arg">R</var>, <var class="Arg">F</var>, <var class="Arg">v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantizedUEA</code>( <var class="Arg">L</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantizedUEA</code>( <var class="Arg">L</var>, <var class="Arg">F</var>, <var class="Arg">v</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>In the first two forms <var class="Arg">R</var> is a root system. With only <var class="Arg">R</var> as input, the corresponding generic quantized enveloping algebra is constructed. It is stored as an attribute of <var class="Arg">R</var> (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 <var class="Arg">RootSystem</var>.</p>

<p>The attribute <var class="Arg">GeneratorsOfAlgebra</var> contains the generators of a PBW-type basis (see Section <a href="chap2.html#X83E7F39F7D16793B"><span class="RefLink">2.4</span></a>), that are constructed relative to the reduced expression for the longest element in the Weyl group that is contained in <var class="Arg">LongestWeylWord( R )</var>. We refer to <code class="func">ObjByExtRep</code> (<a href="chap3.html#X7E3D93D47AFDE8D4"><span class="RefLink">3.5-2</span></a>) for a description of the construction of elements of a quantized enveloping algebra.</p>

<p>The call <var class="Arg">QuantizedUEA( R, F, v )</var> returns the quantized universal enveloping algebra with quantum parameter <var class="Arg">v</var>, which must lie in the field <var class="Arg">F</var>. In this case the elements of <var class="Arg">GeneratorsOfAlgebra</var> are the images of the generators of the corresponding generic quantized enveloping algebra. This means that if <var class="Arg">v</var> is a root of unity, then the generators will not generate the whole algebra, but rather a finite dimensional subalgebra (as for instance <span class="SimpleMath">E_i^k=0</span> for <span class="SimpleMath">k</span> large enough). It is possible to construct elements that do not lie in this finite dimensional subalgebra using <code class="func">ObjByExtRep</code> (<a href="chap3.html#X7E3D93D47AFDE8D4"><span class="RefLink">3.5-2</span></a>).</p>

<p>In the last two cases <var class="Arg">L</var> must be a semisimple Lie algebra. The two calls are short for <var class="Arg">QuantizedUEA( RootSystem( L ) )</var> and <var class="Arg">QuantizedUEA( RootSystem( L ), F, v )</var> respectively.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput"># We construct the generic quantized enveloping algebra corresponding</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># to the root system of type A2+G2:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( [ "A", 2, "G", 2 ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( R );</span>
QuantumUEA( <root system of type A2 G2>, Qpar = q )
<span class="GAPprompt">gap></span> <span class="GAPinput">RootSystem( U );</span>
<root system of type A2 G2>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= GeneratorsOfAlgebra( U );</span>
[ 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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># These elements generate a PBW-type basis of U; the nine elements Fi,</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># and the nine elements Ei correspond to the roots listed in convex order:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRootsInConvexOrder( R );</span>
[ [ 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 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># So, for example, F5 is an element of weight -[ 0, 0, 3, 1 ].</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># We can also multiply elements; the result is written on the PBW-basis:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g[17]*g[4];</span>
(-1+q^-6)*F4*[ K4 ; 1 ]+(q^-3)*F4*K4
<span class="GAPprompt">gap></span> <span class="GAPinput"># Now we construct a non-generic quantized enveloping algebra:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "A", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( R, CF(3), E(3) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= GeneratorsOfAlgebra( U );</span>
[ F1, F2, F3, K1, (-E(3)+E(3)^2)*[ K1 ; 1 ]+K1, K2, 
  (-E(3)+E(3)^2)*[ K2 ; 1 ]+K2, E1, E2, E3 ]
</pre></div>

<p>As can be seen in the example, every element of <span class="SimpleMath">U</span> is written as a linear combination of monomials in the PBW-generators; the generators of <span class="SimpleMath">U^-</span> come first, then the generators of <span class="SimpleMath">U^0</span>, and finally the generators of <span class="SimpleMath">U^+</span>.</p>

<p><a id="X7E3D93D47AFDE8D4" name="X7E3D93D47AFDE8D4"></a></p>

<h5>3.5-2 ObjByExtRep</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ObjByExtRep</code>( <var class="Arg">fam</var>, <var class="Arg">list</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">fam</var> is the elements family of a quantized enveloping algebra <var class="Arg">U</var>. Secondly, <var class="Arg">list</var> is a list describing an element of <var class="Arg">U</var>. We explain how this description works. First we describe an indexing system for the generators of <var class="Arg">U</var>. Let <var class="Arg">R</var> be the root system of <var class="Arg">U</var>. Let <var class="Arg">t</var> be the number of positive roots, and <var class="Arg">rank</var> the rank of the root system. Then the generators of <var class="Arg">U</var> are <var class="Arg">Fk</var>, <var class="Arg">Ki</var> (and its inverse), <var class="Arg">Ek</var>, for <var class="Arg">k=1...t</var>, <var class="Arg">i=1..rank</var>. (See Section <a href="chap2.html#X83E7F39F7D16793B"><span class="RefLink">2.4</span></a>; for the construction of the <var class="Arg">Fk</var>, <var class="Arg">Ek</var>, the value of <var class="Arg">LongestWeylWord( R )</var> is used.) Now the index of <var class="Arg">Fk</var> is <var class="Arg">k</var>, and the index of <var class="Arg">Ek</var> is <var class="Arg">t+rank+k</var>. Furthermore, elements of the algebra generated by the <var class="Arg">Ki</var>, and its inverse, are written as linear combinations of products of "binomials", as in Section <a href="chap2.html#X798D979F7A53E05D"><span class="RefLink">2.5</span></a>. The element</p>

<p class="pcenter"> K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix} </p>

<p>(where <span class="SimpleMath">d=0,1</span>), is indexed as <var class="Arg">[ t+i, d ]</var> (what happens to the <var class="Arg">s</var> is described later). So an index is either an integer, or a list of two integers.</p>

<p>A monomial is a list of indices, each followed by an exponent. First come the indices of the <var class="Arg">Fk</var>, (<var class="Arg">1..t</var>), then come the lists of the form <var class="Arg">[ t+i, d ]</var>, and finally the indices of the <var class="Arg">Ek</var>. Each index is followed by an exponent. An index of the form <var class="Arg">[ t+i, d ]</var> is followed by the <var class="Arg">s</var> in the above formula.</p>

<p>The second argument of <var class="Arg">ObjByExtRep</var> is a list of monomials followed by coefficients. This function returns the element of <var class="Arg">U</var> described by this list.</p>

<p>Finally we remark that the element</p>

<p class="pcenter"> K_i^{d}\begin{bmatrix} K_{i} \\ s \end{bmatrix} </p>

<p>is printed as <var class="Arg">Ki[ Ki ; s ]</var> if <var class="Arg">d=1</var>, and as <var class="Arg">[ Ki ; s ]</var> if <var class="Arg">d=0</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( RootSystem("A",2) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fam:= ElementsFamily( FamilyObj( U ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">list:= [ [ 2, 3, [ 4, 0 ], 8, 6, 11 ], _q^2,    # monomial and coefficient</span>
<span class="GAPprompt">></span> <span class="GAPinput">[ 1, 7, 3, 5, [ 5, 1 ], 3, 8, 9 ], _q^-1 + _q^2 ]; # monomial and coefficient</span>
[ [ 2, 3, [ 4, 0 ], 8, 6, 11 ], q^2, [ 1, 7, 3, 5, [ 5, 1 ], 3, 8, 9 ], 
  q^2+q^-1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ObjByExtRep( fam, list );</span>
(q^2)*F2^(3)*[ K1 ; 8 ]*E1^(11)+(q^2+q^-1)*F1^(7)*F3^(5)*K2[ K2 ; 3 ]*E3^(9)
</pre></div>

<p><a id="X8542B32A8206118C" name="X8542B32A8206118C"></a></p>

<h5>3.5-3 ExtRepOfObj</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ExtRepOfObj</code>( <var class="Arg">elm</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For the element <var class="Arg">elm</var> of a quantized enveloping algebra, this function returns the list that defines <var class="Arg">elm</var> (see <code class="func">ObjByExtRep</code> (<a href="chap3.html#X7E3D93D47AFDE8D4"><span class="RefLink">3.5-2</span></a>)).</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( RootSystem("A",2) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= GeneratorsOfAlgebra(U);</span>
[ F1, F2, F3, K1, (-q+q^-1)*[ K1 ; 1 ]+K1, K2, (-q+q^-1)*[ K2 ; 1 ]+K2, E1, 
  E2, E3 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">ExtRepOfObj( g[5] );</span>
[ [ [ 4, 0 ], 1 ], -q+q^-1, [ [ 4, 1 ], 0 ], 1 ]
</pre></div>

<p><a id="X7879B74F7C77E930" name="X7879B74F7C77E930"></a></p>

<h5>3.5-4 QuantumParameter</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QuantumParameter</code>( <var class="Arg">U</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns the quantum parameter used in the definition of <var class="Arg">U</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem("A",2);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U0:= QuantizedUEA( R, CF(3), E(3) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">QuantumParameter( U0 );</span>
E(3)
</pre></div>

<p><a id="X82B42CD279854DFC" name="X82B42CD279854DFC"></a></p>

<h5>3.5-5 CanonicalMapping</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CanonicalMapping</code>( <var class="Arg">U</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Here <var class="Arg">U</var> is a quantized enveloping algebra. Let <var class="Arg">U0</var> denote the corresponding "generic" quantized enveloping algebra. This function returns the mapping <var class="Arg">U0 --> U</var> obtained by mapping <var class="Arg">q</var> (which is the quantum parameter of <var class="Arg">U0</var>) to the quantum parameter of <var class="Arg">U</var>.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem("A", 3 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( R, CF(5), E(5) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">f:= CanonicalMapping( U );</span>
MappingByFunction( QuantumUEA( <root system of type A
3>, Qpar = q ), QuantumUEA( <root system of type A3>, Qpar = 
E(5) ), function( u ) ... end )
<span class="GAPprompt">gap></span> <span class="GAPinput">U0:= Source( f );</span>
QuantumUEA( <root system of type A3>, Qpar = q )
<span class="GAPprompt">gap></span> <span class="GAPinput">g:= GeneratorsOfAlgebra( U0 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">u:= g[18]*g[9]*g[6];</span>
(q^2)*F6*K2*E6+(q)*K2*[ K3 ; 1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Image( f, u );</span>
(E(5)^2)*F6*K2*E6+(E(5))*K2*[ K3 ; 1 ]
</pre></div>

<p><a id="X87C302567A9B2AD3" name="X87C302567A9B2AD3"></a></p>

<h5>3.5-6 WriteQEAToFile</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ WriteQEAToFile</code>( <var class="Arg">U</var>, <var class="Arg">file</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">U</var> is a quantized enveloping algebra, and file is a string containing the name of a file. This function writes some data to <var class="Arg">file</var>, that allows <code class="func">ReadQEAFromFile</code> (<a href="chap3.html#X874B8E4A83180063"><span class="RefLink">3.5-7</span></a>) to recover it.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( RootSystem("A",3) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">WriteQEAToFile( U, "A3" );</span>
</pre></div>

<p><a id="X874B8E4A83180063" name="X874B8E4A83180063"></a></p>

<h5>3.5-7 ReadQEAFromFile</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ReadQEAFromFile</code>( <var class="Arg">file</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">file</var> is a string containing the name of a file, to which a quantized enveloping algebra has been written by <code class="func">WriteQEAToFile</code> (<a href="chap3.html#X87C302567A9B2AD3"><span class="RefLink">3.5-6</span></a>). This function recovers the quantized enveloping algebra.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">U:= QuantizedUEA( RootSystem("A",3) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">WriteQEAToFile( U, "A3" );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">U0:= ReadQEAFromFile( "A3" );</span>
QuantumUEA( <root system of type A3>, Qpar = q )
</pre></div>

<p><a id="X847A0459844B7A59" name="X847A0459844B7A59"></a></p>

<h4>3.6 <span class="Heading"> Homomorphisms and automorphisms </span></h4>

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

<p><a id="X8185FE54820AA950" name="X8185FE54820AA950"></a></p>

<h5>3.6-1 QEAHomomorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QEAHomomorphism</code>( <var class="Arg">U</var>, <var class="Arg">A</var>, <var class="Arg">list</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">U</var> is a generic quantized enveloping algebra (i.e., with quantum parameter <var class="Arg">_q</var>), <var class="Arg">A</var> is an algebra with one over <var class="Arg">QuantumField</var>, and <var class="Arg">list</var> is a list of <var class="Arg">4*rank</var> elements of <var class="Arg">A</var> (where <var class="Arg">rank</var> is the rank of the root system of <var class="Arg">U</var>). On the first rank positions there are the images of the <span class="SimpleMath">F_α</span> (where the <span class="SimpleMath">α</span> are simple roots, listed in the order in which they occur in <var class="Arg">SimpleSystem( R )</var>). On the positions <var class="Arg">rank+1...2*rank</var> are the images of the <span class="SimpleMath">K_α</span>. On the positions <var class="Arg">2*rank+1...3*rank</var> are the images of the <span class="SimpleMath">K_α^-1</span>, and finally on the positions <var class="Arg">3*rank+1...4*rank</var> occur the images of the <span class="SimpleMath">E_α</span>.</p>

<p>This function returns the homomorphism <var class="Arg">U -> A</var>, 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.</p>


<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R:= RootSystem( "G", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetLongestWeylWord( R, [1,2,1,2,1,2] );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">UR:= QuantizedUEA( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">S:= RootSystem( "G", 2 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetLongestWeylWord( S, [2,1,2,1,2,1] );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">US:= QuantizedUEA( S );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">gS:= GeneratorsOfAlgebra( US );</span>
[ 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 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">SimpleSystem( R );</span>
[ [ 1, 0 ], [ 0, 1 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">PositiveRootsInConvexOrder( S );</span>
[ [ 0, 1 ], [ 1, 1 ], [ 3, 2 ], [ 2, 1 ], [ 3, 1 ], [ 1, 0 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput"># We see that the simple roots of R occur on positions 6 and 1</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># in the list PositiveRootsInConvexOrder( S ); This means that we</span>
<span class="GAPprompt">gap></span> <span class="GAPinput"># get the following list of images of the homomorphism:</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">imgs:= [ gS[6], gS[1],      # the images of the F_{\alpha}</span>
<span class="GAPprompt">></span> <span class="GAPinput">gS[7], gS[9],                  # the images of the K_{\alpha}</span>
<span class="GAPprompt">></span> <span class="GAPinput">gS[8], gS[10],                 # the images of the K_{\alpha}^{-1}</span>
<span class="GAPprompt">></span> <span class="GAPinput">gS[16], gS[11] ];              # the images of the E_{\alpha}</span>
[ F6, F1, K1, K2, (-q+q^-1)*[ K1 ; 1 ]+K1, (-q^3+q^-3)*[ K2 ; 1 ]+K2, E6, E1 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">h:= QEAHomomorphism( UR, US, imgs );</span>
<homomorphism: QuantumUEA( <root system of type G
2>, Qpar = q ) -> QuantumUEA( <root system of type G2>, Qpar = q )>
<span class="GAPprompt">gap></span> <span class="GAPinput">Image( h, GeneratorsOfAlgebra( UR )[3] );</span>
(q^10-q^6-q^4+1)*F1*F6^(2)+(q^6-q^2)*F2*F6+(q^4)*F4
</pre></div>

<p><a id="X81214E9B8532B06F" name="X81214E9B8532B06F"></a></p>

<h5>3.6-2 QEAAutomorphism</h5>

<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QEAAutomorphism</code>( <var class="Arg">U</var>, <var class="Arg">list</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ QEAAutomorphism</code>( <var class="Arg">U</var>, <var class="Arg">f</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>In the first form <var class="Arg">U</var> is a generic quantized enveloping algebra (i.e., with quantum parameter <var class="Arg">_q</var>), and <var class="Arg">list</var> is a list of <var class="Arg">4*rank</var> elements of <var class="Arg">U</var> (where <var class="Arg">rank</var> is the rank of the corresponding root system). On the first <var class="Arg">rank</var> positions there are the images of the <span class="SimpleMath">F_α</span> (where the <span class="SimpleMath">α</span> are simple roots, listed in the order in which they occur in <var class="Arg">SimpleSystem( R )</var>). On the positions <var class="Arg">rank+1...2*rank</var> are the images of the <span class="SimpleMath">K_α</span>. On the positions <var class="Arg">2*rank+1...3*rank</var> are the images of the <span class="SimpleMath">K_α^-1</span>, and finally on the positions <var class="Arg">3*rank+1...4*rank</var> occur the images of the <span class="SimpleMath">E_α</span>.</p>

<p>In the second form <var class="Arg">U</var> is a non-generic quantized enveloping algebra, and <var class="Arg">f</var> is an automorphism of the corresponding generic quantized enveloping algebra. The corresponding automorphism of <var class="Arg">U</var> is constructed. In this case <var class="Arg">f</var> must not be the bar-automorphism of the corresponding generic quantized enveloping algebra (cf. <code class="func">BarAutomorphism</code> (<a href="chap3.html#X8576A5987AD999F0"><span class="RefLink">3.6-6</span></a>)), as this automorphism doesn't work in the non-generic case.



<p>The image of an element <var class="Arg">x</var> under an automorphism <var class="Arg">f</var> is computed by <var class="Arg">Image( f, x )</var>. 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 <var class="Arg">QEAAutomorphism( U, list )</var>, where <var class="Arg">list</var> is a list of pre-images).</p>

<p>Below we construct the automorphism <span class="SimpleMath">ω</span> (cf. Section <a href="chap2.html#X81394E207F6AA6CF"><span class="RefLink">2.2</span></a>) of the quantized enveloping of type <span class="SimpleMath">A_3</span>, when the quantum parameter is <var class="Arg">_q</var>, and when the quantum parameter is a fifth root of unity.</p>


<div class="example"><pre>
--> --------------------

--> maximum size reached

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

99%


¤ Dauer der Verarbeitung: 0.37 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.