<p>Note that if you entered examples from the previous chapter, you need to restart <strong class="pkg">GAP</strong> before loading the <strong class="pkg">Circle</strong> package.</p>
<p>Because for elements of the ring <span class="SimpleMath">\(R\)</span> the ordinary multiplication is already denoted by <code class="code">*</code>, for the implementation of the circle multiplication in the adjoint semigroup we need to wrap up ring elements as CircleObjects, for which <code class="code">*</code> is defined to be the circle multiplication.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CircleObject</code>( <var class="Arg">x</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Let <var class="Arg">x</var> be a ring element. Then <code class="code">CircleObject(x)</code> returns the corresponding circle object. If <var class="Arg">x</var> lies in the family <code class="code">fam</code>, then <code class="code">CircleObject(x)</code> lies in the family <code class="func">CircleFamily</code> (<a href="chap3_mj.html#X7F88A0017DC2E878"><span class="RefLink">3.1-5</span></a>), corresponding to the family <code class="code">fam</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ UnderlyingRingElement</code>( <var class="Arg">x</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns the corresponding ring element for the circle object <var class="Arg">x</var>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCircleObject</code>( <var class="Arg">x</var> )</td><td class="tdright">( category )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCircleObjectCollection</code>( <var class="Arg">x</var> )</td><td class="tdright">( category )</td></tr></table></div>
<p>An object <var class="Arg">x</var> lies in the category <code class="code">IsCircleObject</code> if and only if it lies in a family constructed by <code class="func">CircleFamily</code> (<a href="chap3_mj.html#X7F88A0017DC2E878"><span class="RefLink">3.1-5</span></a>). Since circle objects can be multiplied via <code class="code">*</code> with elements in their family, and we need operations <code class="code">One</code> and <code class="code">Inverse</code> to deal with groups they generate, circle objects are implemented in the category <code class="code">IsMultiplicativeElementWithInverse</code>. A collection of circle objects (e.g. adjoint semigroup or adjoint group) will lie in the category <code class="code">IsCircleObjectCollection</code>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsPositionalObjectOneSlotRep</code>( <var class="Arg">x</var> )</td><td class="tdright">( representation )</td></tr></table></div>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsDefaultCircleObject</code>( <var class="Arg">x</var> )</td><td class="tdright">( representation )</td></tr></table></div>
<p>To store the corresponding circle object, we need only to store the underlying ring element. Since this is quite common situation, we defined the representation <code class="code">IsPositionalObjectOneSlotRep</code> for a more general case. Then we defined <code class="code">IsDefaultCircleObject</code> as a synonym of <code class="code">IsPositionalObjectOneSlotRep</code> for objects in <code class="func">IsCircleObject</code> (<a href="chap3_mj.html#X810FB77F860F888D"><span class="RefLink">3.1-3</span></a>).</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ CircleFamily</code>( <var class="Arg">fam</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p><code class="code">CircleFamily(fam)</code> is a family, elements of which are in one-to-one correspondence with elements of the family <var class="Arg">fam</var>, but with the circle multiplication as an infix multiplication. That is, for <span class="SimpleMath">\(x\)</span>, <span class="SimpleMath">\(y\)</span> in <var class="Arg">fam</var>, the product of their images in the <codeclass="code">CircleFamily(fam)</code> will be the image of <span class="SimpleMath">\( x + y + x y \)</span>. The relation between these families is demonstrated by the following equality:</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ One</code>( <var class="Arg">x</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>This operation returns the multiplicative neutral element for the circle object <var class="Arg">x</var>. The result is the circle object corresponding to the additive neutral element of the appropriate ring.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InverseOp</code>( <var class="Arg">x</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>For a circle object <var class="Arg">x</var>, returns the multiplicative inverse of <var class="Arg">x</var> with respect to the circle multiplication; if such one does not exist then <code class="keyw">fail</code> is returned.</p>
<p>In our implementation we assume that the underlying ring is a subring of the ring with one, thus, if the circle inverse for an element <span class="SimpleMath">\(x\)</span> exists, than it can be computed as <span class="SimpleMath">\(-x(1+x)^{-1}\)</span>.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsUnit</code>( [<var class="Arg">R</var>, ]<var class="Arg">x</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Let <var class="Arg">x</var> be a circle object corresponding to an element of the ring <var class="Arg">R</var>. Then the operation <code class="code">IsUnit</code> returns <code class="code">true</code>, if <var class="Arg">x</var> is invertible in <var class="Arg">R</var> with respect to the circle multiplication, and <code class="code">false</code> otherwise.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ IsCircleUnit</code>( [<var class="Arg">R</var>, ]<var class="Arg">x</var> )</td><td class="tdright">( operation )</td></tr></table></div>
<p>Let <var class="Arg">x</var> be an element of the ring <var class="Arg">R</var>. Then <code class="code">IsCircleUnit( R, x )</code> determines whether <var class="Arg">x</var> is invertible in <var class="Arg">R</var> with respect to the circle multilpication. This is equivalent to the condition that 1+<var class="Arg">x</var> is a unit in <var class="Arg">R</var> with respect to the ordinary multiplication.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdjointSemigroup</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>If <var class="Arg">R</var> is a finite ring then <code class="code">AdjointSemigroup(<var class="Arg">R</var>)</code> will return the monoid which is formed by all elements of <var class="Arg">R</var> with respect to the circle multiplication.</p>
<p>The implementation is rather straightforward and was added to provide a link to the <strong class="pkg">GAP</strong> functionality for semigroups. It assumes that the enumaration of all elements of the ring <var class="Arg">R</var> is feasible.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ AdjointGroup</code>( <var class="Arg">R</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>If <var class="Arg">R</var> is a finite radical algebra then <code class="code">AdjointGroup(<var class="Arg">R</var>)</code> will return the adjoint group of <var class="Arg">R</var>, given as a group generated by a set of circle objects.</p>
<p>To compute the adjoint group of a finite radical algebra, <strong class="pkg">Circle</strong> uses the fact that all elements of a radical algebra form a group with respect to the circle multiplication. Thus, the adjoint group of <var class="Arg">R</var> coincides with <var class="Arg">R</var> elementwise, and we can randomly select an appropriate set of generators for the adjoint group.</p>
<p>The warning is displayed by <code class="code">IsGeneratorsOfMagmaWithInverses</code> method defined in <code class="file">gap4r4/lib/grp.gi</code> and may be ignored.</p>
<p><strong class="button">WARNINGS:</strong></p>
<p>1. The set of generators of the returned group is not required to be a generating set of minimal possible order.</p>
<p>2. <code class="code">AdjointGroup</code> is stored as an attribute of <var class="Arg">R</var>, so for the same copy of <var class="Arg">R</var> calling it again you will get the same result. But if you will create another copy of <var class="Arg">R</var> in the future, the output may differ because of the random selection of generators. If you want to have the same generating set, next time you should construct a group immediately specifying circle objects that generate it.</p>
<p>3. In most cases, to investigate some properties of the adjoint group, it is necessary first to convert it to an isomorphic permutation group or to a PcGroup.</p>
<p>For example, we can create the following commutative 2-dimensional radical algebra of order 4 over the field of two elements, and show that its adjoint group is a cyclic group of order 4:</p>
<p>In the following example we construct a non-commutative 3-dimensional radical algebra of order 8 over the field of two elements, and demonstrate that its adjoint group is the dihedral group of order 8:</p>
<p>If the ring <var class="Arg">R</var> is not a radical algebra, then <strong class="pkg">Circle</strong> will use another approach. We will enumerate all elements of the ring <var class="Arg">R</var> and select those that are units with respect to the circle multiplication. Then we will use a random approach similar to the case of the radical algebra, to find some generating set of the adjoint group. Again, all warnings 1-3 above refer also to this case.</p>
<p>Of course, enumeration of all elements of <var class="Arg">R</var> should be feasible for this computation. In the following example we demonstrate how it works for rings, generated by residue classes:</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Ring( [ ZmodnZObj(2,8) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := AdjointGroup( R );</span>
<group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( G );</span> "C2 x C2"
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Ring( [ ZmodnZObj(2,256) ] );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := AdjointGroup( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription( G );</span> "C64 x C2"
</pre></div>
<p>Due to the <code class="func">AdjointSemigroup</code> (<a href="chap3_mj.html#X83993FD0848D0C80"><span class="RefLink">3.3-1</span></a>), there is also another way to compute the adjoint group of a ring <span class="SimpleMath">\(R\)</span> by means of the computation of its adjoint semigroup <span class="SimpleMath">\(S(R)\)</span> and taking the Green's \(H\)-class of the multiplicative neutral element of \(S(R)\). Let us repeat the last example in this way:
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Ring( [ ZmodnZObj(2,256) ] );; </span>
<span class="GAPprompt">gap></span> <span class="GAPinput">S := AdjointSemigroup( R );</span>
<monoid with 128 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">H := GreensHClassOfElement(S,One(S));</span>
<Green's H-class: <object>>
<span class="GAPprompt">gap></span> <span class="GAPinput">G:=AsGroup(H);</span>
<group of size 128 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">StructureDescription(G);</span> "C64 x C2"
</pre></div>
<p>However, the conversion of the Green's \(H\)-class to the group may take some time which may vary dependently on the particular ring in question, and will also display a lot of warnings about the default IsGeneratorsOfMagmaWithInverses method, so we did not implemented this as as standard method. In the following example the method based on Green's <span class="SimpleMath">\(H\)</span>-class is much slower than an application of earlier described random approach (20s vs 10ms):</p>
<p>Finally, note that if <var class="Arg">R</var> has a unity <span class="SimpleMath">\(1\)</span>, then the set <span class="SimpleMath">\(1+R^{ad}\)</span>, where <span class="SimpleMath">\(R^{ad}\)</span> is the adjoint semigroup of <var class="Arg">R</var>, coincides with the multiplicative semigroup <span class="SimpleMath">\(R^{mult}\)</span> of <span class="SimpleMath">\(R\)</span>, and the map <span class="SimpleMath">\( r \mapsto (1+r) \)</span> for <span class="SimpleMath">\(r\)</span> in <span class="SimpleMath">\(R\)</span> is an isomorphism from <span class="SimpleMath">\(R^{ad}\)</span> onto <span class="SimpleMath">\(R^{mult}\)</span>.</p>
<p>Similarly, the set <span class="SimpleMath">\(1+R^*\)</span>, where <span class="SimpleMath">\(R^{*}\)</span> is the adjoint group of <var class="Arg">R</var>, coincides with the unit group of <span class="SimpleMath">\(R\)</span>, which we denote <span class="SimpleMath">\(U(R)\)</span>, and the map <span class="SimpleMath">\(r \mapsto (1+r)\)</span> for <span class="SimpleMath">\(r\)</span> in <span class="SimpleMath">\(R\)</span> is an isomorphism from <span class="SimpleMath">\(R^*\)</span> onto <span class="SimpleMath">\(U(R)\)</span>.</p>
<p>We demonstrate this isomorphism using the following example.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">LoadPackage( "laguna", false );</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">FG := GroupRing( GF(2), DihedralGroup(8) );</span>
<algebra-with-one over GF(2), with 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := AugmentationIdeal( FG );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := AdjointGroup( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup( G );</span>
[ 128, 170 ]
<span class="GAPprompt">gap></span> <span class="GAPinput">IdGroup( Units( FG ) );</span>
#I LAGUNA package: Computing the unit group ...
[ 128, 170 ]
</pre></div>
<p>Thus, dependently on the ring <code class="code">R</code> in question, it might be possible that you can compute much faster its unit group using <code class="code">Units(R)</code> than its adjoint group using <code class="code">AdjointGroup(R)</code>. This is why in an attempt of computation of the adjoint group of the ring with one a warning message will be displayed:</p>
WARNING: usage of AdjointGroup for associative ring <R> with one!!!
In this case the adjoint group is isomorphic to the unit group
Units(<R>), which possibly may be computed faster!!!
WARNING: usage of AdjointGroup for associative ring <R> with one!!!
In this case the adjoint group is isomorphic to the unit group
Units(<R>), which possibly may be computed faster!!!
10
</pre></div>
<p>If <var class="Arg">R</var> is infinite, an error message will appear, telling that <strong class="pkg">Circle</strong> does not provide methods to deal with infinite rings.</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ InfoCircle</code></td><td class="tdright">( info class )</td></tr></table></div>
<p><code class="code">InfoCircle</code> is a special Info class for <strong class="pkg">Circle</strong> algorithms. It has 2 levels: 0 (default) and 1. To change info level to <code class="code">k</code>, use command <code class="code">SetInfoLevel(InfoCircle, k)</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel( InfoCircle, 1 );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel(InfoCircle,1);</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := Ring( [ ZmodnZObj(2,8) ]);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := AdjointGroup( R );</span>
#I Circle : <R> is not a radical algebra, computing circle units ...
#I Circle : searching generators for adjoint group ...
<group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetInfoLevel( InfoCircle, 0 );</span>
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.
