SSL unipot.gi Sprache: unbekannt

################################################################################
##
#W unipot.gi Unipot package Sergei Haller
##
#Y Copyright (C) 2000-2004, Sergei Haller
#Y Arbeitsgruppe Algebra, Justus-Liebig-Universitaet Giessen
##
## This is the implementation part of the package
##

################################################################################
##
#R IsUnipotChevRepByRootNumbers
#R IsUnipotChevRepByFundamentalCoeffs
#R IsUnipotChevRepByRoots
##
## Different representations for elements of unipotent subgroups.
##
## Roots of elements with representation `IsUnipotChevRepByRootNumbers' are
## represented by their numbers (positions) in `RootSystem().posroots'.
##
## Roots of elements with representation `IsUnipotChevRepByFundamentalCoeffs'
## are represented by coefficients of linear combinations of fundamental roots
## `RootSystem().fundroots'.
##
## Roots of elements with representation `IsUnipotChevRepByRoots' are
## represented by roots themself.
##

DeclareRepresentation( "IsUnipotChevRepByRootNumbers",
 IsAttributeStoringRep,
 [ "roots", "felems" ] );
DeclareRepresentation( "IsUnipotChevRepByFundamentalCoeffs",
 IsAttributeStoringRep,
 [ "roots", "felems" ] );
DeclareRepresentation( "IsUnipotChevRepByRoots",
 IsAttributeStoringRep,
 [ "roots", "felems" ] );

UNIPOT_DEFAULT_REP := IsUnipotChevRepByRootNumbers;

################################################################################
##
#F UnipotChevFamily( <type>, <n>, <F> )
##
## This function creates a UnipotChevFamily of type <type> and of rank <n>
## over the ring <F>.
##
## <type> must be one of "A", "B", "C", "D", "E", "F", "G"
## For the type "A", <n> must be a positive integer.
## For the types "B" and "C", <n> must be a positive integer >= 2.
## For the type "D", <n> must be a positive integer >= 4.
## For the type "E", <n> must be one of 6, 7, 8.
## For the type "F", <n> must be 4.
## For the type "G", <n> must be 2.
##

InstallGlobalFunction( UnipotChevFamily,
function( type, n, F )

 local Fam, # The new Family
 L, # The SimpleLieAlgebra of the given Type
 R, # The RootSystem of L
 V, # Vectorspace used to compute the posrootsFC
 B, # The Basis of L resp. V
 T, # StructureConstantsTable(B), taken from Lie Algebra
 N, # StructureConstantsTable as we need it.
 H,h, # ``half-the-Cartan-matrix''
 r,s; # two roots used in for-loops

 # check the Arguments ...
 if not ( type in ["A", "B", "C", "D", "E", "F", "G"] ) then
 Error( "<type> must be one of ",
 "\"A\", \"B\", \"C\", \"D\", \"E\", \"F\", \"G\" " );
 fi;

 if ( type = "A" ) and not IsPosInt( n ) then
 Error( "<n> must be a positive integer for type A " );
 elif ( type in ["B", "C"] ) and not (IsPosInt( n ) and n >= 2 ) then
 Error( "<n> must be a positive integer for type ", type, " " );
 elif ( type = "D" ) and not (IsPosInt( n ) and n >= 4 ) then
 Error( "<n> must be a positive integer for type D " );
 elif ( type = "E" ) and not ( n in [6 ..8] ) then
 Error( "<n> must be one of 6, 7, 8 for type E " );
 elif ( type = "F" ) and not ( n = 4 ) then
 Error( "<n> must be 4 for type F " );
 elif ( type = "G" ) and not ( n = 2 ) then
 Error( "<n> must be 2 for type G " );
 fi;

 if not ( IsRing( F ) ) then
 Error( "<F> must be a ring." );
 fi;

 # Construct the family of our unipotent element objects.
 Fam:= NewFamily( Concatenation("UnipotChevFam", type, String( n )),
 IsUnipotChevElem,
 IsObject,
 IsUnipotChevFamily );

##
#N In the following two cases the roots are the same, but we need rational
#N structure constants.
# L := SimpleLieAlgebra( type, n, F );
 L := SimpleLieAlgebra( type, n, Rationals );
 R := RootSystem( L );

 # Install the data.
 Fam!.type := type;
 Fam!.rank := n;
 Fam!.ring := F;
 Fam!.rootsystem := R;


 # Compute the structure constants ...
 N := NullMat( Length( PositiveRoots(R) ),
 Length( PositiveRoots(R) ) );

 if Fam!.type in ["B", "C", "F", "G"] then
# B := Basis( L, Concatenation( R.rootvecs,
# BasisVectors(Basis(CartanSubalgebra(L)))
# ));

 # NC = no check, ChevalleyBasis is a basis!
 # B := BasisNC( L, Flat(ChevalleyBasis( L )) );
 # CanonicalBasis is the Chevalley basis! and the structure
 # constants are already stored for CanonicalBasis.
 B := CanonicalBasis( L );

 T := StructureConstantsTable( B );
 # We only need a part of T,
 # example: N_{r,s} = T[r][s][2][1]

 for r in [1..Length( PositiveRoots(R) )] do
 for s in [1..Length( PositiveRoots(R) )] do
 if r < s and
 Position( PositiveRoots(R),
 Sum( PositiveRoots(R){[r,s]} )
 ) <> fail then
 N[r][s] := T[r][s][2][1];
 N[s][r] := T[s][r][2][1]; # = - N[r][s]
 fi;
 od;
 od;
 else # Simple laced types
 H := function( M )
 local h, i, j, l;
 l := Length(M);
 h := IdentityMat(l);
 for i in [1..l-1] do
 for j in [i+1..l] do
 h[i][j] := M[i][j];
 od;
 od;
 return h; # Immutable(h);
 end;
 h := H( CartanMatrix(R) );

 for r in [1..Length( PositiveRoots(R) )] do
 for s in [1..Length( PositiveRoots(R) )] do
 if r < s and
 Position( PositiveRoots(R),
 Sum( PositiveRoots(R){[r,s]} )
 ) <> fail then
 N[r][s] := (-1)^( PositiveRootsFC(R)[r]
 * h
 * PositiveRootsFC(R)[s] );
 N[s][r] := - N[r][s];
 fi;
 od;
 od;
 fi;

 Fam!.structconst := N; # war frueher T

 return Fam;
end
);

################################################################################
##
#M PrintObj( <Fam> ) . . . . . . . . . . . . . . . prints a `UnipotChevFamily'
##
## Special Method for `UnipotChevFamily'
##

InstallMethod( PrintObj,
 "for a UnipotChevFamily",
 [ IsUnipotChevFamily ],
 function( Fam )
 Print( "UnipotChevFamily( \"",
 Fam!.type, "\", ",
 Fam!.rank, ", ",
 Fam!.ring, " )"
 );
 end
);

################################################################################
##
#M <Fam1> = <Fam2> . . . . . . . . . . . . equality for two `UnipotChevFamily'
##
## Returns `true' if both Familys have the same type and equal underlying
## rings.
##
## Are using this in Equality for UnipotChevSubGr
##

