  
  [1X3 [5XCircle[1X functions[0X
  
  To use the [5XCircle[0m package first you need to load it as follows:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> LoadPackage("circle");[0X
    [4X-----------------------------------------------------------------------------[0X
    [4XLoading  Circle 1.3.1 (Adjoint groups of finite rings)[0X
    [4Xby Alexander Konovalov (http://www.cs.st-andrews.ac.uk/~alexk/) and[0X
    [4X   Panagiotis Soules (psoules@math.uoa.gr).[0X
    [4X-----------------------------------------------------------------------------[0X
    [4Xtrue[0X
    [4Xgap>[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  Note  that  if  you  entered examples from the previous chapter, you need to
  restart [5XGAP[0m before loading the [5XCircle[0m package.
  
  
  [1X3.1 Circle objects[0X
  
  Because  for  elements  of the ring R the ordinary multiplication is already
  denoted  by  [10X*[0m,  for  the implementation of the circle multiplication in the
  adjoint  semigroup  we  need  to wrap up ring elements as CircleObjects, for
  which [10X*[0m is defined to be the circle multiplication.
  
  [1X3.1-1 CircleObject[0m
  
  [2X> CircleObject( [0X[3Xx[0X[2X ) _______________________________________________[0Xattribute
  
  Let  [3Xx[0m  be  a  ring  element. Then [10XCircleObject(x)[0m returns the corresponding
  circle object. If [3Xx[0m lies in the family [10Xfam[0m, then [10XCircleObject(x)[0m lies in the
  family [2XCircleFamily[0m ([14X3.1-5[0m), corresponding to the family [10Xfam[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> a := CircleObject( 2 );[0X
    [4XCircleObject( 2 )[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.1-2 UnderlyingRingElement[0m
  
  [2X> UnderlyingRingElement( [0X[3Xx[0X[2X ) ______________________________________[0Xoperation
  
  Returns the corresponding ring element for the circle object [3Xx[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> a := CircleObject( 2 );[0X
    [4XCircleObject( 2 )[0X
    [4Xgap> UnderlyingRingElement( a );    [0X
    [4X2[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.1-3 IsCircleObject[0m
  
  [2X> IsCircleObject( [0X[3Xx[0X[2X ) ______________________________________________[0XCategory
  [2X> IsCircleObjectCollection( [0X[3Xx[0X[2X ) ____________________________________[0XCategory
  
  An  object [3Xx[0m lies in the category [10XIsCircleObject[0m if and only if it lies in a
  family  constructed  by  [2XCircleFamily[0m  ([14X3.1-5[0m).  Since circle objects can be
  multiplied  via  [10X*[0m with elements in their family, and we need operations [10XOne[0m
  and   [10XInverse[0m  to  deal  with  groups  they  generate,  circle  objects  are
  implemented in the category [10XIsMultiplicativeElementWithInverse[0m. A collection
  of  circle objects (e.g. adjoint semigroup or adjoint group) will lie in the
  category [10XIsCircleObjectCollection[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsCircleObject( 2 ); IsCircleObject( CircleObject( 2 ) );            [0X
    [4Xfalse[0X
    [4Xtrue[0X
    [4Xgap> IsMultiplicativeElementWithInverse( CircleObject( 2 ) );[0X
    [4Xtrue[0X
    [4Xgap> IsCircleObjectCollection( [ CircleObject(0), CircleObject(2) ] );[0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.1-4 IsPositionalObjectOneSlotRep[0m
  
  [2X> IsPositionalObjectOneSlotRep( [0X[3Xx[0X[2X ) __________________________[0XRepresentation
  [2X> IsDefaultCircleObject( [0X[3Xx[0X[2X ) _________________________________[0XRepresentation
  
  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  [10XIsPositionalObjectOneSlotRep[0m  for  a more general case.
  Then     we     defined    [10XIsDefaultCircleObject[0m    as    a    synonym    of
  [10XIsPositionalObjectOneSlotRep[0m for objects in [2XIsCircleObject[0m ([14X3.1-3[0m).
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsPositionalObjectOneSlotRep( CircleObject( 2 ) );[0X
    [4Xtrue[0X
    [4Xgap> IsDefaultCircleObject( CircleObject( 2 ) );                          [0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.1-5 CircleFamily[0m
  
  [2X> CircleFamily( [0X[3Xfam[0X[2X ) _____________________________________________[0Xattribute
  
  [10XCircleFamily(fam)[0m   is  a  family,  elements  of  which  are  in  one-to-one
  correspondence  with  elements  of  the  family  [3Xfam[0m,  but  with  the circle
  multiplication  as  an  infix  multiplication. That is, for x, y in [3Xfam[0m, the
  product  of their images in the [10XCircleFamily(fam)[0m will be the image of x + y
  +  x y. The relation between these families is demonstrated by the following
  equality:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> FamilyObj( CircleObject ( 2 ) ) = CircleFamily( FamilyObj( 2 ) );[0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X3.2 Operations with circle objects[0X
  
  [1X3.2-1 One[0m
  
  [2X> One( [0X[3Xx[0X[2X ) ________________________________________________________[0Xoperation
  
  This  operation  returns  the  multiplicative neutral element for the circle
  object  [3Xx[0m.  The  result  is  the circle object corresponding to the additive
  neutral element of the appropriate ring.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> One( CircleObject( 5 ) );[0X
    [4XCircleObject( 0 )[0X
    [4Xgap> One( CircleObject( 5 ) ) = CircleObject( Zero( 5 ) );[0X
    [4Xtrue[0X
    [4Xgap> One( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );[0X
    [4XCircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.2-2 InverseOp[0m
  
  [2X> InverseOp( [0X[3Xx[0X[2X ) __________________________________________________[0Xoperation
  
  For  a circle object [3Xx[0m, returns the multiplicative inverse of [3Xx[0m with respect
  to  the  circle  multiplication;  if  such  one  does not exist then [9Xfail[0m is
  returned.
  
  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.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> CircleObject( -2 )^-1;                        [0X
    [4XCircleObject( -2 )[0X
    [4Xgap> CircleObject( 2 )^-1; [0X
    [4XCircleObject( -2/3 )[0X
    [4Xgap> CircleObject( -2 )*CircleObject( -2 )^-1;[0X
    [4XCircleObject( 0 )[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> m := CircleObject( [ [ 1, 1 ], [ 0, 1 ] ] );   [0X
    [4XCircleObject( [ [ 1, 1 ], [ 0, 1 ] ] )[0X
    [4Xgap> m^-1;    [0X
    [4XCircleObject( [ [ -1/2, -1/4 ], [ 0, -1/2 ] ] )[0X
    [4Xgap> m * m^-1;[0X
    [4XCircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )[0X
    [4Xgap> CircleObject( [ [ 0, 1 ], [ 1, 0 ] ] )^-1; [0X
    [4Xfail[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.2-3 IsUnit[0m
  
  [2X> IsUnit( [0X[3X[R, ]x[0X[2X ) ________________________________________________[0Xoperation
  
  Let [3Xx[0m be a circle object corresponding to an element of the ring [3XR[0m. Then the
  operation  [10XIsUnit[0m  returns [10Xtrue[0m, if [3Xx[0m is invertible in [3XR[0m with respect to the
  circle multiplication, and [10Xfalse[0m otherwise.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsUnit( Integers, CircleObject( -2 ) );[0X
    [4Xtrue[0X
    [4Xgap> IsUnit( Integers, CircleObject( 2 ) ); [0X
    [4Xfalse[0X
    [4Xgap> IsUnit( Rationals, CircleObject( 2 ) );        [0X
    [4Xtrue[0X
    [4Xgap> IsUnit( ZmodnZ(8), CircleObject( ZmodnZObj(2,8) ) );[0X
    [4Xtrue[0X
    [4Xgap> m := CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] );;[0X
    [4Xgap> IsUnit( FullMatrixAlgebra( Rationals, 2 ), m );[0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  If  the  first argument is omitted, the result will be returned with respect
  to the default ring of the circle object [3Xx[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsUnit( CircleObject( -2 ) );[0X
    [4Xtrue[0X
    [4Xgap> IsUnit( CircleObject( 2 ) ); [0X
    [4Xfalse[0X
    [4Xgap> IsUnit( CircleObject( ZmodnZObj(2,8) ) );[0X
    [4Xtrue[0X
    [4Xgap> IsUnit( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );                                    [0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.2-4 IsCircleUnit[0m
  
  [2X> IsCircleUnit( [0X[3X[R, ]x[0X[2X ) __________________________________________[0Xoperation
  
  Let  [3Xx[0m  be  an  element  of the ring [3XR[0m. Then [10XIsCircleUnit( R, x )[0m determines
  whether [3Xx[0m is invertible in [3XR[0m with respect to the circle multilpication. This
  is  equivalent  to the condition that 1+[3Xx[0m is a unit in [3XR[0m with respect to the
  ordinary multiplication.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsCircleUnit( Integers, -2 );[0X
    [4Xtrue[0X
    [4Xgap> IsCircleUnit( Integers, 2 ); [0X
    [4Xfalse[0X
    [4Xgap> IsCircleUnit( Rationals, 2 );          [0X
    [4Xtrue[0X
    [4Xgap> IsCircleUnit( ZmodnZ(8), ZmodnZObj(2,8) ); [0X
    [4Xtrue[0X
    [4Xgap> m := [ [ 1, 1 ],[ 0, 1 ] ];                [0X
    [4X[ [ 1, 1 ], [ 0, 1 ] ][0X
    [4Xgap> IsCircleUnit( FullMatrixAlgebra(Rationals,2), m );[0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  If  the  first argument is omitted, the result will be returned with respect
  to the default ring of [3Xx[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> IsCircleUnit( -2 );                               [0X
    [4Xtrue[0X
    [4Xgap> IsCircleUnit( 2 ); [0X
    [4Xfalse[0X
    [4Xgap> IsCircleUnit( ZmodnZObj(2,8) );           [0X
    [4Xtrue[0X
    [4Xgap> IsCircleUnit( [ [ 1, 1 ],[ 0, 1 ] ] ); [0X
    [4Xtrue[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  
  [1X3.3 Construction of the adjoint semigroup and adjoint group[0X
  
  [1X3.3-1 AdjointSemigroup[0m
  
  [2X> AdjointSemigroup( [0X[3XR[0X[2X ) ___________________________________________[0Xattribute
  
  If  [3XR[0m is a finite ring then [10XAdjointSemigroup([3XR[0m[10X)[0m will return the monoid which
  is formed by all elements of [3XR[0m with respect to the circle multiplication.
  
  The implementation is rather straightforward and was added to provide a link
  to  the [5XGAP[0m functionality for semigroups. It assumes that the enumaration of
  all elements of the ring [3XR[0m is feasible.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> R:=Ring( [ ZmodnZObj(2,8) ] );[0X
    [4X<ring with 1 generators>[0X
    [4Xgap> S:=AdjointSemigroup(R);[0X
    [4X<monoid with 4 generators>[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.3-2 AdjointGroup[0m
  
  [2X> AdjointGroup( [0X[3XR[0X[2X ) _______________________________________________[0Xattribute
  
  If  [3XR[0m  is  a  finite  radical  algebra  then [10XAdjointGroup([3XR[0m[10X)[0m will return the
  adjoint group of [3XR[0m, given as a group generated by a set of circle objects.
  
  To  compute  the  adjoint group of a finite radical algebra, [5XCircle[0m uses the
  fact that all elements of a radical algebra form a group with respect to the
  circle  multiplication.  Thus,  the  adjoint  group  of  [3XR[0m  coincides with [3XR[0m
  elementwise, and we can randomly select an appropriate set of generators for
  the adjoint group.
  
  The  warning  is displayed by [10XIsGeneratorsOfMagmaWithInverses[0m method defined
  in [11Xgap4r4/lib/grp.gi[0m and may be ignored.
  
  [12XWARNINGS:[0m
  
  1.  The  set  of  generators  of  the returned group is not required to be a
  generating set of minimal possible order.
  
  2.  [10XAdjointGroup[0m  is  stored as an attribute of [3XR[0m, so for the same copy of [3XR[0m
  calling  it  again  you  will  get  the  same result. But if you will create
  another copy of [3XR[0m 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.
  
  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.
  
  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:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> x:=[ [ 0, 1, 0 ],[0X
    [4X>         [ 0, 0, 1 ],[0X
    [4X>         [ 0, 0, 0 ] ];;[0X
    [4Xgap> R := Algebra( GF(2), [ One(GF(2))*x ] );  [0X
    [4X<algebra over GF(2), with 1 generators>[0X
    [4Xgap> RadicalOfAlgebra( R ) = R;[0X
    [4Xtrue[0X
    [4Xgap> Dimension(R);[0X
    [4X2[0X
    [4Xgap> G := AdjointGroup( R );    [0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( [ [ 0*Z(2), 0*Z(2), Z(2)^0 ], [ 0*Z(2), 0*Z(2), 0*Z(2) ], [0X
    [4X      [ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ][0X
    [4X<group of size 4 with 2 generators>[0X
    [4Xgap> Size( R ) = Size( G );[0X
    [4Xtrue[0X
    [4Xgap> StructureDescription( G );[0X
    [4X"C4"[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  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:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> x:=[ [ 0, 1, 0 ],[0X
    [4X>         [ 0, 0, 0 ],     [0X
    [4X>         [ 0, 0, 0 ] ];;[0X
    [4Xgap> y:=[ [ 0, 0, 0 ],     [0X
    [4X>         [ 0, 0, 1 ],  [0X
    [4X>         [ 0, 0, 0 ] ];;[0X
    [4Xgap> R := Algebra( GF(2), One(GF(2))*[x,y] );  [0X
    [4X<algebra over GF(2), with 2 generators>[0X
    [4Xgap> RadicalOfAlgebra(R) = R;                [0X
    [4Xtrue[0X
    [4Xgap> Dimension(R);[0X
    [4X3[0X
    [4Xgap> G := AdjointGroup( R );[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( [ [ 0*Z(2), Z(2)^0, Z(2)^0 ], [ 0*Z(2), 0*Z(2), Z(2)^0 ], [0X
    [4X      [ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ][0X
    [4X<group of size 8 with 2 generators>[0X
    [4Xgap> StructureDescription( G );[0X
    [4X"D8"[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  If  the  ring  [3XR[0m  is  not  a  radical  algebra, then [5XCircle[0m will use another
  approach. We will enumerate all elements of the ring [3XR[0m 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.
  
  Of  course,  enumeration  of  all  elements of [3XR[0m should be feasible for this
  computation. In the following example we demonstrate how it works for rings,
  generated by residue classes:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,8) ] );[0X
    [4X<ring with 1 generators>[0X
    [4Xgap> G := AdjointGroup( R );[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 2, 8 ) ) ][0X
    [4X<group of size 4 with 2 generators>[0X
    [4Xgap> StructureDescription( G );[0X
    [4X"C2 x C2"[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,256) ] );   [0X
    [4X<ring with 1 generators>[0X
    [4Xgap> G := AdjointGroup( R );[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 234, 256 ) ) ][0X
    [4X<group of size 128 with 2 generators>[0X
    [4Xgap> StructureDescription( G );[0X
    [4X"C64 x C2"[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  Due  to  the  [2XAdjointSemigroup[0m ([14X3.3-1[0m), 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:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,256) ] );  [0X
    [4X<ring with 1 generators>[0X
    [4Xgap> S := AdjointSemigroup( R );[0X
    [4X<monoid with 128 generators>[0X
    [4Xgap> H := GreensHClassOfElement(S,One(S));[0X
    [4X{CircleObject( ZmodnZObj( 0, 256 ) )}[0X
    [4Xgap> G:=AsGroup(H);[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 0, 256 ) ), CircleObject( ZmodnZObj( 2, 256 ) ), [0X
    [4X  ... [0X
    [4X  CircleObject( ZmodnZObj( 250, 256 ) ), CircleObject( ZmodnZObj( 252, 256 ) )[0X
    [4X    , CircleObject( ZmodnZObj( 254, 256 ) ) ][0X
    [4X<group of size 128 with 2 generators>[0X
    [4Xgap> StructureDescription(G);[0X
    [4X"C64 x C2"[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  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
  [10XIsGeneratorsOfMagmaWithInverses[0m 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:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,1024) ] );   [0X
    [4X<ring with 1 generators>[0X
    [4Xgap> AdjointGroup(R); time;[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 136, 1024 ) ) ][0X
    [4X<group of size 512 with 3 generators>[0X
    [4X109[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,1024) ] );[0X
    [4X<ring with 1 generators>[0X
    [4Xgap> S:=AdjointSemigroup(R); AsGroup(GreensHClassOfElement(S,One(S))); time;[0X
    [4X<monoid with 512 generators>[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 0, 1024 ) ), CircleObject( ZmodnZObj( 2, 1024 ) ), [0X
    [4X  CircleObject( ZmodnZObj( 4, 1024 ) ), CircleObject( ZmodnZObj( 6, 1024 ) ), [0X
    [4X  ...[0X
    [4X  CircleObject( ZmodnZObj( 1018, 1024 ) ), [0X
    [4X  CircleObject( ZmodnZObj( 1020, 1024 ) ), [0X
    [4X  CircleObject( ZmodnZObj( 1022, 1024 ) ) ][0X
    [4X<group of size 512 with 2 generators>[0X
    [4X5474[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  Finally,  note  that  if [3XR[0m has a unity 1, then the set 1+R^ad, where R^ad is
  the  adjoint  semigroup  of  [3XR[0m,  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.
  
  Similarly,  the  set  1+R^*,  where R^* is the adjoint group of [3XR[0m, 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).
  
  We demonstrate this isomorphism using the following example.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> FG := GroupRing( GF(2), DihedralGroup(8) );[0X
    [4X<algebra-with-one over GF(2), with 3 generators>[0X
    [4Xgap> R := AugmentationIdeal( FG );[0X
    [4X<two-sided ideal in <algebra-with-one over GF(2), with 3 generators>, [0X
    [4X  (dimension 7)>[0X
    [4Xgap> G := AdjointGroup( R );[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( (Z(2)^0)*f2+(Z(2)^0)*f1*f2 ) ][0X
    [4X<group of size 128 with 4 generators>[0X
    [4Xgap> IdGroup( G );[0X
    [4X[ 128, 170 ][0X
    [4Xgap> IdGroup( Units( FG ) );[0X
    [4X#I  LAGUNA package: Computing the unit group ...[0X
    [4X[ 128, 170 ][0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  Thus,  dependently  on the ring [10XR[0m in question, it might be possible that you
  can compute much faster its unit group using [10XUnits(R)[0m than its adjoint group
  using  [10XAdjointGroup(R)[0m.  This  is  why  in  an attempt of computation of the
  adjoint group of the ring with one a warning message will be displayed:
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> AdjointGroup( GroupRing( GF(2), DihedralGroup(8) ) );[0X
    [4X[0X
    [4XWARNING: usage of AdjointGroup for associative ring <R> with one!!! [0X
    [4XIn this case the adjoint group is isomorphic to the unit group [0X
    [4XUnits(<R>), which possibly may be computed faster!!! [0X
    [4X[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^[0X
    [4X    0)*f1*f3 ) ][0X
    [4X<group of size 128 with 4 generators>[0X
    [4Xgap> AdjointGroup( Integers mod 11 );                  [0X
    [4X[0X
    [4XWARNING: usage of AdjointGroup for associative ring <R> with one!!! [0X
    [4XIn this case the adjoint group is isomorphic to the unit group [0X
    [4XUnits(<R>), which possibly may be computed faster!!! [0X
    [4X[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( Z(11)^0 ) ][0X
    [4X<group of size 10 with 1 generators>[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  If [3XR[0m is infinite, an error message will appear, telling that [5XCircle[0m does not
  provide methods to deal with infinite rings.
  
  
  [1X3.4 Service functions[0X
  
  [1X3.4-1 InfoCircle[0m
  
  [2X> InfoCircle______________________________________________________[0Xinfo class
  
  [10XInfoCircle[0m is a special Info class for [5XCircle[0m algorithms. It has 2 levels: 0
  (default)    and   1.   To   change   info   level   to   [10Xk[0m,   use   command
  [10XSetInfoLevel(InfoCircle, k)[0m.
  
  [4X---------------------------  Example  ----------------------------[0X
    [4X[0X
    [4Xgap> SetInfoLevel( InfoCircle, 1 );[0X
    [4Xgap> SetInfoLevel(InfoCircle,1);[0X
    [4Xgap> R := Ring( [ ZmodnZObj(2,8) ]);[0X
    [4X<ring with 1 generators>[0X
    [4Xgap> G := AdjointGroup( R );[0X
    [4X#I  Circle : <R> is not a radical algebra, computing circle units ...[0X
    [4X#I  Circle : searching generators for adjoint group ...[0X
    [4X#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0X
    [4X[ CircleObject( ZmodnZObj( 6, 8 ) ) ][0X
    [4X<group of size 4 with 2 generators>[0X
    [4Xgap> SetInfoLevel( InfoCircle, 0 );[0X
    [4X[0X
  [4X------------------------------------------------------------------[0X
  
  [1X3.4-2 CIRCLEBuildManual[0m
  
  [2X> CIRCLEBuildManual( [0X[3X[0X[2X ) ____________________________________________[0Xfunction
  
  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  [5XCircle[0m 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  [5XCircle[0m  which  requires UNIX/Linux
  environment.
  
  [1X3.4-3 CIRCLEBuildManualHTML[0m
  
  [2X> CIRCLEBuildManualHTML( [0X[3X[0X[2X ) ________________________________________[0Xfunction
  
  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 [5XCircle[0m 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.
  
