<?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 (Circle) - Chapter 3: Circle functions</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" />
</head>
<body>
<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="chap4.html">4</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="chap2.html">Previous Chapter</a> <a href="chap4.html">Next Chapter</a> </div>
<p><a id="X81CE94FA8343B1D8" name="X81CE94FA8343B1D8"></a></p>
<div class="ChapSects"><a href="chap3.html#X81CE94FA8343B1D8">3 <span class="Heading"><strong class="pkg">Circle</strong> functions</span></a>
<div class="ContSect"><span class="nocss"> </span><a href="chap3.html#X7E25EF1786B5F87C">3.1 <span class="Heading">Circle objects</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7F5C18AA7B433BDD">3.1-1 CircleObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X874B2B2A7F5A9A78">3.1-2 UnderlyingRingElement</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X810FB77F860F888D">3.1-3 IsCircleObject</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X8469C7F67A8864B3">3.1-4 IsPositionalObjectOneSlotRep</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7F88A0017DC2E878">3.1-5 CircleFamily</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap3.html#X85ECB0B482AB3170">3.2 <span class="Heading">Operations with circle objects</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X8129A6877FFD804B">3.2-1 One</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X82EC4F49877D6EB1">3.2-2 InverseOp</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X85CBFBAE78DE72E8">3.2-3 IsUnit</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7CE7866F7CD00709">3.2-4 IsCircleUnit</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap3.html#X86F80DD8823966F7">3.3 <span class="Heading">Construction of the adjoint semigroup and adjoint group</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X83993FD0848D0C80">3.3-1 AdjointSemigroup</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X868FAC7E87D11137">3.3-2 AdjointGroup</a></span>
</div>
<div class="ContSect"><span class="nocss"> </span><a href="chap3.html#X80DFB24F8289C323">3.4 <span class="Heading">Service functions</span></a>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7A24C0997AC7C6A3">3.4-1 InfoCircle</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7D74CBE0787AC1B1">3.4-2 CIRCLEBuildManual</a></span>
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap3.html#X7B286B3985877CCE">3.4-3 CIRCLEBuildManualHTML</a></span>
</div>
</div>
<h3>3 <span class="Heading"><strong class="pkg">Circle</strong> functions</span></h3>
<p>To use the <strong class="pkg">Circle</strong> package first you need to load it as follows:</p>
<table class="example">
<tr><td><pre>
gap> LoadPackage("circle");
-----------------------------------------------------------------------------
Loading Circle 1.3.1 (Adjoint groups of finite rings)
by Alexander Konovalov (http://www.cs.st-andrews.ac.uk/~alexk/) and
Panagiotis Soules (psoules@math.uoa.gr).
-----------------------------------------------------------------------------
true
gap>
</pre></td></tr></table>
<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><a id="X7E25EF1786B5F87C" name="X7E25EF1786B5F87C"></a></p>
<h4>3.1 <span class="Heading">Circle objects</span></h4>
<p>Because for elements of the ring R 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>
<p><a id="X7F5C18AA7B433BDD" name="X7F5C18AA7B433BDD"></a></p>
<h5>3.1-1 CircleObject</h5>
<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.html#X7F88A0017DC2E878"><b>3.1-5</b></a>), corresponding to the family <code class="code">fam</code>.</p>
<table class="example">
<tr><td><pre>
gap> a := CircleObject( 2 );
CircleObject( 2 )
</pre></td></tr></table>
<p><a id="X874B2B2A7F5A9A78" name="X874B2B2A7F5A9A78"></a></p>
<h5>3.1-2 UnderlyingRingElement</h5>
<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">( operation )</td></tr></table></div>
<p>Returns the corresponding ring element for the circle object <var class="Arg">x</var>.</p>
<table class="example">
<tr><td><pre>
gap> a := CircleObject( 2 );
CircleObject( 2 )
gap> UnderlyingRingElement( a );
2
</pre></td></tr></table>
<p><a id="X810FB77F860F888D" name="X810FB77F860F888D"></a></p>
<h5>3.1-3 IsCircleObject</h5>
<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.html#X7F88A0017DC2E878"><b>3.1-5</b></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>
<table class="example">
<tr><td><pre>
gap> IsCircleObject( 2 ); IsCircleObject( CircleObject( 2 ) );
false
true
gap> IsMultiplicativeElementWithInverse( CircleObject( 2 ) );
true
gap> IsCircleObjectCollection( [ CircleObject(0), CircleObject(2) ] );
true
</pre></td></tr></table>
<p><a id="X8469C7F67A8864B3" name="X8469C7F67A8864B3"></a></p>
<h5>3.1-4 IsPositionalObjectOneSlotRep</h5>
<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.html#X810FB77F860F888D"><b>3.1-3</b></a>).</p>
<table class="example">
<tr><td><pre>
gap> IsPositionalObjectOneSlotRep( CircleObject( 2 ) );
true
gap> IsDefaultCircleObject( CircleObject( 2 ) );
true
</pre></td></tr></table>
<p><a id="X7F88A0017DC2E878" name="X7F88A0017DC2E878"></a></p>
<h5>3.1-5 CircleFamily</h5>
<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 x, y in <var class="Arg">fam</var>, the product of their images in the <code class="code">CircleFamily(fam)</code> will be the image of x + y + x y. The relation between these families is demonstrated by the following equality:</p>
<table class="example">
<tr><td><pre>
gap> FamilyObj( CircleObject ( 2 ) ) = CircleFamily( FamilyObj( 2 ) );
true
</pre></td></tr></table>
<p><a id="X85ECB0B482AB3170" name="X85ECB0B482AB3170"></a></p>
<h4>3.2 <span class="Heading">Operations with circle objects</span></h4>
<p><a id="X8129A6877FFD804B" name="X8129A6877FFD804B"></a></p>
<h5>3.2-1 One</h5>
<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>
<table class="example">
<tr><td><pre>
gap> One( CircleObject( 5 ) );
CircleObject( 0 )
gap> One( CircleObject( 5 ) ) = CircleObject( Zero( 5 ) );
true
gap> One( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );
CircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )
</pre></td></tr></table>
<p><a id="X82EC4F49877D6EB1" name="X82EC4F49877D6EB1"></a></p>
<h5>3.2-2 InverseOp</h5>
<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 x exists, than it can be computed as -x(1+x)^-1.</p>
<table class="example">
<tr><td><pre>
gap> CircleObject( -2 )^-1;
CircleObject( -2 )
gap> CircleObject( 2 )^-1;
CircleObject( -2/3 )
gap> CircleObject( -2 )*CircleObject( -2 )^-1;
CircleObject( 0 )
</pre></td></tr></table>
<table class="example">
<tr><td><pre>
gap> m := CircleObject( [ [ 1, 1 ], [ 0, 1 ] ] );
CircleObject( [ [ 1, 1 ], [ 0, 1 ] ] )
gap> m^-1;
CircleObject( [ [ -1/2, -1/4 ], [ 0, -1/2 ] ] )
gap> m * m^-1;
CircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )
gap> CircleObject( [ [ 0, 1 ], [ 1, 0 ] ] )^-1;
fail
</pre></td></tr></table>
<p><a id="X85CBFBAE78DE72E8" name="X85CBFBAE78DE72E8"></a></p>
<h5>3.2-3 IsUnit</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> IsUnit</code>( <var class="Arg">[R, ]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>
<table class="example">
<tr><td><pre>
gap> IsUnit( Integers, CircleObject( -2 ) );
true
gap> IsUnit( Integers, CircleObject( 2 ) );
false
gap> IsUnit( Rationals, CircleObject( 2 ) );
true
gap> IsUnit( ZmodnZ(8), CircleObject( ZmodnZObj(2,8) ) );
true
gap> m := CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] );;
gap> IsUnit( FullMatrixAlgebra( Rationals, 2 ), m );
true
</pre></td></tr></table>
<p>If the first argument is omitted, the result will be returned with respect to the default ring of the circle object <var class="Arg">x</var>.</p>
<table class="example">
<tr><td><pre>
gap> IsUnit( CircleObject( -2 ) );
true
gap> IsUnit( CircleObject( 2 ) );
false
gap> IsUnit( CircleObject( ZmodnZObj(2,8) ) );
true
gap> IsUnit( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );
true
</pre></td></tr></table>
<p><a id="X7CE7866F7CD00709" name="X7CE7866F7CD00709"></a></p>
<h5>3.2-4 IsCircleUnit</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> IsCircleUnit</code>( <var class="Arg">[R, ]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>
<table class="example">
<tr><td><pre>
gap> IsCircleUnit( Integers, -2 );
true
gap> IsCircleUnit( Integers, 2 );
false
gap> IsCircleUnit( Rationals, 2 );
true
gap> IsCircleUnit( ZmodnZ(8), ZmodnZObj(2,8) );
true
gap> m := [ [ 1, 1 ],[ 0, 1 ] ];
[ [ 1, 1 ], [ 0, 1 ] ]
gap> IsCircleUnit( FullMatrixAlgebra(Rationals,2), m );
true
</pre></td></tr></table>
<p>If the first argument is omitted, the result will be returned with respect to the default ring of <var class="Arg">x</var>.</p>
<table class="example">
<tr><td><pre>
gap> IsCircleUnit( -2 );
true
gap> IsCircleUnit( 2 );
false
gap> IsCircleUnit( ZmodnZObj(2,8) );
true
gap> IsCircleUnit( [ [ 1, 1 ],[ 0, 1 ] ] );
true
</pre></td></tr></table>
<p><a id="X86F80DD8823966F7" name="X86F80DD8823966F7"></a></p>
<h4>3.3 <span class="Heading">Construction of the adjoint semigroup and adjoint group</span></h4>
<p><a id="X83993FD0848D0C80" name="X83993FD0848D0C80"></a></p>
<h5>3.3-1 AdjointSemigroup</h5>
<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>
<table class="example">
<tr><td><pre>
gap> R:=Ring( [ ZmodnZObj(2,8) ] );
<ring with 1 generators>
gap> S:=AdjointSemigroup(R);
<monoid with 4 generators>
</pre></td></tr></table>
<p><a id="X868FAC7E87D11137" name="X868FAC7E87D11137"></a></p>
<h5>3.3-2 AdjointGroup</h5>
<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>
<table class="example">
<tr><td><pre>
gap> x:=[ [ 0, 1, 0 ],
> [ 0, 0, 1 ],
> [ 0, 0, 0 ] ];;
gap> R := Algebra( GF(2), [ One(GF(2))*x ] );
<algebra over GF(2), with 1 generators>
gap> RadicalOfAlgebra( R ) = R;
true
gap> Dimension(R);
2
gap> G := AdjointGroup( R );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( [ [ 0*Z(2), 0*Z(2), Z(2)^0 ], [ 0*Z(2), 0*Z(2), 0*Z(2) ],
[ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ]
<group of size 4 with 2 generators>
gap> Size( R ) = Size( G );
true
gap> StructureDescription( G );
"C4"
</pre></td></tr></table>
<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>
<table class="example">
<tr><td><pre>
gap> x:=[ [ 0, 1, 0 ],
> [ 0, 0, 0 ],
> [ 0, 0, 0 ] ];;
gap> y:=[ [ 0, 0, 0 ],
> [ 0, 0, 1 ],
> [ 0, 0, 0 ] ];;
gap> R := Algebra( GF(2), One(GF(2))*[x,y] );
<algebra over GF(2), with 2 generators>
gap> RadicalOfAlgebra(R) = R;
true
gap> Dimension(R);
3
gap> G := AdjointGroup( R );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( [ [ 0*Z(2), Z(2)^0, Z(2)^0 ], [ 0*Z(2), 0*Z(2), Z(2)^0 ],
[ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ]
<group of size 8 with 2 generators>
gap> StructureDescription( G );
"D8"
</pre></td></tr></table>
<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>
<table class="example">
<tr><td><pre>
gap> R := Ring( [ ZmodnZObj(2,8) ] );
<ring with 1 generators>
gap> G := AdjointGroup( R );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 2, 8 ) ) ]
<group of size 4 with 2 generators>
gap> StructureDescription( G );
"C2 x C2"
gap> R := Ring( [ ZmodnZObj(2,256) ] );
<ring with 1 generators>
gap> G := AdjointGroup( R );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 234, 256 ) ) ]
<group of size 128 with 2 generators>
gap> StructureDescription( G );
"C64 x C2"
</pre></td></tr></table>
<p>Due to the <code class="func">AdjointSemigroup</code> (<a href="chap3.html#X83993FD0848D0C80"><b>3.3-1</b></a>), there is also another way to compute the adjoint group of a ring R by means of the computation of its adjoint semigroup S(R) and taking the Green's H-class of the multiplicative neutral element of S(R). Let us repeat the last example in this way:</p>
<table class="example">
<tr><td><pre>
gap> R := Ring( [ ZmodnZObj(2,256) ] );
<ring with 1 generators>
gap> S := AdjointSemigroup( R );
<monoid with 128 generators>
gap> H := GreensHClassOfElement(S,One(S));
{CircleObject( ZmodnZObj( 0, 256 ) )}
gap> G:=AsGroup(H);
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 0, 256 ) ), CircleObject( ZmodnZObj( 2, 256 ) ),
...
CircleObject( ZmodnZObj( 250, 256 ) ), CircleObject( ZmodnZObj( 252, 256 ) )
, CircleObject( ZmodnZObj( 254, 256 ) ) ]
<group of size 128 with 2 generators>
gap> StructureDescription(G);
"C64 x C2"
</pre></td></tr></table>
<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 <code class="code">IsGeneratorsOfMagmaWithInverses</code> method, so we did not implemented this as as standard method. In the following example the method based on Green's H-class is about 50 times slower than an application of earlier described random approach:</p>
<table class="example">
<tr><td><pre>
gap> R := Ring( [ ZmodnZObj(2,1024) ] );
<ring with 1 generators>
gap> AdjointGroup(R); time;
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 136, 1024 ) ) ]
<group of size 512 with 3 generators>
109
gap> R := Ring( [ ZmodnZObj(2,1024) ] );
<ring with 1 generators>
gap> S:=AdjointSemigroup(R); AsGroup(GreensHClassOfElement(S,One(S))); time;
<monoid with 512 generators>
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 0, 1024 ) ), CircleObject( ZmodnZObj( 2, 1024 ) ),
CircleObject( ZmodnZObj( 4, 1024 ) ), CircleObject( ZmodnZObj( 6, 1024 ) ),
...
CircleObject( ZmodnZObj( 1018, 1024 ) ),
CircleObject( ZmodnZObj( 1020, 1024 ) ),
CircleObject( ZmodnZObj( 1022, 1024 ) ) ]
<group of size 512 with 2 generators>
5474
</pre></td></tr></table>
<p>Finally, note that if <var class="Arg">R</var> has a unity 1, then the set 1+R^ad, where R^ad is the adjoint semigroup of <var class="Arg">R</var>, coincides with the multiplicative semigroup R^mult of R, and the map r -> (1+r) for r in R is an isomorphism from R^ad onto R^mult.</p>
<p>Similarly, the set 1+R^*, where R^* is the adjoint group of <var class="Arg">R</var>, coincides with the unit group of R, which we denote U(R), and the map r -> (1+r) for r in R is an isomorphism from R^* onto U(R).</p>
<p>We demonstrate this isomorphism using the following example.</p>
<table class="example">
<tr><td><pre>
gap> FG := GroupRing( GF(2), DihedralGroup(8) );
<algebra-with-one over GF(2), with 3 generators>
gap> R := AugmentationIdeal( FG );
<two-sided ideal in <algebra-with-one over GF(2), with 3 generators>,
(dimension 7)>
gap> G := AdjointGroup( R );
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( (Z(2)^0)*f2+(Z(2)^0)*f1*f2 ) ]
<group of size 128 with 4 generators>
gap> IdGroup( G );
[ 128, 170 ]
gap> IdGroup( Units( FG ) );
#I LAGUNA package: Computing the unit group ...
[ 128, 170 ]
</pre></td></tr></table>
<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>
<table class="example">
<tr><td><pre>
gap> AdjointGroup( GroupRing( GF(2), DihedralGroup(8) ) );
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!!!
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3 ) ]
<group of size 128 with 4 generators>
gap> AdjointGroup( Integers mod 11 );
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!!!
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( Z(11)^0 ) ]
<group of size 10 with 1 generators>
</pre></td></tr></table>
<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>
<p><a id="X80DFB24F8289C323" name="X80DFB24F8289C323"></a></p>
<h4>3.4 <span class="Heading">Service functions</span></h4>
<p><a id="X7A24C0997AC7C6A3" name="X7A24C0997AC7C6A3"></a></p>
<h5>3.4-1 InfoCircle</h5>
<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>
<table class="example">
<tr><td><pre>
gap> SetInfoLevel( InfoCircle, 1 );
gap> SetInfoLevel(InfoCircle,1);
gap> R := Ring( [ ZmodnZObj(2,8) ]);
<ring with 1 generators>
gap> G := AdjointGroup( R );
#I Circle : <R> is not a radical algebra, computing circle units ...
#I Circle : searching generators for adjoint group ...
#I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for
[ CircleObject( ZmodnZObj( 6, 8 ) ) ]
<group of size 4 with 2 generators>
gap> SetInfoLevel( InfoCircle, 0 );
</pre></td></tr></table>
<p><a id="X7D74CBE0787AC1B1" name="X7D74CBE0787AC1B1"></a></p>
<h5>3.4-2 CIRCLEBuildManual</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> CIRCLEBuildManual</code>( <var class="Arg"></var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>This function is used to build the manual in the following formats: DVI, PDF, PS, HTML and text for online help. We recommend that the user should have a recent and fairly complete TeX distribution. Since <strong class="pkg">Circle</strong> is distributed together with its manual, it is not necessary for the user to use this function. Normally it is intended to be used by the developers only. This is the only function of <strong class="pkg">Circle</strong> which requires UNIX/Linux environment.</p>
<p><a id="X7B286B3985877CCE" name="X7B286B3985877CCE"></a></p>
<h5>3.4-3 CIRCLEBuildManualHTML</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">> CIRCLEBuildManualHTML</code>( <var class="Arg"></var> )</td><td class="tdright">( function )</td></tr></table></div>
<p>This fuction is used to build the manual only in HTML format. This does not depend on the availability of the TeX installation and works under Windows and MacOS as well. Since <strong class="pkg">Circle</strong> is distributed together with its manual, it is not necessary for the user to use this function. Normally it is intended to be used by the developers only.</p>
<div class="chlinkprevnextbot"> <a href="chap0.html">Top of Book</a> <a href="chap2.html">Previous Chapter</a> <a href="chap4.html">Next Chapter</a> </div>
<div class="chlinkbot"><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="chap4.html">4</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
5e1854624d3bc613bdd0dd13d1ef9ac7
>
files
>
982