InstallMethod( \=,
 "for two UnipotChevFamily",
 IsIdenticalObj,
 [ IsUnipotChevFamily,
 IsUnipotChevFamily ],
 function( Fam1, Fam2 )
 return IsIdenticalObj( Fam1, Fam2 )
 or ( ( Fam1!.type = Fam2!.type )
 and ( Fam1!.rank = Fam2!.rank )
 and ( Fam1!.ring = Fam2!.ring )
 );
 end
);

################################################################################
##
#M OneOp( <Fam> ) . . . . . . . . . . . the one-element of a `UnipotChevFamily'
##
## Returns the identity in the family
##

InstallOtherMethod( OneOp,
 "for a UnipotChevFamily",
 [ IsUnipotChevFamily ],
 Fam -> UnipotChevElem( Fam, rec(roots:=[], felems:=[]),
 UNIPOT_DEFAULT_REP )
);

################################################################################
##
#F UnipotChevSubGr( <type>, <n>, <F> )
##
## `UnipotChevSubGr' returns the unipotent subgroup $U$ of the Chevalley group
## of type <type>, rank <n> over the ring <F>.
##
## <type> must be one of "A", "B", "C", "D", "E", "F", "G"
## For the type "A", <n> must be a positive integer.
## For the types "B" and "C", <n> must be a positive integer >= 2.
## For the type "D", <n> must be a positive integer >= 4.
## For the type "E", <n> must be one of 6, 7, 8.
## For the type "F", <n> must be 4.
## For the type "G", <n> must be 2.
##

InstallGlobalFunction( UnipotChevSubGr,
function( type, n, F )
 local gr, Fam;

 Fam := UnipotChevFamily( type, n, F );

 gr := Objectify( NewType( CollectionsFamily( Fam ),
 IsUnipotChevSubGr and IsAttributeStoringRep
 ),
 rec()
 );

 SetIsWholeFamily( gr, true );

##
#N see Theorem 5.3.3(i) in [Car72]
##
 SetIsNilpotentGroup( gr, true );

##
## store the `RootSystem' in the attribute.
##
 SetRootSystem( gr, Fam!.rootsystem );

##
## Store the property `IsFinite' (if the group is finite or not).
## This helps choosing better Methods sometimes.
## This is a ``cheap'' call, whereas calculating the size of the
## group may require large powers of large integers.
##
 SetIsFinite( gr, IsFinite(F) );

 return gr;
end
);

################################################################################
##
#M PrintObj( ) . . . . . . . . . . . . . . . . . prints a `UnipotChevSubGr'
##
## Special Method for `UnipotChevSubGr'
##

InstallMethod( PrintObj,
 "for a UnipotChevSubGr",
 [ IsUnipotChevSubGr ],
 function( U )
 local Fam;
 Fam := ElementsFamily( FamilyObj( U ) );

 Print( "UnipotChevSubGr( \"",
 Fam!.type, "\", ",
 Fam!.rank, ", ",
 Fam!.ring, " )"
 );
 end
);

################################################################################
##
#M ViewObj( ) . . . . . . . . . . . . . . . . . . . for a `UnipotChevSubGr'
##
## Special Method for `UnipotChevSubGr'
##

InstallMethod( ViewObj,
 "for a UnipotChevSubGr",
 [ IsUnipotChevSubGr ], 1,
 function( U )
 local type,
 Fam;
 Fam := ElementsFamily( FamilyObj( U ) );
 type := Concatenation( Fam!.type, String(Fam!.rank) );

 Print("<Unipotent subgroup of a Chevalley group",
 " of type ", type, " over ");
 ViewObj( Fam!.ring ); Print(">");
 end
);

################################################################################
##
#M <U1> = <U2> . . . . . . . . . . . . . . . equality for two `UnipotChevSubGr'
##
## Special Method for `UnipotChevSubGr'
##

InstallMethod( \=,
 "for two UnipotChevSubGr",
 IsIdenticalObj,
 [ IsUnipotChevSubGr,
 IsUnipotChevSubGr ],
 function( U1, U2 )
 local Fam1, Fam2;

 Fam1 := ElementsFamily( FamilyObj( U1 ) );
 Fam2 := ElementsFamily( FamilyObj( U2 ) );

 return IsIdenticalObj( U1, U2 ) or Fam1 = Fam2;
 end
);

################################################################################
##
#M One( ) . . . . . . . . . . . . . the one-element of a `UnipotChevSubGr'
##
## Special Method for `UnipotChevSubGr'
##

InstallOtherMethod( One,
 "for a UnipotChevSubGr",
 [ IsUnipotChevSubGr ],
 U -> OneOp( U )
);

################################################################################
##
#M OneOp( ) . . . . . . . . . . . . the one-element of a `UnipotChevSubGr'
##
## Special Method for `UnipotChevSubGr'
##

InstallOtherMethod( OneOp,
 "for a UnipotChevSubGr",
 [ IsUnipotChevSubGr ],
 U -> One(ElementsFamily( FamilyObj( U ) ))
);

################################################################################
##
#M Size( ) . . . . . . . . . . . . . the size of a finite `UnipotChevSubGr'
##
## Special Method for finite `UnipotChevSubGr'
##
## Are using the result of [Car72], Theorem 5.3.3 (ii) to compute the size.
##

InstallMethod( Size,
 "for a finite UnipotChevSubGr",
 [ IsUnipotChevSubGr and IsFinite ],
 function( U )
 local Fam, R;

 Fam := ElementsFamily( FamilyObj( U ) );
 R := RootSystem(U);

 Info(UnipotChevInfo, 2, "The order of this group is ",
 Size(Fam!.ring),"^",Length(PositiveRoots(R)),
 " which is");
 return Size(Fam!.ring)^Length(PositiveRoots(R));
 end
);

################################################################################
##
#M GeneratorsOfGroup( ) . . . the generators of a finite `UnipotChevSubGr'
##
## Special Method for finite `UnipotChevSubGr'
##
##

InstallOtherMethod( GeneratorsOfGroup,
 "for a finite UnipotChevSubGr",
 [ IsUnipotChevSubGr and IsFinite ],
 function( U )
 local Fam;

 Fam := ElementsFamily( FamilyObj( U ) );

 return
 ListX( [1 .. Length(PositiveRoots(RootSystem(U)))],
 Difference( AsSet( Fam!.ring ), [Zero( Fam!.ring )] ),
 function( r, x )
 return UnipotChevElem( U, rec(roots:=[r], felems:=[x]), UNIPOT_DEFAULT_REP );
 end
 );
 end
);

################################################################################
##
#M CentralElement( ) . . . . . . . . . . . . . . . for a `UnipotChevSubGr'
##
## Returns an arbitrary element from the center of .
##
#T This one has no proper name now. the declaration part should go into
#T unipot.gd once it is working.
##

DeclareAttribute( "CentralElement", IsUnipotChevSubGr );

