<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FreeLieRing</code>( <var class="Arg">R</var>, <var class="Arg">names</var> )</td><td class="tdright">( method )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FreeLieRing</code>( <var class="Arg">R</var>, <var class="Arg">names</var>, <var class="Arg">deg</var> )</td><td class="tdright">( method )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FreeLieRing</code>( <var class="Arg">R</var>, <var class="Arg">k</var> )</td><td class="tdright">( method )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FreeLieRing</code>( <var class="Arg">R</var>, <var class="Arg">k</var>, <var class="Arg">deg</var> )</td><td class="tdright">( method )</td></tr></table></div>
<p>Here <var class="Arg">R</var> is a ring, which has to be either the integers, or a field. <var class="Arg">names</var> is a list of strings, which will be the names of the generators. This function returns the free Lie ring over <var class="Arg">R</var>, with generators named as in <var class="Arg">names </var>. If <var class="Arg">L</var> denotes the output, then <var class="Arg">L.i</var> will be the i-th generator. If a third argument <var class="Arg">deg</var> is given then this must be a list of positive integers. Then each generator will have a degree equal to the corresponding element of the list <var class="Arg">deg</var>.</p>
<p>Monomials in the free Lie ring of the form <span class="SimpleMath">\((a,b)\)</span> with <span class="SimpleMath">\(a>b\)</span> are automatically rewritten as <span class="SimpleMath">\(-(b,a)\)</span>. Monomials of the form <span class="SimpleMath">\((a,a)\)</span> are rewritten as zero. There is no other rewriting done. Therefore, the object returned by this function is strictly speaking not the same as the free Lie ring, it rather is the free anticommutative algebra.</p>
<p>Monomials in the free Lie ring are printed as bracketed expressions. In a printed element the monomials appear in increasing order; in particular the last monomial is the leading monomial.</p>
<p>If instead of the list <var class="Arg">names</var> a positive integer <var class="Arg">k</var> is given, then the free Lie ring on that number of generators is returned. Again we can give each generator a degree different from 1 by adding a third argument <var class="Arg">deg</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">L:= FreeLieRing( Integers, ["a","b"] );</span>
<Free algebra over Integers generators: a, b >
<span class="GAPprompt">gap></span> <span class="GAPinput">a:= L.1; b:= L.2;</span>
a
b
<span class="GAPprompt">gap></span> <span class="GAPinput">(a*b)*b+2*a*b; </span>
(2)*(a,b)+(-1)*(b,(a,b))
</pre></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Degree</code>( <var class="Arg">f</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">f</var> is an element of a free Lie ring. Its degree is returned.</p>
<p>The package can deal with finite-dimensional Lie rings given by a multiplication table (which follow the format for multiplication tables in the <strong class="pkg">GAP</strong> library), and a list of moduli. This list has to have the same length as the number of basis elements of the Lie ring. If the i-th element of this list is <span class="SimpleMath">\(m\)</span> then the additive order of the i-th basis edlement if <span class="SimpleMath">\(m\)</span>. If <span class="SimpleMath">\(m=0\)</span> then the additive order is infinite.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieRingByStructureConstants</code>( <var class="Arg">tor</var>, <var class="Arg">T</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">T</var> is a multiplication table, and <var class="Arg">tor</var> is a list of moduli. This function returns the corresponding Lie ring. In the example below we create the Lie ring with basis elements <span class="SimpleMath">\(x,y,z\)</span>, with <span class="SimpleMath">\([x,y]=z\)</span>, <span class="SimpleMath">\(3x=6y=3z=0\)</span>.</p>
<p>The multiplication table has to be created using the <strong class="pkg">GAP</strong> functions for constructing multiplication tables of Lie algebras. In particular, we refer to the <strongclass="pkg">GAP</strong> reference manual for descriptions of the functions <code class="func">EmptySCTable</code> (<a href="../../../doc/ref/chap62_mj.html#X7F1203A1793411DF"><span class="RefLink">Reference: EmptySCTable</span></a>) <code class="func">SetEntrySCTable</code> (<a href="../../../doc/ref/chap62_mj.html#X817BD086876EC1C4"><span class="RefLink">Reference: SetEntrySCTable</span></a>)</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FpLieRing</code>( <var class="Arg">L</var>, <var class="Arg">R</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a free Lie ring defined over the integers, and <var class="Arg">R</var> is a set of elements of <var class="Arg">L</var>. This function returns the Lie ring given by structure constants, that is isomorphic to <var class="Arg">L</var> modulo the ideal generated by <var class="Arg">R</var>.</p>
<p>It is possible to set the option <var class="Arg">maxdeg</var> to a positive value <var class="Arg">d</var>. Then a nilpotent quotient is computed, i.e., all elements of <var class="Arg">L</var> of degree strictly greater than <var class="Arg">d</var> will be treated as relations.</p>
<p>The algebra that is output by this function has an attribute, <var class="Arg">CanonicalProjection</var>, which is a function mapping elements of the free Lie ring <var class="Arg">L</var> to their projections in the output algebra.</p>
<p>The algorithm behind this function has been described in <a href="chapBib_mj.html#biBcicgra1">[CdG07]</a> and <a href="chapBib_mj.html#biBcicgra2">[CdG09]</a>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ FpLieAlgebra</code>( <var class="Arg">L</var>, <var class="Arg">R</var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>This is similar to <var class="Arg">FpLieRing</var>, with the difference that the free Lie ring <var class="Arg">L</var> must be defined over a field. Then the algorithms become a lot faster (in most cases). The result however is a Lie algebra, and not a Lie ring.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Basis</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> a Lie ring. Its basis is returned.</p>
<p>We note that in <strong class="pkg">LieRing</strong> Lie rings have one basis that is computed by the system; one should not try to set a basis.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ StructureConstantsTable</code>( <var class="Arg">B</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">B</var> is the basis of a Lie ring. Its structure constants table is returned.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Torsion</code>( <var class="Arg">B</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">B</var> is the basis of a Lie ring. The list of torsion moduli of its basis elements is returned.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ Coefficients</code>( <var class="Arg">B</var>, <var class="Arg">elm</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">B</var> is the basis of a Lie ring, and <var class="Arg">elm</var> is an element of the same Lie ring. The coefficients of <var class="Arg">elm</var> with respect to <var class="Arg">B</var> are returned.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SubLieRing</code>( <var class="Arg">L</var>, <var class="Arg">gens</var>[, <var class="Arg">string</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring, and <var class="Arg">gens</var> a list of elements of <varclass="Arg">L</var>. This function constructs the subring generated by the elements in <var class="Arg">gens</var>. If these elements are known to form a basis of the subalgebra, then as a third argument the string <var class="Arg">"basis"</var> can be added. That makes the execution of the function a lot faster.</p>
<p>This function depends on hermite and Smith normal form computations. Therefore in practice, for bigger inputs, it can be slow.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieRingIdeal</code>( <var class="Arg">L</var>, <var class="Arg">gens</var>[, <var class="Arg">string</var>] )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This is the same as <var class="Arg">SubLieRing</var> except that the output is an ideal (on the level of data structures that is the same as a Lie subring).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ NaturalHomomorphismByIdeal</code>( <var class="Arg">L</var>, <var class="Arg">I</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring, and <var class="Arg">I</var> an ideal of <var class="Arg">L</var>. This function constructs the canonical projection of <var class="Arg">L</var> on the quotient of <var class="Arg">L</var> by <var class="Arg">I</var>.</p>
<p>We remark that it is <em>not checked</em> whether <var class="Arg">I</var> is an ideal or not. if <var class="Arg">I</var> is just a subalgebra, then nothing is guaranteed about the result of this function.</p>
<p>Also this function depends on Smith normal form computations; therefore it can be slow on bigger inputs.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieLowerCentralSeries</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring. Its lower central series is returned.</p>
<p>This repeatedly constructs ideals of <var class="Arg">L</var>; therefore also this function can be rather slow on bigger inputs.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">L:= FreeLieRing( Integers, ["x","y"] );; x:= L.1;; y:= L.2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rr:=[((y*x)*x)*x-6*(y*x)*y, 3*((((y*x)*x)*x)*x)*x-20*(((y*x)*x)*x)*y ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">K:= FpLieRing( L, rr : maxdeg:= 7 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">LieLowerCentralSeries(K);</span>
[ <Lie ring with 26 generators>, <Lie ring with 24 generators>,
<Lie ring with 23 generators>, <Lie ring with 22 generators>,
<Lie ring with 21 generators>, <Lie ring with 19 generators>,
<Lie ring with 16 generators>, <Lie ring with 0 generators> ]
</pre></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieLowerPCentralSeries</code>( <var class="Arg">L</var>, <var class="Arg">p</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring, and <var class="Arg">p</var> is a prime. The lower <var class="Arg">p</var>-central series of <var class="Arg">L</var> is returned. This is the series where the <span class="SimpleMath">\(L^{k+1}\)</span> is generated by <span class="SimpleMath">\([L,L^k]\)</span> and <span class="SimpleMath">\(pL^k\)</span>. Note that this may not be a finite series, if <span class="SimpleMath">\(L\)</span> is not of exponent <span class="SimpleMath">\(p^n\)</span> (as abelian group). The function does not check this; if the series is infinite, then it will loop forever.</p>
<p>This repeatedly constructs ideals of <var class="Arg">L</var>; therefore also this function can be rather slow on bigger inputs.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">L:= FreeLieRing( Integers, ["x","y"] );; x:= L.1;; y:= L.2;;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">rr:=[((y*x)*x)*x-7*(y*x)*y, 7*((((y*x)*x)*x)*x)*x-49*(((y*x)*x)*x)*y, </span>
<span class="GAPprompt">></span> <span class="GAPinput">7*x, 49*y ];;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">K:= FpLieRing( L, rr : maxdeg:= 5 );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">LieLowerPCentralSeries(K,7);</span>
[ <Lie ring with 11 generators>, <Lie ring with 10 generators>,
<Lie ring with 8 generators>, <Lie ring with 6 generators>,
<Lie ring with 4 generators>, <Lie ring with 0 generators> ]
</pre></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieCentre</code>( <var class="Arg">L</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring. Its centre is returned.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ TensorWithField</code>( <var class="Arg">L</var>, <var class="Arg">F</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a Lie ring, and <var class="Arg">F</var> is a field. This function returns the Lie algebra that is obtained by tensoring <var class="Arg">L</var> with <var class="Arg">F</var>.</p>
<p>By the Lazard correspondence we can put a Lie ring structure on a <span class="SimpleMath">\(p\)</span>-group of class <span class="SimpleMath">\(<p\)</span>. Conversely, we can define a group structure on a nilpotent Lie ring of order <span class="SimpleMath">\(p^n\)</span> and class <span class="SimpleMath">\(<p\)</span>. The package contains functions for doing this effectively. However, we do not work with a single object having both the structure of a <span class="SimpleMath">\(p\)</span>-group and a Lie ring. Rather we define two objects, a <span class="SimpleMath">\(p\)</span>-group and a Lie ring, along with bijections between the two. Our programs use the BCH-formula and its inverses, that have been stored in a file, truncated at weight 14. This means that currently the package is able to deal with groups and algebras up to class 14. The underlying algorithms have been described in <a href="chapBib_mj.html#biBcicgravl">[CdGVL11]</a></p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ PGroupToLieRing</code>( <var class="Arg">G</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Here <var class="Arg">G</var> is a <span class="SimpleMath">\(p\)</span>-group of class <span class="SimpleMath">\(<p\)</span>. This function returns a record with four components: <var class="Arg">pgroup</var> (the group <var class="Arg">G</var>), <var class="Arg">liering</var> (the corresponding Lie ring), <var class="Arg">GtoL</var> (a function mapping elements of the group to elements of the Lie ring), <var class="Arg">LtoG</var> (a function mapping elements of the Lie ring to elements of the group).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ LieRingToPGroup</code>( <var class="Arg">L</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Here <var class="Arg">L</var> is a nilpotent Lie ring of class <span class="SimpleMath">\(<p\)</span> and order <span class="SimpleMath">\(p^n\)</span>. This function returns a record with four components: <var class="Arg">pgroup</var> (the <span class="SimpleMath">\(p\)</span>-group corresponding to <var class="Arg">L</var>), <var class="Arg">liering</var> (the Lie ring <var class="Arg">L</var>), <var class="Arg">GtoL</var> (a function mapping elements of the group to elements of the Lie ring), <var class="Arg">LtoG</var> (a function mapping elements of the Lie ring to elements of the group).</p>
<h4>2.5 <span class="Heading">The database of <span class="SimpleMath">\(n\)</span>-Engel Lie rings</span></h4>
<p>A Lie ring <span class="SimpleMath">\(L\)</span> is said to satisfy the <span class="SimpleMath">\(n\)</span>-Engel condition if for all <span class="SimpleMath">\(x,y \in L\)</span> we have <span class="SimpleMath">\((ad x)^n (y) = 0\)</span>. The package <strong class="pkg">LieRing</strong> contains a small database of Lie rings that satisfy an <span class="SimpleMath">\(n\)</span>-Engel condition. They have been computed with the algorithms described in <a href="chapBib_mj.html#biBcicgra1">[CdG07]</a> and <a href="chapBib_mj.html#biBcicgra2">[CdG09]</a>.</p>
<p>Currently the database contains the "freeest" (or "largest") <span class="SimpleMath">\(n\)</span>-Engel Lie rings with <span class="SimpleMath">\(k\)</span> generators for <span class="SimpleMath">\((n,k) = (3,2), (3,3), (3,4), (4,2), (4,3)\)</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ SmallNEngelLieRing</code>( <var class="Arg">n</var>, <var class="Arg">k</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This returns the biggest <var class="Arg">n</var>-Engel Lie ring with <var class="Arg">k</var> generators, for the values of <var class="Arg">n,k</var> indicated above. For other values an error is raised.</p>
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.
