Quelle  funct.xml

<Chapter Label="Funct">
<Heading>&Circle; functions</Heading>

To use the &Circle; package first you need to load it as follows:

<Log>
<![CDATA[
gap> LoadPackage("circle");
-----------------------------------------------------------------------------
Loading  Circle 1.6.5 (Adjoint groups of finite rings)
by Olexandr Konovalov (https://alex-konovalov.github.io/) and
   Panagiotis Soules (psoules@math.uoa.gr).
maintained by:
   Olexandr Konovalov (https://alex-konovalov.github.io/).
Homepage: https://gap-packages.github.io/circle
Report issues at https://github.com/gap-packages/circle/issues
-----------------------------------------------------------------------------
true
gap>
]]>
</Log>

Note that if you entered examples from the previous chapter, you need
to restart &GAP; before loading the &Circle; package.


<Section Label="CircleObjects">
<Heading>Circle objects</Heading>

Because for elements of the ring <M>R</M> the ordinary multiplication
is already denoted by <C>*</C>, for the implementation of the circle
multiplication in the adjoint semigroup we need to wrap up ring 
elements as CircleObjects, for which <C>*</C> is defined to be the 
circle multiplication.

<ManSection>
   <Attr Name="CircleObject" 
         Arg="x" />
<Description>       
Let <A>x</A> be a ring element. Then <C>CircleObject(x)</C> returns the
corresponding circle object. If <A>x</A> lies in the family <C>fam</C>,
then <C>CircleObject(x)</C> lies in the family <Ref Fam="CircleFamily"/>,
corresponding to the family <C>fam</C>.

<Example>
<![CDATA[
gap> a := CircleObject( 2 );
CircleObject( 2 )
]]>
</Example>

</Description>        
</ManSection>


<ManSection>
   <Attr Name="UnderlyingRingElement" 
         Arg="x" />
<Description>       
Returns the corresponding ring element for the circle object <A>x</A>.
<Example>
<![CDATA[
gap> a := CircleObject( 2 );
CircleObject( 2 )
gap> UnderlyingRingElement( a );    
2
]]>
</Example>

</Description>        
</ManSection>


<ManSection>
   <Filt Name="IsCircleObject" 
         Arg="x" 
         Type="Category" />
   <Filt Name="IsCircleObjectCollection" 
         Arg="x" 
         Type="Category" />  
<Description>       
An object <A>x</A> lies in the category <C>IsCircleObject</C> if and
only if it lies in a family constructed by <Ref Attr="CircleFamily"/>. 
Since circle objects can be multiplied via <C>*</C> with elements in 
their family, and we need operations <C>One</C> and <C>Inverse</C> to 
deal with groups they generate, circle objects are implemented in the 
category <C>IsMultiplicativeElementWithInverse</C>. A collection of 
circle objects (e.g. adjoint semigroup or adjoint group) will lie in 
the category <C>IsCircleObjectCollection</C>.
  
<Example>
<![CDATA[
gap> IsCircleObject( 2 ); IsCircleObject( CircleObject( 2 ) );            
false
true
gap> IsMultiplicativeElementWithInverse( CircleObject( 2 ) );
true
gap> IsCircleObjectCollection( [ CircleObject(0), CircleObject(2) ] );
true
]]>
</Example>

</Description> 
</ManSection>

<ManSection>
   <Filt Name="IsPositionalObjectOneSlotRep" 
         Arg="x" 
         Type="Representation" />
   <Filt Name="IsDefaultCircleObject" 
         Arg="x" 
         Type="Representation" />         
<Description>
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 <C>IsPositionalObjectOneSlotRep</C> for a 
more general case. Then we defined <C>IsDefaultCircleObject</C> as a
synonym of <C>IsPositionalObjectOneSlotRep</C> for objects in 
<Ref Filt="IsCircleObject" />.

<Example>
<![CDATA[
gap> IsPositionalObjectOneSlotRep( CircleObject( 2 ) );
true
gap> IsDefaultCircleObject( CircleObject( 2 ) );                          
true
]]>
</Example>

</Description>              
</ManSection>

<ManSection>
   <Attr Name="CircleFamily"
         Arg="fam" />
<Description>    
<C>CircleFamily(fam)</C> is a family, elements of which are in one-to-one
correspondence with elements of the family <A>fam</A>,
but with the circle multiplication as an infix multiplication.
That is, for <M>x</M>, <M>y</M> in <A>fam</A>, the product of their images 
in the <C>CircleFamily(fam)</C> will be the image of <M> x + y + x y </M>.
The relation between these families is demonstrated by the following equality:

<Example>
<![CDATA[
gap> FamilyObj( CircleObject ( 2 ) ) = CircleFamily( FamilyObj( 2 ) );
true
]]>
</Example>

</Description> 
</ManSection>

</Section>

<Section Label="CircleOperations">
<Heading>Operations with circle objects</Heading>
 
<ManSection>
   <Oper Name="One" 
         Arg="x" />
<Description>       
This operation returns the multiplicative neutral element 
for the circle object <A>x</A>. The result is the circle 
object corresponding to the additive neutral element of 
the appropriate ring. 

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

</Description>        
</ManSection>


<ManSection>
   <Oper Name="InverseOp" 
         Arg="x" />
<Description>       
For a circle object <A>x</A>, returns the multiplicative 
inverse of <A>x</A> with respect to the circle multiplication; 
if such one does not exist then <K>fail</K> is returned.<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 <M>x</M> exists, than it can be computed as <M>-x(1+x)^{-1}</M>.

<Example>
<![CDATA[
gap> CircleObject( -2 )^-1;                        
CircleObject( -2 )
gap> CircleObject( 2 )^-1; 
CircleObject( -2/3 )
gap> CircleObject( -2 )*CircleObject( -2 )^-1;
CircleObject( 0 )
]]>
</Example>

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

</Description>        
</ManSection>


<ManSection>
   <Oper Name="IsUnit" 
         Arg="[ R, ] x" />
<Description>
Let <A>x</A> be a circle object corresponding to an element of 
the ring <A>R</A>. Then the operation <C>IsUnit</C> returns 
<C>true</C>, if <A>x</A> is invertible in <A>R</A> with respect
to the circle multiplication, and <C>false</C> otherwise.

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



If the first argument is omitted, the result will be returned with respect
to the default ring of the circle object <A>x</A>.

<Example>
<![CDATA[
gap> IsUnit( CircleObject( -2 ) );
true
gap> IsUnit( CircleObject( 2 ) ); 
false
gap> IsUnit( CircleObject( ZmodnZObj(2,8) ) );
true
gap> IsUnit( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );                                    
false
]]>
</Example>

</Description>              
</ManSection>


<ManSection>
   <Oper Name="IsCircleUnit" 
         Arg="[ R, ] x" />
<Description>
Let <A>x</A> be an element of the ring <A>R</A>. Then 
<C>IsCircleUnit( R, x )</C> determines whether <A>x</A> is invertible
in <A>R</A> with respect to the circle multilpication. This is 
equivalent to the condition that 1+<A>x</A> is a unit in <A>R</A> 
with respect to the ordinary multiplication. 

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

If the first argument is omitted, the result will be returned with respect
to the default ring of <A>x</A>.

<Example>
<![CDATA[
gap> IsCircleUnit( -2 );                               
true
gap> IsCircleUnit( 2 ); 
false
gap> IsCircleUnit( ZmodnZObj(2,8) );           
true
gap> IsCircleUnit( [ [ 1, 1 ],[ 0, 1 ] ] ); 
false
]]>
</Example>

</Description>              
</ManSection>

</Section>


<Section Label="CircleAdjointGroups">
<Heading>Construction of the adjoint semigroup and adjoint group</Heading>

<ManSection>
   <Attr Name="AdjointSemigroup" 
         Arg="R" />
<Description>
If <A>R</A> is a finite ring then <C>AdjointSemigroup(<A>R</A>)</C> will 
return the monoid which is formed by all elements of <A>R</A> with
respect to the circle multiplication.
<P/>

The implementation is rather straightforward and was added to provide a 
link to the &GAP; functionality for semigroups. It assumes that the
enumaration of all elements of the ring <A>R</A> is feasible.

<Example>
<![CDATA[
gap> R:=Ring( [ ZmodnZObj(2,8) ] );;
gap> S:=AdjointSemigroup(R);
<monoid with 4 generators>
]]>
</Example>

</Description> 

</ManSection>


<ManSection>
   <Attr Name="AdjointGroup" 
         Arg="R" />
<Description>
If <A>R</A> is a finite radical algebra then 
<C>AdjointGroup(<A>R</A>)</C> will return the adjoint group 
of <A>R</A>, given as a group generated by a set of circle objects.
<P/> 

To compute the adjoint group of a finite radical algebra,
&Circle; uses the fact that all elements of a radical algebra 
form a group with respect to the circle multiplication. Thus,
the adjoint group of <A>R</A> coincides with <A>R</A> elementwise,
and we can randomly select an appropriate set of generators for
the adjoint group. 
<P/>

The warning is displayed by <C>IsGeneratorsOfMagmaWithInverses</C>
method defined in <File>gap4r4/lib/grp.gi</File> and may be ignored.
<P/>

<B>WARNINGS:</B>
<P/>

1. The set of generators of the returned group is not required 
to be a generating set of minimal possible order.
<P/>

2. <C>AdjointGroup</C> is stored as an attribute of <A>R</A>, 
so for the same copy of <A>R</A> calling it again you will get 
the same result. But if you will create another copy of <A>R</A>
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/>

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/>

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:

<Example>
<![CDATA[
gap> x:=[ [ 0, 1, 0 ],
>         [ 0, 0, 1 ],
>         [ 0, 0, 0 ] ];;
gap> R := Algebra( GF(2), [ One(GF(2))*x ] );;
gap> RadicalOfAlgebra( R ) = R;
true
gap> Dimension(R);
2
gap> G := AdjointGroup( R );;
gap> Size( R ) = Size( G );
true
gap> StructureDescription( G );
"C4"
]]>
</Example>

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:

<Alt Only="LaTeX">\pagebreak</Alt>

<Example>
<![CDATA[
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 );
<group of size 8 with 2 generators>
gap> StructureDescription( G );
"D8"
]]>
</Example>

If the ring <A>R</A> is not a radical algebra, 
then &Circle; will use another approach. We will enumerate 
all elements of the ring <A>R</A> 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/>

Of course, enumeration of all elements of <A>R</A> should be feasible
for this computation.
In the following example we demonstrate how it works for rings, 
generated by residue classes:

<Example>
<![CDATA[
gap> R := Ring( [ ZmodnZObj(2,8) ] );;
gap> G := AdjointGroup( R );
<group of size 4 with 2 generators>
gap> StructureDescription( G );
"C2 x C2"
gap> R := Ring( [ ZmodnZObj(2,256) ] );;
gap> G := AdjointGroup( R );;
gap> StructureDescription( G );
"C64 x C2"
]]>
</Example>

Due to the <Ref Attr="AdjointSemigroup" />, there is also another way to 
compute the adjoint group of a ring <M>R</M> by means of the computation of its
adjoint semigroup <M>S(R)</M> and taking the Green's <M>H</M>-class of the 
multiplicative neutral element of <M>S(R)</M>. Let us repeat the last example
in this way:

<Example>
<![CDATA[
gap> R := Ring( [ ZmodnZObj(2,256) ] );; 
gap> S := AdjointSemigroup( R );
<monoid with 128 generators>
gap> H := GreensHClassOfElement(S,One(S));
<Green's H-class: <object>>
gap> G:=AsGroup(H);
<group of size 128 with 2 generators>
gap> StructureDescription(G);
"C64 x C2"
]]>
</Example>

However, the conversion of the Green's <M>H</M>-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 
<C>IsGeneratorsOfMagmaWithInverses</C> method, so we did not implemented 
this as as standard method. In the following example the method based on
Green's <M>H</M>-class is much slower than an application of
earlier described random approach (20s vs 10ms):

<Example>
<![CDATA[
gap> R := Ring( [ ZmodnZObj(2,256) ] );;
gap> AdjointGroup(R);;
gap> R := Ring( [ ZmodnZObj(2,256) ] );;
gap> S:=AdjointSemigroup(R); 
<monoid with 128 generators>
gap> AsGroup(GreensHClassOfElement(S,One(S))); 
<group of size 128 with 2 generators>
]]>
</Example>
  

Finally, note that if <A>R</A> has a unity <M>1</M>, then the set <M>1+R^{ad}</M>, 
where <M>R^{ad}</M> is the adjoint semigroup of <A>R</A>, coincides
with the multiplicative semigroup <M>R^{mult}</M> of <M>R</M>, and the map 
<M> r \mapsto (1+r) </M> for <M>r</M> in <M>R</M> is an isomorphism 
from <M>R^{ad}</M> onto <M>R^{mult}</M>. 
<P/>

Similarly, the set <M>1+R^*</M>, where <M>R^{*}</M> is the adjoint 
group of <A>R</A>, coincides with the unit group of <M>R</M>, 
which we denote <M>U(R)</M>, and the map <M>r \mapsto (1+r)</M> 
for <M>r</M> in <M>R</M> is an isomorphism from <M>R^*</M> onto 
<M>U(R)</M>.
<P/>

We demonstrate this isomorphism using the following example. 

<Example>
<![CDATA[
gap> LoadPackage( "laguna", false );
true
gap> FG := GroupRing( GF(2), DihedralGroup(8) );
<algebra-with-one over GF(2), with 3 generators>
gap> R := AugmentationIdeal( FG );;
gap> G := AdjointGroup( R );;
gap> IdGroup( G );
[ 128, 170 ]
gap> IdGroup( Units( FG ) );
#I  LAGUNA package: Computing the unit group ...
[ 128, 170 ]
]]>
</Example>

Thus, dependently on the ring <C>R</C> in question, it might be possible 
that you can compute much faster its unit group using <C>Units(R)</C> than
its adjoint group using <C>AdjointGroup(R)</C>. This is why in an attempt
of computation of the adjoint group of the ring with one a warning message
will be displayed:
<P/>

<Example>
<![CDATA[
gap> Size( 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!!! 

128
gap> Size( 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!!! 

10
]]>
</Example>

If <A>R</A> is infinite, an error message will appear,
telling that &Circle; does not provide methods to deal
with infinite rings.

</Description>              
</ManSection>
  
</Section>


<!-- ######################################################### -->

<Section Label="Service">
<Heading>Service functions</Heading>


<ManSection>
   <InfoClass Name="InfoCircle" />
<Description>
<C>InfoCircle</C> is a special Info class for &Circle; algorithms.
It has 2 levels: 0 (default) and 1. To change info level to 
<C>k</C>, use command <C>SetInfoLevel(InfoCircle, k)</C>. 

<Example>
<![CDATA[
gap> SetInfoLevel( InfoCircle, 1 );
gap> SetInfoLevel(InfoCircle,1);
gap> R := Ring( [ ZmodnZObj(2,8) ]);;
gap> G := AdjointGroup( R );
#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>
gap> SetInfoLevel( InfoCircle, 0 );
]]>
</Example>

</Description>
</ManSection>

</Section>

</Chapter>