InstallMethod( CentralElement,
 "for a UnipotChevSubGr",
 [ IsUnipotChevSubGr ],
 function( U )
 local z, # the central element to be returned...
 t, tnr, # the indeterminates for z ...
 posrootsFC, r, # roots
 ring, # underlying ring
 comm, # the commutator of z with some elements ...
 ext, # external rep of a polynom
 i,j; # some loop variables ...



 posrootsFC := PositiveRootsFC(RootSystem(U));
 ring := ElementsFamily(FamilyObj(U))!.ring;

 # generate posroots many indeterminates...
 t := [];
 for r in [1..Length(posrootsFC)] do
 t[r] := Indeterminate( ring,
 Concatenation( "t_", String(r) ), t );
 od;

 # numbers of indeterminates ...
 tnr := List( t,
 s -> IndeterminateNumberOfUnivariateRationalFunction(s));

 # now <z> is an arbitrary Element in :
 # (in fact, we could have called Representative(), but
 # we want to modify the lists <t> and <tnr> later on.)
 z := UnipotChevElemByFC( U, posrootsFC, t );

 # compute the commutator of z with any root elements
 # and draw conclusions
 for r in Reversed(posrootsFC) do
 repeat
 comm := Comm( z,
 UnipotChevElemByFC( U, r, One(ring) ),
 "canonical" );
# Print("#I ");View(comm);Print("\n\n");
 for i in comm!.felems do
 ext := ExtRepPolynomialRatFun(i);
 # if it is NOT a sum
 if Length( ext ) = 2 then
 for j in [1..Length(ext[1])] do
 if IsOddInt(j) and ext[1][j] in tnr then
 j:=Position(tnr, ext[1][j]);
# Print("#I Eliminieren ",t[j],"\n");
 t[j] := Zero(ring);
 tnr[j] := Zero(ring);
 break;
 fi;
 od;
 fi;
 od;
 z := UnipotChevElemByFC( U, posrootsFC, t );
 until IsOne(comm);
 od;

 return z;
 end
);

################################################################################
##
#M IsCentral( , <z> ) . . . . for a `UnipotChevSubGr' and a `UnipotChevElem'
##

InstallMethod( IsCentral,
 "for a UnipotChevSubGr and a UnipotChevElem",
 IsCollsElms,
 [ IsUnipotChevSubGr, IsUnipotChevElem ],
 function( U, z )
 local posrootsFC, ring, r;

 # Treat the trivial case.
 if IsOne(z) then
 return true;
 fi;

 posrootsFC := PositiveRootsFC(RootSystem(U));
 ring := ElementsFamily(FamilyObj(U))!.ring;

 # The element <z> is central if and only if <z> commutes with all the
 # elements x_r(1), r a positive root.
 for r in posrootsFC do;
 if not IsOne(Comm(z, UnipotChevElemByFC( U, r, One(ring) ), "canonical")) then
 return false;
 fi;
 od;

 return true;
 end
);

################################################################################
##
#M Representative( ) . . . . . . . . . . . . . . . . . for `UnipotChevElem'
##
## this one returns an element with ineterminates over the underlying ring
## instead of the ring elements itself. This allows ``symbolic'' computations.
##

InstallMethod( Representative,
 "for a UnipotChevElem",
 [ IsUnipotChevSubGr ],
 function( U )
 local posroots, r, indets;
 posroots := PositiveRoots(RootSystem(U));

 indets := [];
 for r in [1..Length(posroots)] do
 Add(indets,
 Indeterminate( ElementsFamily(FamilyObj(U))!.ring,
 Concatenation("t_", String(r)),
 indets )
 );
 od;

 return UnipotChevElem( U, rec(roots := [1..Length(posroots)],
 felems := indets ), UNIPOT_DEFAULT_REP );
 end
);

################################################################################
##
#M UnipotChevElem( <Fam>, <record>, <rep> )
##
## This is an `undocumented' function and should not be used at the GAP prompt
##
## the <record> must be of the following form:
## rec( roots:=<roots>, felems:=<felems> )
## where <roots> is a list of numbers from [1 .. <n>], <n> the number of
## positive roots of the underlying root system and <felems> a list of the
## corresponding ring elements.
##

InstallOtherMethod( UnipotChevElem,
 "for UnipotChevFamily, a record and a string.",
 [IsUnipotChevFamily,
 IsRecord,
 IS_OPERATION],
 function( Fam, record, rep )
 local i, # loop variable
 roots,
 felems,
 roots1, # used for simplifying list
 F, # the ring
 obj; # the returned value

 roots := record.roots;
 felems := record.felems;

 F := Fam!.ring;

 # check the lists
 if not Length( roots ) = Length( felems ) then
 Error( "<roots> and <felems> must have same length" );
 fi;

 for i in [1 .. Length(roots)] do
 if not ( IsBound( roots[i] )
 and IsBound( felems[i] ) ) then
 Error(
 "<roots> and <felems> must be dense lists",
 " of root numbers and ring elements,",
 " respsctively.\n"
 );
 fi;
 if not ( felems[i] in F )
 and
 not IsIdenticalObj(ElementsFamily(FamilyObj(F)),
 CoefficientsFamily(FamilyObj(felems[i])))
 then
 Error( "<felems>[", i, "] must be an element ",
 "of the ring ", F, "\n",
 "or an Indeterminate over this ring." );
 fi;
 if not ( roots[i] in [1 .. Length( PositiveRoots(Fam!.rootsystem) )] ) then
 Error( "<roots>[", i, "] must be an integer",
 " in [1 .. <number of positive roots>]." );
 fi;
 od;

 if not rep in [ IsUnipotChevRepByRootNumbers,
 IsUnipotChevRepByFundamentalCoeffs,
 IsUnipotChevRepByRoots] then
 Error( "<rep> must be one of IsUnipotChevRepByRootNumbers,",
 " IsUnipotChevRepByFundamentalCoeffs,",
 " IsUnipotChevRepByRoots\n");
 fi;

 # use structural copies of the lists, so if one gave us mutable lists,
 # we do not mute them

 roots := StructuralCopy(roots);
 felems := StructuralCopy(felems);

##
#N Note: The corresponding repeat-loop somewhere in CanonicalForm( <x> )
#N MUST be always the same as the following loop here.
##
 # simplifying the element ...
 repeat
 roots1 := StructuralCopy(roots);
 for i in [ 1 .. Length(roots) ] do
 if felems[i] = Zero(F)
 or felems[i] = Zero(F)*Indeterminate(F) then
 Unbind( roots[i] );
 Unbind( felems[i] );
 elif i < Length(roots)
 and roots[i] = roots[i+1] then
 felems[i+1] := felems[i] + felems[i+1];
 Unbind( roots[i] );
 Unbind( felems[i] );
 fi;
 od;
 roots := Compacted( roots );
 felems := Compacted( felems );
 until roots = roots1;

 obj := Objectify( NewType( Fam,
 IsUnipotChevElem and
 rep and
 IsCopyable),
 rec( roots := roots,
 felems := felems )
 );


 # we alredy know the canonical form of the object if the
 # length of <roots> is < 2:
 # it is the object itself:
 if Length(roots) < 2 then
 SetCanonicalForm( obj, obj );
 fi;

 # we alredy know that the element is the identity if the
 # length of <roots> is 0:
 if Length(roots) = 0 then
 SetIsOne( obj, true );

 # and we alredy know that the element is not the identity if the
 # length of <roots> is 1:
 elif Length(roots) = 1 then
 SetIsOne( obj, false );
 fi;

 return obj;
 end
);

