  
  [1m[4m[31m2. [1mCircle[1m[4m[31m functions[0m
  
  To use the [1mCircle[0m package first you need to load it as follows:
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> LoadPackage("circle");[0m
    [22m[35m-----------------------------------------------------------------------------[0m
    [22m[35mLoading  Circle 1.0 (Adjoint groups of associative rings)[0m
    [22m[35mby Alexander Konovalov (http://homepages.vub.ac.be/~okonoval/) and[0m
    [22m[35m   Panagiotis Soules (psoules@math.uoa.gr).[0m
    [22m[35m-----------------------------------------------------------------------------[0m
    [22m[35mtrue[0m
    [22m[35mgap>[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m2.1 Circle objects[0m
  
  Because  for  elements  of the ring R the ordinary multiplication is already
  denoted  by  [22m[32m*[0m,  for  the implementation of the circle multiplication in the
  adjoint  semigroup  we  need  to wrap up ring elements as CircleObjects, for
  which [22m[32m*[0m is defined to be the circle multiplication.
  
  [1m[4m[31m2.1-1 CircleObject[0m
  
  [1m[34m> CircleObject( [0m[22m[34mx[0m[1m[34m ) _______________________________________________[0mattribute
  
  Let  [22m[34mx[0m  be  a  ring  element. Then [22m[32mCircleObject(x)[0m returns the corresponding
  circle object. If [22m[34mx[0m lies in the family [22m[32mfam[0m, then [22m[32mCircleObject(x)[0m lies in the
  family [1m[34mCircleFamily[0m ([1m2.1-5[0m), corresponding to the family [22m[32mfam[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x := 2;                                   [0m
    [22m[35m2[0m
    [22m[35mgap> a := CircleObject( x );[0m
    [22m[35mCircleObject( 2 )[0m
    [22m[35mgap> FamilyObj( a ) = CircleFamily( FamilyObj( x ) ); [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.1-2 UnderlyingRingElement[0m
  
  [1m[34m> UnderlyingRingElement( [0m[22m[34mx[0m[1m[34m ) ______________________________________[0moperation
  
  Let  [22m[34mx[0m  be  a  circle  object.  Then  [22m[32mUnderlyingRingElement([22m[34mx[0m)[0m  returns  the
  corresponding ring element.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x := 2;                                   [0m
    [22m[35m2[0m
    [22m[35mgap> a := CircleObject( x );[0m
    [22m[35mCircleObject( 2 )[0m
    [22m[35mgap> UnderlyingRingElement( a );    [0m
    [22m[35m2[0m
    [22m[35mgap> FamilyObj( a ) = CircleFamily( FamilyObj( x ) ); [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.1-3 IsCircleObject[0m
  
  [1m[34m> IsCircleObject( [0m[22m[34mx[0m[1m[34m ) ______________________________________________[0mCategory
  [1m[34m> IsCircleObjectCollection( [0m[22m[34mx[0m[1m[34m ) ____________________________________[0mCategory
  
  An  object [22m[34mx[0m lies in the category [22m[32mIsCircleObject[0m if and only if it lies in a
  family  constructed  by  [1m[34mCircleFamily[0m  ([1m2.1-5[0m).  Since circle objects can be
  multiplied  via  [22m[32m*[0m  with  elements in their family, and we want to implement
  operations [22m[32mOne[0m and [22m[32mInverse[0m to deal with groups they generate, circle objects
  are implemented in the category [22m[32mIsMultiplicativeElementWithInverse[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsCircleObject( 2 );             [0m
    [22m[35mfalse[0m
    [22m[35mgap> IsCircleObject( CircleObject( 2 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsMultiplicativeElementWithInverse( CircleObject( 2 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> One( CircleObject( 2 ) );[0m
    [22m[35mCircleObject( 0 )[0m
    [22m[35mgap> CircleObject( -2 )^-1;[0m
    [22m[35mCircleObject( -2 )[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.1-4 IsPositionalObjectOneSlotRep[0m
  
  [1m[34m> IsPositionalObjectOneSlotRep( [0m[22m[34mx[0m[1m[34m ) __________________________[0mRepresentation
  [1m[34m> IsDefaultCircleObject( [0m[22m[34mx[0m[1m[34m ) _________________________________[0mRepresentation
  
  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  [22m[32mIsPositionalObjectOneSlotRep[0m  for  a more general case.
  Then     we     defined    [22m[32mIsDefaultCircleObject[0m    as    a    synonym    of
  [22m[32mIsPositionalObjectOneSlotRep[0m for objects in [1m[34mIsCircleObject[0m ([1m2.1-3[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsPositionalObjectOneSlotRep( CircleObject( 2 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsDefaultCircleObject( CircleObject( 2 ) );                          [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.1-5 CircleFamily[0m
  
  [1m[34m> CircleFamily( [0m[22m[34mfam[0m[1m[34m ) _____________________________________________[0mattribute
  
  [22m[32mCircleFamily(fam)[0m   is  a  family,  elements  of  which  are  in  one-to-one
  correspondence  with  elements  of  the  family  [22m[34mfam[0m,  but  with  the circle
  multiplication  as  an  infix  multiplication. That is, for x, y in [22m[34mfam[0m, the
  product  of their images in the [22m[32mCircleFamily(fam)[0m will be the image of x + y
  + x y.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x:=CircleObject(2)*CircleObject(3);                       [0m
    [22m[35mCircleObject( 11 )[0m
    [22m[35mgap> y:=CircleObject(2+3+2*3);[0m
    [22m[35mCircleObject( 11 )[0m
    [22m[35mgap> x=y;[0m
    [22m[35mtrue[0m
    [22m[35mgap> FamilyObj(x)=FamilyObj(y);                                                                 [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m2.2 Operations with circle objects[0m
  
  [1m[4m[31m2.2-1 OneOp[0m
  
  [1m[34m> OneOp( [0m[22m[34mx[0m[1m[34m ) ______________________________________________________[0moperation
  
  This  operation  returns  the  multiplicative neutral element for the circle
  object  [22m[34mx[0m.  The  result  is  the circle object corresponding to the additive
  neutral element of the appropriate ring.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> One( CircleObject( 5 ) );[0m
    [22m[35mCircleObject( 0 )[0m
    [22m[35mgap> One( CircleObject( 5 ) ) = CircleObject( Zero( 5 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> One( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );[0m
    [22m[35mCircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.2-2 InverseOp[0m
  
  [1m[34m> InverseOp( [0m[22m[34mx[0m[1m[34m ) __________________________________________________[0moperation
  
  For  a circle object [22m[34mx[0m, returns the multiplicative inverse of [22m[34mx[0m with respect
  to  the  circle  multiplication;  if  such  one  does not exist then [22m[32mfail[0m is
  returned.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> CircleObject( -2 )^-1;                        [0m
    [22m[35mCircleObject( -2 )[0m
    [22m[35mgap> CircleObject( 2 )^-1; [0m
    [22m[35mCircleObject( -2/3 )[0m
    [22m[35mgap> CircleObject( -2 )*CircleObject( -2 )^-1;[0m
    [22m[35mCircleObject( 0 )[0m
    [22m[35mgap> m := CircleObject( [ [ 1, 1 ], [ 0, 1 ] ] );   [0m
    [22m[35mCircleObject( [ [ 1, 1 ], [ 0, 1 ] ] )[0m
    [22m[35mgap> m^-1;    [0m
    [22m[35mCircleObject( [ [ -1/2, -1/4 ], [ 0, -1/2 ] ] )[0m
    [22m[35mgap> m * m^-1;[0m
    [22m[35mCircleObject( [ [ 0, 0 ], [ 0, 0 ] ] )[0m
    [22m[35mgap> CircleObject( [ [ 0, 1 ], [ 1, 0 ] ] )^-1; [0m
    [22m[35mfail[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.2-3 IsUnit[0m
  
  [1m[34m> IsUnit( [0m[22m[34mR, x[0m[1m[34m ) __________________________________________________[0moperation
  [1m[34m> IsUnit( [0m[22m[34mx[0m[1m[34m ) _____________________________________________________[0moperation
  
  Let [22m[34mx[0m be a circle object corresponding to an element of the ring [22m[34mR[0m. Then the
  operation  [22m[32mIsUnit[0m  returns [22m[32mtrue[0m, if [22m[34mx[0m is invertible in [22m[34mR[0m with respect to the
  circle multiplication, and [22m[32mfalse[0m otherwise.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsUnit( Integers, CircleObject( -2 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsUnit( Integers, CircleObject( 2 ) ); [0m
    [22m[35mfalse[0m
    [22m[35mgap> IsUnit( Rationals, CircleObject( 2 ) );        [0m
    [22m[35mtrue[0m
    [22m[35mgap> IsUnit( ZmodnZ(8), CircleObject( ZmodnZObj(2,8) ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> m := CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] );[0m
    [22m[35mCircleObject( [ [ 1, 1 ], [ 0, 1 ] ] )[0m
    [22m[35mgap> IsUnit( FullMatrixAlgebra( Rationals, 2 ), m );[0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  In  the  second form the result will be returned with respect to the default
  ring of the circle object [22m[34mx[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsUnit( CircleObject( -2 ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsUnit( CircleObject( 2 ) ); [0m
    [22m[35mfalse[0m
    [22m[35mgap> IsUnit( CircleObject( ZmodnZObj(2,8) ) );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsUnit( CircleObject( [ [ 1, 1 ],[ 0, 1 ] ] ) );                                    [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.2-4 IsCircleUnit[0m
  
  [1m[34m> IsCircleUnit( [0m[22m[34mR, x[0m[1m[34m ) ____________________________________________[0moperation
  [1m[34m> IsCircleUnit( [0m[22m[34mx[0m[1m[34m ) _______________________________________________[0moperation
  
  Let  [22m[34mx[0m  be  an  element  of the ring [22m[34mR[0m. Then [22m[32mIsCircleUnit( R, x )[0m determines
  whether [22m[34mx[0m is invertible in [22m[34mR[0m with respect to the circle multilpication. This
  is  equivalent  to the condition that 1+[22m[34mx[0m is a unit in [22m[34mR[0m with respect to the
  ordinary multiplication.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsCircleUnit( Integers, -2 );[0m
    [22m[35mtrue[0m
    [22m[35mgap> IsCircleUnit( Integers, 2 ); [0m
    [22m[35mfalse[0m
    [22m[35mgap> IsCircleUnit( Rationals, 2 );          [0m
    [22m[35mtrue[0m
    [22m[35mgap> IsCircleUnit( ZmodnZ(8), ZmodnZObj(2,8) ); [0m
    [22m[35mtrue[0m
    [22m[35mgap> m := [ [ 1, 1 ],[ 0, 1 ] ];                [0m
    [22m[35m[ [ 1, 1 ], [ 0, 1 ] ][0m
    [22m[35mgap> IsCircleUnit( FullMatrixAlgebra(Rationals,2), m );[0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  In  the  second form the result will be returned with respect to the default
  ring of [22m[34mx[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> IsCircleUnit( -2 );                               [0m
    [22m[35mtrue[0m
    [22m[35mgap> IsCircleUnit( 2 ); [0m
    [22m[35mfalse[0m
    [22m[35mgap> IsCircleUnit( ZmodnZObj(2,8) );           [0m
    [22m[35mtrue[0m
    [22m[35mgap> IsCircleUnit( [ [ 1, 1 ],[ 0, 1 ] ] ); [0m
    [22m[35mtrue[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  
  [1m[4m[31m2.3 Construction of the adjoint group[0m
  
  [1m[4m[31m2.3-1 AdjointGroup[0m
  
  [1m[34m> AdjointGroup( [0m[22m[34mR[0m[1m[34m ) _______________________________________________[0mattribute
  
  If  [22m[34mR[0m  is  a  finite  radical  algebra  then [22m[32mAdjointGroup([22m[34mR[0m)[0m will return the
  adjoint group of [22m[34mR[0m, given as a group generated by a set of circle objects.
  
  To  compute  the  adjoint group of a finite radical algebra, [1mCircle[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  [22m[34mR[0m  coincides with [22m[34mR[0m
  elementwise, and we can randomly select an appropriate set of generators for
  the adjoint group.
  
  The  warning  is displayed by [22m[32mIsGeneratorsOfMagmaWithInverses[0m method defined
  in [1mgap4r4/lib/grp.gi[0m and may be ignored.
  
  [1m[46mWARNINGS:[0m
  
  1.  The  set  of  generators of the returned group is not required to be the
  minimal generating set.
  
  2.  [22m[32mAdjointGroup[0m  is  stored as an attribute of [22m[34mR[0m, so for the same copy of [22m[34mR[0m
  calling  it  again  you  will  get  the  same result. But if you will create
  another copy of [22m[34mR[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:
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x:=[ [ 0, 1, 0 ],[0m
    [22m[35m>         [ 0, 0, 1 ],[0m
    [22m[35m>         [ 0, 0, 0 ] ];;[0m
    [22m[35mgap> R := Algebra( GF(2), [ One(GF(2))*x ] );  [0m
    [22m[35m<algebra over GF(2), with 1 generators>[0m
    [22m[35mgap> RadicalOfAlgebra( R ) = R;[0m
    [22m[35mtrue[0m
    [22m[35mgap> Dimension(R);[0m
    [22m[35m2[0m
    [22m[35mgap> G := AdjointGroup( R );    [0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( [ [ 0*Z(2), 0*Z(2), Z(2)^0 ], [ 0*Z(2), 0*Z(2), 0*Z(2) ], [0m
    [22m[35m      [ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ][0m
    [22m[35m<group of size 4 with 2 generators>[0m
    [22m[35mgap> Size( R ) = Size( G );[0m
    [22m[35mtrue[0m
    [22m[35mgap> StructureDescription( G );[0m
    [22m[35m"C4"[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  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:
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> x:=[ [ 0, 1, 0 ],[0m
    [22m[35m>         [ 0, 0, 0 ],     [0m
    [22m[35m>         [ 0, 0, 0 ] ];;[0m
    [22m[35mgap> y:=[ [ 0, 0, 0 ],     [0m
    [22m[35m>         [ 0, 0, 1 ],  [0m
    [22m[35m>         [ 0, 0, 0 ] ];;[0m
    [22m[35mgap> R := Algebra( GF(2), One(GF(2))*[x,y] );  [0m
    [22m[35m<algebra over GF(2), with 2 generators>[0m
    [22m[35mgap> RadicalOfAlgebra(R) = R;                [0m
    [22m[35mtrue[0m
    [22m[35mgap> Dimension(R);[0m
    [22m[35m3[0m
    [22m[35mgap> G := AdjointGroup( R );[0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( [ [ 0*Z(2), Z(2)^0, Z(2)^0 ], [ 0*Z(2), 0*Z(2), Z(2)^0 ], [0m
    [22m[35m      [ 0*Z(2), 0*Z(2), 0*Z(2) ] ] ) ][0m
    [22m[35m<group of size 8 with 2 generators>[0m
    [22m[35mgap> StructureDescription( G );[0m
    [22m[35m"D8"[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  If  the  ring  [22m[34mR[0m  is not a radical algebra, but also is not a ring with one,
  then [1mCircle[0m will use another approach. We will enumerate all elements of the
  ring  [22m[34mR[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 [22m[34mR[0m should be feasible for this
  computation. In the following example we demonstrate how it works for rings,
  generated by residue classes:
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> R := Ring( [ ZmodnZObj(2,8) ] );[0m
    [22m[35m<ring with 1 generators>[0m
    [22m[35mgap> G := AdjointGroup( R );[0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( ZmodnZObj( 2, 8 ) ) ][0m
    [22m[35m<group of size 4 with 2 generators>[0m
    [22m[35mgap> StructureDescription( G );[0m
    [22m[35m"C2 x C2"[0m
    [22m[35mgap> R := Ring( [ ZmodnZObj(2,256) ] );   [0m
    [22m[35m<ring with 1 generators>[0m
    [22m[35mgap> G := AdjointGroup( R );[0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( ZmodnZObj( 234, 256 ) ) ][0m
    [22m[35m<group of size 128 with 2 generators>[0m
    [22m[35mgap> StructureDescription( G );[0m
    [22m[35m"C64 x C2"[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  If [22m[34mR[0m has a unity 1, then the set 1+R^ad, where R^ad is the adjoint semigroup
  of [22m[34mR[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 [22m[34mR[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.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> FG := GroupRing( GF(2), DihedralGroup(8) );[0m
    [22m[35m<algebra-with-one over GF(2), with 3 generators>[0m
    [22m[35mgap> R := AugmentationIdeal( FG );[0m
    [22m[35m<two-sided ideal in <algebra-with-one over GF(2), with 3 generators>, [0m
    [22m[35m  (dimension 7)>[0m
    [22m[35mgap> G := AdjointGroup( R );[0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( (Z(2)^0)*f2+(Z(2)^0)*f1*f2 ) ][0m
    [22m[35m<group of size 128 with 4 generators>[0m
    [22m[35mgap> IdGroup( G );[0m
    [22m[35m[ 128, 170 ][0m
    [22m[35mgap> IdGroup( Units( FG ) );[0m
    [22m[35m#I  LAGUNA package: Computing the unit group ...[0m
    [22m[35m[ 128, 170 ][0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  This  is  is  why  we  did  not  implemented  in  [1mCircle[0m  adjoint groups for
  associative rings with one. If you will try to compute the adjoint group for
  such  a ring, you will get an error message telling that you can investigate
  the unit group of the ring instead.
  
  If [22m[34mR[0m is infinite, an error message will appear, telling that [1mCircle[0m does not
  provide methods to deal with infinite rings.
  
  
  [1m[4m[31m2.4 Service functions[0m
  
  [1m[4m[31m2.4-1 InfoCircle[0m
  
  [1m[34m> InfoCircle______________________________________________________[0minfo class
  
  [22m[32mInfoCircle[0m is a special Info class for [1mCircle[0m algorithms. It has 2 levels: 0
  (default)    and   1.   To   change   info   level   to   [22m[32mk[0m,   use   command
  [22m[32mSetInfoLevel(InfoCircle, k)[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m[0m
    [22m[35mgap> SetInfoLevel( InfoCircle, 1 );[0m
    [22m[35mgap> SetInfoLevel(InfoCircle,1);[0m
    [22m[35mgap> R := Ring( [ ZmodnZObj(2,8) ]);[0m
    [22m[35m<ring with 1 generators>[0m
    [22m[35mgap> G := AdjointGroup( R );[0m
    [22m[35m#I  Circle : <R> is not a radical algebra, computing circle units ...[0m
    [22m[35m#I  Circle : searching generators for adjoint group ...[0m
    [22m[35m#I  default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [0m
    [22m[35m[ CircleObject( ZmodnZObj( 6, 8 ) ) ][0m
    [22m[35m<group of size 4 with 2 generators>[0m
    [22m[35mgap> SetInfoLevel( InfoCircle, 0 );[0m
    [22m[35m[0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m2.4-2 CIRCLEBuildManual[0m
  
  [1m[34m> CIRCLEBuildManual( [0m[22m[34m[0m[1m[34m ) ____________________________________________[0mfunction
  
  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  [1mCircle[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  [1mCircle[0m  which  requires UNIX/Linux
  environment.
  
  [1m[4m[31m2.4-3 CIRCLEBuildManualHTML[0m
  
  [1m[34m> CIRCLEBuildManualHTML( [0m[22m[34m[0m[1m[34m ) ________________________________________[0mfunction
  
  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 [1mCircle[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.
  