################################################################################
##
#M UnipotChevElem( , <record>, <rep> )
##
## This is an `undocumented' function and should not be used at the GAP prompt
##

InstallMethod( UnipotChevElem,
 "for UnipotChevSubGr, a record and a string",
 [IsUnipotChevSubGr,
 IsRecord,
 IS_OPERATION],
 function( U, record, rep )
 return UnipotChevElem( ElementsFamily(FamilyObj(U)), record, rep );
 end
);

################################################################################
##
#M UnipotChevElemByRootNumbers( , <roots>, <felems> )
##
## Returns an element of a unipotent subgroup with representation
## `IsUnipotChevRepByRootNumbers'.
##
## <roots> should be a list of numbers of the roots in
## `RootSystem().posroots' and <felems> a list of corresponding ring
## elements,
##

InstallMethod( UnipotChevElemByRootNumbers,
 "for UnipotChevSubGr and a list of positions of roots",
 [IsUnipotChevSubGr,
 IsList,
 IsList],
 function( U, roots, felems )
 return UnipotChevElem( U, rec( roots:=roots, felems:=felems ),
 IsUnipotChevRepByRootNumbers );
 end
);

################################################################################
##
#M UnipotChevElemByRoots( , <roots>, <felems> )
##
## Returns an element of a unipotent subgroup with representation
## `IsUnipotChevRepByRoots'.
##
## <roots> should be a list of roots in `RootSystem().posroots' and
## <felems> a list of corresponding ring elements,
##

InstallMethod( UnipotChevElemByRoots,
 "for UnipotChevSubGr and a list of roots",
 [IsUnipotChevSubGr,
 IsList,
 IsList],
 function( U, roots, felems )
 local list_of_positions,
 i,
 Fam,
 F;

 Fam := ElementsFamily(FamilyObj(U));

 F := Fam!.ring;
 list_of_positions := [];

 # check the lists
 if not Length( roots ) = Length( felems ) then
 Error( "<roots> and <felems> must have same length" );
 fi;
 for i in [1 .. Length(roots)] do
 if not ( IsBound( roots[i] )
 and IsBound( felems[i] ) ) then
 Error(
 "<roots> and <felems> must be dense lists",
 " of roots and ring elements,",
 " respsctively.\n"
 );
 fi;

 if not ( felems[i] in F )
 and
 not IsIdenticalObj(ElementsFamily(FamilyObj(F)),
 CoefficientsFamily(FamilyObj(felems[i])))
 then
 Error( "<felems>[", i, "] must be an element ",
 "of the ring ", F, "\n",
 "or an Indeterminate over this ring." );
 fi;

 Add( list_of_positions, Position( PositiveRoots(RootSystem(U)), roots[i] ) );

 if list_of_positions[i] = fail then
 Error( "<roots>[", i, "] must be a root." );
 fi;
 od;

 return UnipotChevElem( U, rec( roots := list_of_positions,
 felems := felems ),
 IsUnipotChevRepByRoots );
 end
);

################################################################################
##
#M UnipotChevElemByFundamentalCoeffs( , <roots>, <felems> )
##
## Returns an element of a unipotent subgroup with representation
## `IsUnipotChevRepByFundamentalCoeffs'.
##
## <roots> should be a list of roots as coefficients of a linear combination
## of fundamental roots `RootSystem().fundroots' and <felems> a list of
## corresponding ring elements,
##

InstallMethod( UnipotChevElemByFundamentalCoeffs,
 "for UnipotChevSubGr and a list of coordinates of roots",
 [IsUnipotChevSubGr,
 IsList,
 IsList],
 function( U, roots, felems )
 local list_of_positions,
 i,
 Fam,
 F;

 Fam := ElementsFamily(FamilyObj(U));

 F := Fam!.ring;
 list_of_positions := [];


 # check the lists
 if not Length( roots ) = Length( felems ) then
 Error( "<roots> and <felems> must have same length" );
 fi;
 for i in [1 .. Length(roots)] do
 if not ( IsBound( roots[i] )
 and IsBound( felems[i] ) ) then
 Error(
 "<roots> and <felems> must be dense lists",
 " of roots as coefficients of a linear",
 " combination of fundamental roots",
 " and ring elements,",
 " respsctively.\n"
 );
 fi;

 if not ( felems[i] in F )
 and
 not IsIdenticalObj(ElementsFamily(FamilyObj(F)),
 CoefficientsFamily(FamilyObj(felems[i])))
 then
 Error( "<felems>[", i, "] must be an element ",
 "of the ring ", F, "\n",
 "or an Indeterminate over this ring." );
 fi;

 Add( list_of_positions, Position( PositiveRootsFC(RootSystem(U)), roots[i] ) );

 if list_of_positions[i] = fail then
 Error( "<roots>[", i, "] must be a list of coefficients",
 " representing a root as a linear combination of",
 " fundamental roots." );
 fi;
 od;

 return UnipotChevElem( U, rec( roots := list_of_positions,
 felems := felems ),
 IsUnipotChevRepByFundamentalCoeffs );
 end
);

################################################################################
##
#M UnipotChevElemByRootNumbers( , <root>, <felem> )
#M UnipotChevElemByRoots( , <root>, <felem> )
#M UnipotChevElemByFundamentalCoeffs( , <root>, <felem> )
##
## These are abbreviations for `UnipotChevElemByXX( , [<root>], [<felem>] )'
##

InstallOtherMethod( UnipotChevElemByRootNumbers,
 "for UnipotChevSubGr, a position of a root and a ring rlement",
 [IsUnipotChevSubGr,
 IsPosInt,
 IsObject], # the third argument must be an element of Fam!.ring
 function( U, root, felem )
 return UnipotChevElemByRootNumbers( U, [root], [felem] );
 end
);

InstallOtherMethod( UnipotChevElemByRoots,
 "for UnipotChevSubGr, a root and a ring rlement",
 [IsUnipotChevSubGr,
 IsList,
 IsObject], # the third argument must be an element of Fam!.ring
 function( U, root, felem )
 return UnipotChevElemByRoots( U, [root], [felem] );
 end
);

InstallOtherMethod( UnipotChevElemByFundamentalCoeffs,
 "for UnipotChevSubGr, a lin. comb. of fund. roots and a ring element",
 [IsUnipotChevSubGr,
 IsList,
 IsObject], # the third argument must be an element of Fam!.ring
 function( U, root, felem )
 return UnipotChevElemByFundamentalCoeffs( U, [root], [felem] );
 end
);

################################################################################
##
#M UnipotChevElemByRootNumbers( , <list> )
#M UnipotChevElemByRoots( , <list> )
#M UnipotChevElemByFundamentalCoeffs( , <list> )
##
#N These are old versions of `UnipotChevElemByXX'.
#N They are *deprecated* and installed for compatibility only.
#N They may be removed at any time.
##

InstallOtherMethod( UnipotChevElemByRootNumbers,
 "for UnipotChevSubGr and a list. ***DEPRECATED***",
 [IsUnipotChevSubGr,
 IsList],
 function( U, list )
 local roots, felems, i;

 Info(InfoWarning, 1, "UnipotChevElemByRootNumbers( , <list> ) is ***DEPRECATED***");

 roots := [];
 felems := [];

 # no checking the list at all.
 for i in [1 .. Length(list)] do;
 Add( roots, list[i].r );
 Add( felems, list[i].x );
 od;
 return UnipotChevElemByRootNumbers( U, roots, felems );
 end
);

InstallOtherMethod( UnipotChevElemByRoots,
 "for UnipotChevSubGr and a list. ***DEPRECATED***",
 [IsUnipotChevSubGr,
 IsList],
 function( U, list )
 local roots, felems, i, Fam;

 Info(InfoWarning, 1, "UnipotChevElemByRoots( , <list> ) is ***DEPRECATED***");

 roots := [];
 felems := [];

 # no checking the list at all.
 for i in [1 .. Length(list)] do;
 Add( roots, list[i].r );
 Add( felems, list[i].x );
 od;
 return UnipotChevElemByRoots( U, roots, felems );
 end
);

InstallOtherMethod( UnipotChevElemByFundamentalCoeffs,
 "for UnipotChevSubGr and a list. ***DEPRECATED***",
 [IsUnipotChevSubGr,
 IsList],
 function( U, list )
 local roots, felems, i, Fam;

 Info(InfoWarning, 1, "UnipotChevElemByFundamentalCoefficions( , <list> ) is ***DEPRECATED***");

 roots := [];
 felems := [];

 # no checking the list at all.
 for i in [1 .. Length(list)] do;
 Add( roots, list[i].coeffs );
 Add( felems, list[i].x );
 od;
 return UnipotChevElemByFundamentalCoeffs( U, roots, felems );
 end
);

################################################################################
##
#M UnipotChevElemByRootNumbers( <x> )
#M UnipotChevElemByFundamentalCoeffs( <x> )
#M UnipotChevElemByRoots( <x> )
##
## These are provided for converting elements to diferent representations.
##
## E.g. If <x> has already the representation `IsUnipotChevRepByRoots',
## then <x> itself is returned by `UnipotChevElemByRoots( <x> ).
## Otherwise a *new* element with given representation is constructed.
##

DeclareGlobalFunction( "ChangeUnipotChevRep" );
InstallOtherMethod( UnipotChevElemByRootNumbers,
 "for UnipotChevElem",
 [IsUnipotChevElem],
 function( x )
 if IsUnipotChevRepByRootNumbers(x) then
 return x;
 else
 return ChangeUnipotChevRep( x,
 IsUnipotChevRepByRootNumbers );
 fi;
 end
);

InstallOtherMethod( UnipotChevElemByFundamentalCoeffs,
 "for UnipotChevElem",
 [IsUnipotChevElem],
 function( x )
 if IsUnipotChevRepByFundamentalCoeffs(x) then
 return x;
 else
 return ChangeUnipotChevRep( x,
 IsUnipotChevRepByFundamentalCoeffs );
 fi;
 end
);

InstallOtherMethod( UnipotChevElemByRoots,
 "for UnipotChevElem",
 [IsUnipotChevElem],
 function( x )
 if IsUnipotChevRepByRoots(x) then
 return x;
 else
 return ChangeUnipotChevRep( x,
 IsUnipotChevRepByRoots );
 fi;
 end
);

InstallGlobalFunction( ChangeUnipotChevRep,
 function( x, rep )
 local Fam,
 new_obj,
 new_inv,
 new_canon;

 Fam := FamilyObj(x);

 new_obj := UnipotChevElem( Fam, rec( roots := x!.roots,
 felems := x!.felems ),
 rep );

 if HasIsOne(x) then
 SetIsOne( new_obj, IsOne(x) );
 fi;

 if HasInverse(x) then
 if IsIdenticalObj(x, Inverse(x)) then
 SetInverse( new_obj, new_obj );
 else
 new_inv := UnipotChevElem( Fam,
 rec( roots := Inverse(x)!.roots,
 felems := Inverse(x)!.felems ),
 rep );
 if HasIsOne(Inverse(x)) then
 SetIsOne( new_inv, IsOne(x) );
 fi;
 SetInverse( new_obj, new_inv );
 SetInverse( new_inv, new_obj );
 if HasCanonicalForm(x^-1) then
 if IsIdenticalObj(x^-1, CanonicalForm(x^-1)) then
 SetCanonicalForm( new_obj^-1, new_obj^-1 );
 else
 new_canon :=
 UnipotChevElem(
 Fam,
 rec( roots := CanonicalForm(x^-1)!.roots,
 felems := CanonicalForm(x^-1)!.felems ),
 rep );
 # CanonicalForm always HasIsOne !
 SetIsOne( new_canon, IsOne(x) );
 SetCanonicalForm( new_inv, new_canon );
 SetCanonicalForm( new_canon, new_canon );
 SetInverse( new_canon, new_obj );
 fi;

 fi;
 fi;
 fi;
 if HasCanonicalForm(x) then
 if IsIdenticalObj( x, CanonicalForm(x) ) then
 SetCanonicalForm( new_obj, new_obj );
 else
 new_canon := UnipotChevElem(
 Fam,
 rec( roots := CanonicalForm(x)!.roots,
 felems := CanonicalForm(x)!.felems ),
 rep );
 SetCanonicalForm( new_obj, new_canon );
 SetCanonicalForm( new_canon, new_canon );
 if HasInverse( new_obj ) then
 SetInverse( new_canon, Inverse(new_obj) );
 fi;
 fi;
 fi;



 return new_obj;
 end
);

################################################################################
##
#M PrintObj( <x> ) . . . . . . . . . . . . . . . . . prints a `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##

InstallMethod( PrintObj,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ], 1,
 function( x )
 local Fam;
 Fam := FamilyObj(x);

 if Length(x!.roots) = 0 then
 Print("One( ", "UnipotChevSubGr( \"",
 Fam!.type, "\", ",
 Fam!.rank, ", ",
 Fam!.ring, " )");
 else
 if IsUnipotChevRepByRootNumbers(x) then
 Print( "UnipotChevElemByRootNumbers" );
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 Print( "UnipotChevElemByFundamentalCoeffs" );
 elif IsUnipotChevRepByRoots(x) then
 Print( "UnipotChevElemByRoots" );
 fi;

 Print( "( ", "UnipotChevSubGr( \"",
 Fam!.type, "\", ",
 Fam!.rank, ", ",
 Fam!.ring, " )", ", " );

 if IsUnipotChevRepByRootNumbers(x) then
 Print( x!.roots );
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 Print( List(x!.roots, r -> PositiveRootsFC(Fam!.rootsystem)[r] ));
 elif IsUnipotChevRepByRoots(x) then
 Print( List(x!.roots, r -> PositiveRoots (Fam!.rootsystem)[r] ));
 fi;

 Print( ", ", x!.felems, " )");

 fi;
 end
);

################################################################################
##
#M ViewObj( <x> ) . . . . . . . . . . . . . . . . . . . . for `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
#T maybe should check for the length of the output and "beautify" the output
#T depending on the SizeScreen()
##

InstallMethod( ViewObj,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 function( x )
 local r, R;

 R := FamilyObj(x)!.rootsystem;

 if Length( x!.roots ) = 0 then
 Print( "<identity>" );
 else
 for r in [ 1 .. Length(x!.roots) ] do
 if r > 1 then Print(" * "); fi;
 Print( "x_{" );
 if IsUnipotChevRepByRootNumbers(x) then
 ViewObj( x!.roots[r] );
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 ViewObj( PositiveRootsFC(R)[ x!.roots[r] ] );
 elif IsUnipotChevRepByRoots(x) then
 ViewObj( PositiveRoots (R)[ x!.roots[r] ] );
 fi;
 Print( "}( " );
 ViewObj( x!.felems[r] );
 Print( " )" );
 od;
 fi;
 end
);

################################################################################
##
#M ShallowCopy( <x> ) . . . . . . . . . . . . . . . . . . for `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## should we have different Methods for each Representation? this means much
## code duplication ...
##

InstallMethod( ShallowCopy,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 function( x )
 local rep, copy;

 if IsUnipotChevRepByRootNumbers(x) then
 rep := IsUnipotChevRepByRootNumbers;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 rep := IsUnipotChevRepByFundamentalCoeffs(x);
 elif IsUnipotChevRepByRoots(x) then
 rep := IsUnipotChevRepByRoots;
 fi;

 copy := UnipotChevElem( FamilyObj( x ),
 rec( roots := x!.roots,
 felems := x!.felems ),
 rep );

 if HasInverse(x) then
 SetInverse(copy, Inverse(x));
 fi;
 if HasCanonicalForm(x) then
 SetCanonicalForm(copy, CanonicalForm(x));
 fi;
 if HasIsOne(x) then
 SetIsOne(copy, IsOne(x));
 fi;

 return copy;
 end
);

################################################################################
##
#M <x> = <y> . . . . . . . . . . . . . . . . equality for two `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## If <x> and <y> are identical or are products of the *same* root elements
## then `true' is returned. Otherwise canonical form of both arguments must be
## computed (if not already known), which may be expensive.
##

InstallMethod( \=,
 "for two UnipotChevElem",
 IsIdenticalObj,
 [ IsUnipotChevElem,
 IsUnipotChevElem ],
 function( x, y )
 if IsIdenticalObj( x,y ) or
 ( x!.roots = y!.roots and x!.felems = y!.felems ) then
 return true;
 else

 if not HasCanonicalForm(x) then
 Info(UnipotChevInfo, 3,
 "CanonicalForm for the 1st argument is not known.");
 Info(UnipotChevInfo, 3,
 " computing it may take a while.");
 fi;
 if not HasCanonicalForm(y) then
 Info(UnipotChevInfo, 3,
 "CanonicalForm for the 2nd argument is not known.");
 Info(UnipotChevInfo, 3,
 " computing it may take a while.");
 fi;

 return CanonicalForm(x)!.roots = CanonicalForm(y)!.roots
 and CanonicalForm(x)!.felems = CanonicalForm(y)!.felems;
 fi;
 end
);

################################################################################
##
#M <x> < <y> . . . . . . . . . . . . . . . . less than for two `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## This is needed e.g. by `AsSSortetList'.
##
## The ordering is computed in the following way:
## Let x = x_{r_1}(s_1) ... x_{r_n}(s_n)
## and y = x_{r_1}(t_1) ... x_{r_n}(t_n), then
##
## x < y <=> [ s_1, ..., s_n ] < [ t_1, ..., t_n ],
##
## where the lists are compared lexicographically.
## e.g. x = x_1(1)x_2(1) = x_1(1)x_2(1)x_3(0) --> field elems: [ 1, 1, 0 ]
## y = x_1(1)x_3(1) = x_1(1)x_2(0)x_3(1) --> field elems: [ 1, 0, 1 ]
## --> y < x (above lists ordered lexicographically)
##

InstallMethod( \<,
 "for two UnipotChevElem",
 IsIdenticalObj,
 [ IsUnipotChevElem,
 IsUnipotChevElem ],
 function( x, y )
 local Fam, R, r, pos, tx, ty, o;

 if IsIdenticalObj( x,y ) or
 ( x!.roots = y!.roots and x!.felems = y!.felems ) then
 return false;
 else

 if not HasCanonicalForm(x) then
 Info(UnipotChevInfo, 3,
 "CanonicalForm for the 1st argument is not known.");
 Info(UnipotChevInfo, 3,
 " computing it may take a while.");
 fi;
 if not HasCanonicalForm(y) then
 Info(UnipotChevInfo, 3,
 "CanonicalForm for the 2nd argument is not known.");
 Info(UnipotChevInfo, 3,
 " computing it may take a while.");
 fi;

 Fam := FamilyObj(x);
 R := Fam!.rootsystem;
 o := Zero(Fam!.ring);

 for r in [1 .. Length(PositiveRoots(R))] do;

 pos := Position( CanonicalForm(x)!.roots, r );
 if pos = fail then tx := o;
 else tx := CanonicalForm(x)!.felems[pos];
 fi;
 pos := Position( CanonicalForm(y)!.roots, r );
 if pos = fail then ty := o;
 else ty := CanonicalForm(y)!.felems[pos];
 fi;
 if not tx = ty then
 return tx < ty;
 fi;
 od;

 return false;
 fi;
 end
);

################################################################################
##
#M <x> * <y> . . . . . . . . . . . . . multiplication for two `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
#N The representation of the product will be always the representation of the
#N first argument.
##

InstallMethod( \*,
 "for two UnipotChevElem",
 IsIdenticalObj,
 [ IsUnipotChevElem,
 IsUnipotChevElem ],
 function( x, y )
 local rep;

 if IsUnipotChevRepByRootNumbers(x) then
 rep := IsUnipotChevRepByRootNumbers;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 rep := IsUnipotChevRepByFundamentalCoeffs;
 elif IsUnipotChevRepByRoots(x) then
 rep := IsUnipotChevRepByRoots;
 fi;

 return UnipotChevElem(
 FamilyObj( x ),
 rec( roots := Concatenation( x!.roots, y!.roots ),
 felems := Concatenation( x!.felems, y!.felems ) ),
 rep
 );
 end
);

################################################################################
##
#M <x>^ . . . . . . . . . . . . . . . . . integer powers of `UnipotChevElem'
##
## Special methods for root elements and for the identity.
##

InstallMethod( \^,
 "for a root element UnipotChevElem and an integer",
 [ IsUnipotChevElem and IsRootElement,
 IsInt ],
 function( x, i )
 local rep;

 if IsUnipotChevRepByRootNumbers(x) then
 rep := IsUnipotChevRepByRootNumbers;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 rep := IsUnipotChevRepByFundamentalCoeffs;
 elif IsUnipotChevRepByRoots(x) then
 rep := IsUnipotChevRepByRoots;
 fi;

 return UnipotChevElem(
 FamilyObj( x ),
 rec( roots := x!.roots,
 felems := [ i * x!.felems[1] ] ),
 rep
 );
 end
);

InstallMethod( \^,
 "for a identity UnipotChevElem and an integer",
 [ IsUnipotChevElem and IsOne,
 IsInt ],
 function( x, i )
 return x;
 end
);

################################################################################
##
#M OneOp( <x> ) . . . . . . . . . . . . . the one-element of a `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## `OneOp' returns the multiplicative neutral element of <x>. This is equal to
## <x>^0.
##

InstallMethod( OneOp,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 x -> One( FamilyObj( x ) )
);

################################################################################
##
#M IsOne( <x> ) . . . . . . . . . . . . the one-property of a `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##

InstallMethod( IsOne,
 "for a UnipotChevElem with known canonical form",
 [ IsUnipotChevElem and HasCanonicalForm ], 1,
 x -> IsOne( CanonicalForm( x ) )
);

InstallMethod( IsOne,
 "for a UnipotChevElem with known inverse",
 [ IsUnipotChevElem and HasInverse ],
 function( x )
 if HasIsOne( Inverse(x) ) then
 return IsOne( Inverse(x) );
 else
 TryNextMethod();
 fi;
 end
);

InstallMethod( IsOne,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 x -> IsOne( CanonicalForm( x ) )
);

################################################################################
##
#M Inverse( <x> ) . . . . . . . . . . . . . . the inverse of a `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##

InstallMethod( Inverse,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 function( x )
 local inv, rep;
 if HasCanonicalForm( x ) and HasInverse(CanonicalForm( x )) then
 return Inverse(CanonicalForm( x ));
 fi;

 if IsUnipotChevRepByRootNumbers(x) then
 rep := IsUnipotChevRepByRootNumbers;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 rep := IsUnipotChevRepByFundamentalCoeffs;
 elif IsUnipotChevRepByRoots(x) then
 rep := IsUnipotChevRepByRoots;
 fi;

 inv := UnipotChevElem(
 FamilyObj( x ),
 rec( roots := Reversed(x!.roots),
 felems := -Reversed(x!.felems) ),
 rep
 );

 # We alredy know the inverse of inv: it's x itself.
 SetInverse( inv, x );

 # Unfortunately we don't know the CanonicalForm for inv even
 # if we know it for x. If we would, we would store it here.
 # (Note that ``know'' have to be understood in the sense that
 # it is very cheap to get such a value.)

 # but the inverse of the canonical form of x is the same as
 # the inverse of x:
 if HasCanonicalForm( x ) then
 SetInverse( CanonicalForm(x), inv );
 fi;

 # if the Property IsOne of x is known, so it is also known for
 # the inverse!
 if HasIsOne( x ) then
 SetIsOne( inv, IsOne(x) );
 fi;

 return inv;
 end
);

################################################################################
##
#M InverseOp( <x> ) . . . . . . . . . . . . . the inverse of a `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
#N Ref, Chapter 28 (?reference:inverse) sais:
#N The default method of `Inverse' is to call `InverseOp' (note that
#N `InverseOp' must *not* delegate to `Inverse'); other methods to
#N compute inverses need to be installed only for `InverseOp'.
#N
#N In our case computing Inverse may be very time intensive, so
#N we want to call `Inverse' instead of `InverseOp' because we
#N want the inverse to be stored as attribute once computed
#N
#N In fact, the canonical form of an element is the time intensive
#N operation. But consider the following example:
#N x := UnipotChevElem(...);
#N y := x^-1;
#N CanonicalForm(y);
#N z := x^-1;
#N CanonicalForm(z); # must be computed again if Inverse not stored in x
#N
#N Note, that delegating `InverseOp' to `Inverse' *requires*
#N `Inverse' to be overwritten not to call `InverseOp'.
##

InstallMethod( InverseOp,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 x -> Inverse(x)
);

################################################################################
##
#F ChevalleyCommutatorConstant( , <j>, <r>, <s>, <Fam> )
##
## This is an `undocumented' function and should not be used at the GAP prompt
##
## The constants occuring in Chevalley's commutator formula. We compute them
## as Rationals and embed them in the given ring afterwards. (It is known of
## them to be in [ 1, -1, 2, -2, 3, -3 ], in Char 2 this would be [ 1, 0 ] =
## [ 1, 1, 0, 0, 1, 1 ] )
##
## The meaning of the arguments comes from the commutator formula, where <r>
## and <s> are not the roots themself but their indices.
## (e.g. roots are $r = r1$ and $s = r2$ --> arguments are $r = 1$, $s = 2$)
##

InstallGlobalFunction( ChevalleyCommutatorConstant,
 function( i, j, r, s, Fam)
 local M, N,
 const,
 roots,
 F;

 M := function( r, s, i )
 local m, # the returned value
 k,p; # used in the for-loop

 m := 1;
 Info( UnipotChevInfo, 6,
 "M( ", r, ", ", s, ", ", i, " ) = 1/", Factorial(i) );

 for k in [ 0 .. i-1 ] do
 p := Position( roots, k * roots[r] + roots[s] );
 Info( UnipotChevInfo, 6, " * N( ", r, ", ", p, " )",
 " [ = ", N[r][p], " ]" );
 m := m * N[r][p];
 od;

 return m/Factorial(i);
 end;

 roots := PositiveRoots(Fam!.rootsystem);
 F := Fam!.ring;
 N := Fam!.structconst;

 if not (r in [1 .. Length(roots)] and s in [1 .. Length(roots)]) then
 Error( "<r> and <s> must be integers in",
 " [1 .. <number of positive roots>]." );
 fi;
 if not IsUnipotChevFamily(Fam) then
 Error( "<Fam> must be UnipotChevFamily (not ",
 FamilyObj(Fam), ")." );
 fi;

 Info(UnipotChevInfo, 6, "C( ", i, ", ", j, ", ", r, ", ", s, " ) = ");


 if j=1 then
 Info( UnipotChevInfo, 6,
 " = M( ", r, ", ", s, ", ", i, " )" );
 const := M( r, s, i );
 elif i=1 then
 Info( UnipotChevInfo, 6,
 " = -1^", j, " * M( ", s, ", ", r, ", ", j, " )" );
 const := (-1)^j * M( s, r, j );
 elif i=3 and j=2 then
 Info( UnipotChevInfo, 6,
 " = 1/3 * M( ",
 Position( roots, roots[r]+roots[s] ),
 ", ", r, ", ", 2, " )" );
 const := 1/3 * M( Position( roots, roots[r]+roots[s] ), r, 2 );
 elif i=2 and j=3 then
 Info( UnipotChevInfo, 6,
 " = -2/3 * M( ",
 Position( roots, roots[s]+roots[r] ),
 ", ", s,", ", 2, " )" );
 const := -2/3 * M( Position( roots, roots[s]+roots[r] ), s, 2 );
 else
 Error("i=",i, ", j=", j, " are illegal parameters.");
 fi;

 if not (const in [ 1, 2, 3, -1, -2, -3 ]) then
 Error("Something's gone wrong: the constant should be in",
 " [ 1, 2, 3, -1, -2, -3 ]\n",
 "instead of ", const);
 fi;

 return const*One(F);
 end
);

################################################################################
##
#M <x>^<y> . . . . . . . . . . . . . . . . . conjugation with `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## Doesn't do anything more than the default Method, but it stores the inverse
## of <y>. And the result has the representation of <x>. (The default method
## would return an element with representation of <y>.)
##

InstallMethod( \^,
 "for two UnipotChevElem's",
 [ IsUnipotChevElem,
 IsUnipotChevElem ],
 function( x, y )
 local fun;

 if IsUnipotChevRepByRootNumbers(x) then
 fun := UnipotChevElemByRN;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 fun := UnipotChevElemByFC;
 elif IsUnipotChevRepByRoots(x) then
 fun := UnipotChevElemByR;
 fi;

 return fun( y^-1 * x * y );
 end
);

################################################################################
##
#M Comm( <x>, <y> ) . . . . . . . . . . . . commutator of two `UnipotChevElem'
##
## Special Method for `UnipotChevElem'
##
## Doesn't do anything more than the default Method, but it stores the inverse
## elements of <x> and <y>
##
## The result has the representation of <x>.
##

InstallMethod( Comm,
 "for two UnipotChevElem",
 IsIdenticalObj,
 [ IsUnipotChevElem,
 IsUnipotChevElem ],
 function( x, y )
 return x^-1 * y^-1 * x * y;
 end
);

################################################################################
##
#M Comm( <x>, <y>, "canonical" ) . . . . . . . . . commutator in canonical form
#M . . . . . . . . . . . of two `UnipotChevElem'
##
## Computes CanonicalForm of the Comm
##

InstallOtherMethod( Comm,
 "for two UnipotChevElem and a string",
 IsFamFamX,
 [ IsUnipotChevElem,
 IsUnipotChevElem,
 IsString ],
 function( x, y, canon)
 if canon <> "canonical" then
 Error("3rd argument (if present) must be \"canonical\"");
 fi;
 return CanonicalForm( Comm( x, y ) );
 end
);

################################################################################
##
#M Comm( <x>, <y>, "canonical" ) . . . . . . . . . commutator in canonical form
#M . . . of two root elements (`UnipotChevElem')
##
## This Method calls `Comm( <x>, <y>, "as list" )', which uses a theorem,
## known as Chevalley's commutator formula.
##

InstallOtherMethod( Comm,
 "for two root elements UnipotChevElem and a string",
 IsFamFamX,
 [ IsUnipotChevElem and IsRootElement,
 IsUnipotChevElem and IsRootElement,
 IsString ],
 function( x, y, canon )
 local rep, obj;

 if canon <> "canonical" then
 Error("3rd argument (if present) must be \"canonical\"");
 fi;

 if IsUnipotChevRepByRootNumbers(x) then
 rep := IsUnipotChevRepByRootNumbers;
 elif IsUnipotChevRepByFundamentalCoeffs(x) then
 rep := IsUnipotChevRepByFundamentalCoeffs;
 elif IsUnipotChevRepByRoots(x) then
 rep := IsUnipotChevRepByRoots;
 fi;


 obj := UnipotChevElem(
 FamilyObj(x),
 Comm( rec(r := x!.roots[1], x := x!.felems[1]),
 rec(r := y!.roots[1], x := y!.felems[1]),
 "as list",
 FamilyObj(x) ),
 rep
 );

 # obj has already the canonical form
 SetCanonicalForm( obj, obj );

 return obj;
 end
);

################################################################################
##
#M Comm( <x>, <y>, "as list", <Fam> ) . . . . . . commutator in canonical form
#M . . . . of two root elements (`UnipotChevElem')
##
## This is an `undocumented' function and should not be used at the GAP prompt
##
## This method uses a theorem, known as Chevalley's commutator formula,
## see [Car72], Theorem 5.2.2 (especially Corollar 5.2.3), Pages 76,77
##

InstallOtherMethod( Comm,
 "for two records, a string and a UnipotChevFamily",
 IsFamFamXY,
 [ IsRecord,
 IsRecord,
 IsString,
 IsUnipotChevFamily ],
 function( x, y, str, Fam )
 local comm_roots,
 comm_felems, # will be returned
 roots, # Roots
 in12, in21, # Hilfsvariablen
 add; # Hilfsfunktion

 if str <> "as list" then
 Error("3rd argument must be \"as list\"");
 fi;

 comm_roots := [];
 comm_felems := [];
 roots := PositiveRoots(Fam!.rootsystem);

 add := function(i,j)
 Add(comm_roots,
 Position( roots, j*roots[x.r] + i*roots[y.r] ) );
 Add(comm_felems,
 ChevalleyCommutatorConstant( i, j, y.r, x.r, Fam )
 * (-y.x)^i * (x.x)^j );
 end;

##
#N 1*r + 1*s can appear in a group of any type
#N 2*r + 1*s can appear only in groups of types B_n, C_n, F_4, G_2
#N 3*r + 1*s \ these both con only appear in a group of type G_2
#N 3*r + 2*s / and only together!
#N
#N see [Car72], Lemma 3.6.3
##


 if (roots[y.r] + roots[x.r]) in roots then
 add(1,1);
 if Fam!.type in [ "B", "C", "F" ] then

 if (2*roots[y.r] + roots[x.r]) in roots then
 add(2,1);
 elif (roots[y.r] + 2*roots[x.r]) in roots then
 add(1,2);
 fi;

 elif (Fam!.type = "G") then
 in21 := (2*roots[y.r] + roots[x.r]) in roots;
 in12 := (roots[y.r] + 2*roots[x.r]) in roots;

 if in21 and in12 then
 # which of them is the first inside roots?
 if Position(roots, 2*roots[y.r] + roots[x.r])
 < Position(roots, roots[y.r] + 2*roots[x.r]) then
 add(2,1);
 add(1,2);
 else
 add(1,2);
 add(2,1);
 fi;
 elif in21 then
 add(2,1);
 if (3*roots[y.r] + roots[x.r]) in roots then
 add(3,1);
 add(3,2);
 fi;
 elif in12 then
 add(1,2);
 if (roots[y.r] + 3*roots[x.r]) in roots then
 add(1,3);
 add(2,3);
 fi;
 fi;
 fi;
 fi;
 return rec( roots := comm_roots,
 felems := comm_felems );
 end
);

################################################################################
##
#M IsRootElement( <x> ) . . . . . . . . . is a `UnipotChevElem' a root element?
##
## `IsRootElement' returns `true' if and only if <x> is a <root element>,
## i.e $<x>=x_{r_i}(t)$ for some root $r_i$.
##
## We store this property just after creating objects.
##
#N *Note:* the canonical form of <x> may be a root element even if <x> isn't
#N one.
##

InstallImmediateMethod( IsRootElement,
 "for a UnipotChevElem",
 IsUnipotChevElem,
 0,
 x -> ( Length( x!.roots ) = 1 )
);

################################################################################
##
#M CanonicalForm( <x> ) . . . . . . . . . canonical form of a `UnipotChevElem'
##
## `CanonicalForm' returns the canonical form of <x>.
## For more information on the canonical form see [Car72], Theorem 5.3.3 (ii).
##

InstallMethod( CanonicalForm,
 "for a UnipotChevElem",
 [ IsUnipotChevElem ],
 function( x )
 local i, # used in afor loop
 canonical, # the return value
 computeCanonical, # subroutine
 rep, # here we remember the representation of <x>
 F; # the ring

--> --------------------

--> maximum size reached

--> --------------------

SSL unipot.gi Sprache: unbekannt

[ zur Elbe Produktseite wechseln0.59Quellennavigators Analyse erneut starten ]