This chapter describes the package Unipot. Mainly, the package provides the ability to compute with elements of unipotent subgroups of Chevalley groups, but also some properties of this groups.
In this chapter we will refer to unipotent subgroups of Chevalley groups as ``unipotent subgroups'' and to elements of unipotent subgroups as ``unipotent elements''. Specifically, we only consider unipotent subgroups generated by all positive root elements.
In this section we will describe the general functionality provided by this package.
UnipotChevInfo V
UnipotChevInfo  is an InfoClass used  in this package. InfoLevel of
this InfoClass is set to  1 by default and can be changed to  any level
by SetInfoLevel( UnipotChevInfo, n ).
Following levels are used throughout the package:
In this section we will describe the functionality for unipotent subgroups provided by this package.
IsUnipotChevSubGr( grp ) C
Category for unipotent subgroups.
UnipotChevSubGr( type, n, F ) 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 geq2.
For the type  "D", n must be a positive integer geq4.
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.
gap> U_G2 := UnipotChevSubGr("G", 2, Rationals);
<Unipotent subgroup of a Chevalley group of type G2 over Rationals>
gap> IsUnipotChevSubGr(U_G2);
true
gap> UnipotChevSubGr("E", 3, Rationals);
Error, <n> must be one of 6, 7, 8 for type E  called from
UnipotChevFamily( type, n, F ) called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk>
PrintObj( U ) M
ViewObj( U ) M
Special methods for unipotent  subgroups.  (see  GAP Reference Manual,
section  View  and  Print  for general  information  on View  and
Print)
gap> Print(U_G2); UnipotChevSubGr( "G", 2, Rationals )gap> View(U_G2); <Unipotent subgroup of a Chevalley group of type G2 over Rationals>gap>
One( U ) M
OneOp( U ) M
Special  methods  for unipotent  subgroups. Return the  identity
element   of   the   group  U.   The   returned   element  has
representation UNIPOT_DEFAULT_REP (see UNIPOT_DEFAULT_REP).
Size( U ) M
Size returns  the order  of a unipotent subgroup.  This  is  a
special  method for  unipotent  subgroups  using the  result  in
Carter Carter72, Theorem 5.3.3 (ii).
gap> SetInfoLevel( UnipotChevInfo, 2 );
gap> Size( UnipotChevSubGr("E", 8, GF(7)) );
#I  The order of this group is 7^120 which is
25808621098934927604791781741317238363169114027609954791128059842592785343731\
7437263620645695945672001
gap> SetInfoLevel( UnipotChevInfo, 1 );
RootSystem( U ) M
This  method is similar  to the  method RootSystem  for semisimple  Lie
algebras (see Section Semisimple  Lie Algebras and Root  Systems in
the GAP Reference Manual for further information).
RootSystem returns the underlying root system of the unipotent subgroup
U. The returned object is from the category IsRootSystem:
gap> R_G2 := RootSystem(U_G2); <root system of rank 2> gap> IsRootSystem(last); true gap> SimpleSystem(R_G2); [ [ 2, -1 ], [ -3, 2 ] ] gap>
Additionally to the properties and attributes described in the Reference Manual, following attributes are installed for the Root Systems by the package Unipot:
PositiveRootsFC( R ) A
NegativeRootsFC( R ) A
The list of positive resp. negative roots of the root system R. Every root is represented as a list of coefficients of the linear combination in fundamental roots. E.g. let r=sumi=1l kiri, where r1, ..., rl are the fundamental roots, then r is represented as the list [k1, ..., kl].
gap> U_E6 := UnipotChevSubGr("E",6,GF(2));
<Unipotent subgroup of a Chevalley group of type E6 over GF(2)>
gap> R_E6 := RootSystem(U_E6);
<root system of rank 6>
gap> PositiveRoots(R_E6){[1..6]};
[ [ 2,  0, -1, 0,  0, 0 ], [ 0, 2, 0, -1, 0,  0 ], [ -1, 0, 2, -1,  0, 0 ],
  [ 0, -1, -1, 2, -1, 0 ], [ 0, 0, 0, -1, 2, -1 ], [  0, 0, 0,  0, -1, 2 ] ]
gap> PositiveRootsFC(R_E6){[1..6]};
[ [ 1, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0 ],
  [ 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 1 ] ]
gap>
gap> PositiveRootsFC(R)[Length(PositiveRootsFC(R_E6))]; # the highest root
[ 1, 2, 2, 3, 2, 1 ]
GeneratorsOfGroup( U ) M
This is a special Method for unipotent subgroups of finite Chevalley groups.
Representative( U ) M
This method  returns  an  element  of  the  unipotent  subgroup  U with
indeterminates  instead of ring elements. Such  an element could be  used
for  symbolic  computations (see  Symbolic Computation).  The  returned
element      has       representation      UNIPOT_DEFAULT_REP      (see
UNIPOT_DEFAULT_REP).
gap> Representative(U_G2);
x_{1}( t_1 ) * x_{2}( t_2 ) * x_{3}( t_3 ) * x_{4}( t_4 ) * 
x_{5}( t_5 ) * x_{6}( t_6 )
CentralElement( U ) M
This method returns the representative of the center of U without calculating the center.
In this section we will describe the functionality for unipotent elements provided by this package.
IsUnipotChevElem( elm ) C
Category for elements of a unipotent subgroup.
IsUnipotChevRepByRootNumbers( elm ) R
IsUnipotChevRepByFundamentalCoeffs( elm ) R
IsUnipotChevRepByRoots( elm ) R
IsUnipotChevRepByRootNumbers, IsUnipotChevRepByFundamentalCoeffs  and
IsUnipotChevRepByRoots  are  different  representations  for  unipotent
elements.
Roots of elements with representation IsUnipotChevRepByRootNumbers  are
represented       by       their       numbers       (positions)       in
PositiveRoots(RootSystem(U)).
Roots          of          elements          with          representation
IsUnipotChevRepByFundamentalCoeffs  are  represented  by   elements  of
PositiveRootsFC(RootSystem(U)).
Roots  of   elements  with  representation  IsUnipotChevRepByRoots  are
represented     by     roots     themself,      i.e.      elements     of
PositiveRoots(RootSystem(U)).
(See UnipotChevElemByRootNumbers, UnipotChevElemByFundamentalCoeffs and UnipotChevElemByRoots for examples.)
UNIPOT_DEFAULT_REP V
This variable  contains  the  default representation  for  newly  created
elements, e.g. created by  One or Random. When  Unipot  is loaded,
the  default representation is  IsUnipotChevRepByRootNumbers and can be
changed by assigning a new value to UNIPOT_DEFAULT_REP.
gap> UNIPOT_DEFAULT_REP := IsUnipotChevRepByFundamentalCoeffs;;
Note that Unipot doesn't check the type of this  value, i.e. you may
assign any value to UNIPOT_DEFAULT_REP, which  may  result in errors in
following commands:
gap> UNIPOT_DEFAULT_REP := 3;; gap> One( U_G2 ); ... Error message ...
UnipotChevElemByRootNumbers( U, roots, felems ) O
UnipotChevElemByRootNumbers( U, root, felem ) O
UnipotChevElemByRN( U, roots, felems ) O
UnipotChevElemByRN( U, root, felem ) O
UnipotChevElemByRootNumbers returns  an element of a unipotent subgroup
U    with    representation    IsUnipotChevRepByRootNumbers    (see
IsUnipotChevRepByRootNumbers).
roots should be a list of root numbers, i.e. integers from the range 1,
...,  Length(PositiveRoots(RootSystem(U))). And felems a list  of
corresponding ring elements or indeterminates over that ring  (see GAP
Reference   Manual,   Indeterminate  for  general   information  on
indeterminates  or  section  Symbolic computation  of  this  manual for
examples).
The second  variant of  UnipotChevElemByRootNumbers  is an abbreviation
for the first one if roots and felems contain only one element.
UnipotChevElemByRN is just a synonym for UnipotChevElemByRootNumbers.
gap> IsIdenticalObj( UnipotChevElemByRN, UnipotChevElemByRootNumbers );
true
gap> y := UnipotChevElemByRootNumbers(U_G2, [1,5], [2,7] );
x_{1}( 2 ) * x_{5}( 7 )
gap> x := UnipotChevElemByRootNumbers(U_G2, 1, 2);
x_{1}( 2 )
In this example we create two elements: xr_1( 2 ) . xr_5( 7 ) and
xr_1(  2  ), where ri, i = 1,  ..., 6 are the positive roots in
PositiveRoots(RootSystem(U)) and xr_i(t),  i  = 1, ..., 6  the
corresponding root elements.
UnipotChevElemByFundamentalCoeffs( U, roots, felems ) O
UnipotChevElemByFundamentalCoeffs( U, root, felem ) O
UnipotChevElemByFC( U, roots, felems ) O
UnipotChevElemByFC( U, root, felem ) O
UnipotChevElemByFundamentalCoeffs  returns  an  element  of a unipotent
subgroup  U  with  representation  IsUnipotChevRepByFundamentalCoeffs
(see IsUnipotChevRepByFundamentalCoeffs).
roots      should      be      a     list      of      elements      of
PositiveRootsFC(RootSystem(U)).   And   felems    a    list    of
corresponding ring elements or indeterminates over that ring  (see GAP
Reference   Manual,   Indeterminate  for  general   information  on
indeterminates  or  section  Symbolic computation  of  this  manual for
examples).
The   second   variant  of   UnipotChevElemByFundamentalCoeffs   is  an
abbreviation for  the first one if roots and  felems contain only one
element.
UnipotChevElemByFC       is       just       a        synonym       for
UnipotChevElemByFundamentalCoeffs.
gap> PositiveRootsFC(RootSystem(U_G2));
[ [ 1, 0 ], [ 0, 1 ], [ 1, 1 ], [ 2, 1 ], [ 3, 1 ], [ 3, 2 ] ]
gap> y1 := UnipotChevElemByFundamentalCoeffs( U_G2, [[ 1, 0 ], [ 3, 1 ]], [2,7] );
x_{[ 1, 0 ]}( 2 ) * x_{[ 3, 1 ]}( 7 )
gap> x1 := UnipotChevElemByFundamentalCoeffs( U_G2, [ 1, 0 ], 2 );
x_{[ 1, 0 ]}( 2 )
In   this   example   we   create   the   same   two   elements   as   in
UnipotChevElemByRootNumbers: x[  1, 0 ]( 2  ) . x[ 3, 1 ]( 7  )
and x[ 1, 0 ]( 2 ), where [ 1, 0 ] = 1r1 + 0r2 = r1 and [ 3, 1
]  = 3r1 + 1r2=r5  are  the  first  and the  fifth  positive roots of
PositiveRootsFC(RootSystem(U)) respectively.
UnipotChevElemByRoots( U, roots, felems ) O
UnipotChevElemByRoots( U, root, felem ) O
UnipotChevElemByR( U, roots, felems ) O
UnipotChevElemByR( U, root, felem ) O
UnipotChevElemByRoots returns  an element of  a unipotent  subgroup U
with         representation        IsUnipotChevRepByRoots        (see
IsUnipotChevRepByRoots).
roots   should   be   a    list   of   elements   of    
The second variant of `UnipotChevElemByRootsPositiveRoots(
or  indeterminates  over   that   ring  (see   GAP  Reference  Manual,
"ref:Indeterminate" for general information on indeterminates or  section
"Symbolic computation" of this manual for examples).
 is an abbreviation  for the
first one if roots and felems contain only one element.
UnipotChevElemByR is just a synonym for UnipotChevElemByRoots.
gap> PositiveRoots(RootSystem(U_G2));
[ [ 2, -1 ], [ -3, 2 ], [ -1, 1 ], [ 1, 0 ], [ 3, -1 ], [ 0, 1 ] ]
gap> y2 := UnipotChevElemByRoots( U_G2, [[ 2, -1 ], [ 3, -1 ]], [2,7] );
x_{[ 2, -1 ]}( 2 ) * x_{[ 3, -1 ]}( 7 )
gap> x2 := UnipotChevElemByRoots( U_G2, [ 2, -1 ], 2 );
x_{[ 2, -1 ]}( 2 )
In this example we create again the two elements as in previous examples:
x[ 2, -1 ]( 2 ) . x[ 3, -1 ]( 7 ) and x[ 2, -1 ]( 2 ), where
[ 2, -1 ]  =  r1  and [ 3, -1 ] =  r5 are the  first  and the fifth
positive roots of PositiveRoots(RootSystem( U)) respectively.
UnipotChevElemByRootNumbers( x ) O
UnipotChevElemByFundamentalCoeffs( x ) O
UnipotChevElemByRoots( x ) O
These three methods are provided for converting a unipotent element to the respective representation.
If x has already the required representation, then x itself is returned. Otherwise a new element with the required representation is generated.
gap> x;
x_{1}( 2 )
gap> x1 := UnipotChevElemByFundamentalCoeffs( x );
x_{[ 1, 0 ]}( 2 )
gap> IsIdenticalObj(x, x1); x = x1;
false
true
gap> x2 := UnipotChevElemByFundamentalCoeffs( x1 );;
gap> IsIdenticalObj(x1, x2);
true
Note:  If  some  attributes  of  x  are  known  (e.g  Inverse  (see
Inverse!for     `UnipotChevElem')      or     CanonicalForm      (see
CanonicalForm)), then they are ``converted'' to the new representation,
too.
 UnipotChevElemByRootNumbers( U, list ) O
 UnipotChevElemByRoots( U, list ) O
 UnipotChevElemByFundamentalCoeffs( U, list ) O
DEPRECATED  These   are  old  versions  of  UnipotChevElemByXX  (from
Unipot  1.0   and  1.1).  They  are  deprecated  now  and   exist  for
compatibility only. They may be removed at any time.
CanonicalForm( x ) A
CanonicalForm  returns the  canonical form of x. For more information
on the canonical form  see Carter Carter72, Theorem 5.3.3 (ii). It
says:
Each element of a unipotent subgroup U of a Chevalley group with root system Phi is uniquely expressible in the form
prodr_iinPhi^+ xr_i(ti), where the product is taken over all positive roots in increasing order.
gap> z := UnipotChevElemByFC( U_G2, [[0,1], [1,0]], [3,2]);
x_{[ 0, 1 ]}( 3 ) * x_{[ 1, 0 ]}( 2 )
gap> CanonicalForm(z);
x_{[ 1, 0 ]}( 2 ) * x_{[ 0, 1 ]}( 3 ) * x_{[ 1, 1 ]}( 6 ) *
x_{[ 2, 1 ]}( 12 ) * x_{[ 3, 1 ]}( 24 ) * x_{[ 3, 2 ]}( -72 )
So if we call the positive roots r1,...,r6, we have z = xr_2(3)xr_1(2) = xr_1( 2 ) xr_2( 3 ) xr_3( 6 ) xr_4( 12 ) xr_5( 24 ) xr_6( -72 ).
PrintObj( x ) M
ViewObj( x ) M
Special  methods for  unipotent elements. (see GAP  Reference  Manual,
section  View  and  Print  for  general  information on  View and
Print). The output depends on the representation of x.
gap> Print(x);
UnipotChevElemByRootNumbers( UnipotChevSubGr( "G", 2, Rationals ), \
[ 1 ], [ 2 ] )gap> View(x);
x_{1}( 2 )gap>
gap> Print(x1);
UnipotChevElemByFundamentalCoeffs( UnipotChevSubGr( "G", 2, Rationals ), \
[ [ 1, 0 ] ], [ 2 ] )gap> View(x1);
x_{[ 1, 0 ]}( 2 )gap>
ShallowCopy( x ) M
This is a special method for unipotent elements.
ShallowCopy  creates  a  copy  of  x.  The  returned  object is  not
identical to x but it  is equal to x w.r.t. the  equality operator
=. Note that CanonicalForm and  Inverse  of  x  (if known)  are
identical to CanonicalForm and Inverse of the returned object.
(See GAP Reference Manual, section Duplication of Objects for further information on copyability)
 = y M
Special  method  for unipotent elements. If x and y are identical  or
are  products of  the  same root  elements  then  true  is  returned.
Otherwise CanonicalForm (see CanonicalForm) of both arguments must be
computed (if not already known), which may be expensive. If the canonical
form of one  of  the  elements  must be  calculated  and  InfoLevel  of
UnipotChevInfo is at least 3, the user is notified about this:
gap> y := UnipotChevElemByRN( U_G2, [1,5], [2,7] );
x_{1}( 2 ) * x_{5}( 7 )
gap> z := UnipotChevElemByRN( U_G2, [5,1], [7,2] );
x_{5}( 7 ) * x_{1}( 2 )
gap> SetInfoLevel( UnipotChevInfo, 3 );
gap> y=z;
#I  CanonicalForm for the 1st argument is not known.
#I                    computing it may take a while.
#I  CanonicalForm for the 2nd argument is not known.
#I                    computing it may take a while.
true
gap> SetInfoLevel( UnipotChevInfo, 1 );
 < y M
Special Method for UnipotChevElem
This is needed e.g. by AsSSortetList.
The ordering is computed in the following way: Let x = xr_1(s1) ... xr_n(sn) and y = xr_1(t1) ... xr_n(tn), then
x < y Leftrightarrow [ s1, ..., sn ] < [ t1, ..., tn ],
where the lists are compared lexicographically.
e.g. for x = xr_1(1)xr_2(1) = xr_1(1)xr_2(1)xr_3(0)  (field elems: [ 1, 1, 0 ])
     and y = xr_1(1)xr_3(1) = xr_1(1)xr_2(0)xr_3(1)  (field elems: [ 1, 0, 1 ])
we have y < x (above lists ordered lexicographically).
 * y M
Special method for unipotent elements. The expressions in the form xr(t)xr(u) will be reduced to xr(t+u) whenever possible.
gap> y;z;
x_{1}( 2 ) * x_{5}( 7 )
x_{5}( 7 ) * x_{1}( 2 )
gap> y*z;
x_{1}( 2 ) * x_{5}( 14 ) * x_{1}( 2 )
Note: The representation of the product will be always the representation of the first argument.
gap> x; x1; x=x1;
x_{1}( 2 )
x_{[ 1, 0 ]}( 2 )
true
gap> x * x1;
x_{1}( 4 )
gap> x1 * x;
x_{[ 1, 0 ]}( 4 )
OneOp( x ) M
Special method for unipotent elements. OneOp returns the multiplicative
neutral element of x. This is equal to x^0.
Inverse( x ) M
InverseOp( x ) M
Special methods for unipotent elements. We are using the fact
Bigl( xr_1( t1) . . . xr_m(tm) Bigr)-1 = xr_m(-tm) . . . xr_1(-t1) .
IsOne( x ) M
Special method for unipotent elements. Returns true  if and only if x
is equal to the identity element.
 ^ i M
Integral powers of the unipotent elements are calculated by the default methods installed in GAP. But special (more efficient) methods are instlled for root elements and for the identity.
 ^ y M
Conjugation of two unipotent elements, i.e. xy = y-1xy. The representation of the result will be the representation of x.
Comm( x, y ) M
Comm( x, y, "canonical" ) M
Special methods for unipotent elements.
Comm returns the commutator of x and y, i.e. x  -1 . y-1
.  x  .  y. The  second variant returns  the  canonical form  of the
commutator.  In some cases it may be more efficient  than CanonicalForm(
Comm( x, y ) )
IsRootElement( x ) P
IsRootElement  returns  true  if  and  only  if  x  is a root
element, i.e. x=xr(t) for some root r. We  store this property
immediately after creating objects.
Note: the canonical form of x may be a root element even if x isn't one.
gap> x := UnipotChevElemByRN( U_G2, [1,5,1], [2,7,-2] );
x_{1}( 2 ) * x_{5}( 7 ) * x_{1}( -2 )
gap> IsRootElement(x);
false
gap> CanonicalForm(x); IsRootElement(CanonicalForm(x));
x_{5}( 7 )
true
IsCentral( U, z )
Special method for a unipotent subgroup and a unipotent element.
In some cases, calculation with explicite elements is not enough. Unipot povides a way to do symbolic calculations with unipotent elements for this purpose. This is done by using indeterminates (see GAP Reference Manual, Indeterminates for more information) over the underlying field instead of the field elements.
gap> U_G2 := UnipotChevSubGr("G", 2, Rationals);;
gap> a := Indeterminate( Rationals, "a" );
a
gap> b := Indeterminate( Rationals, "b", [a] );
b
gap> c := Indeterminate( Rationals, "c", [a,b] );
c
gap> x := UnipotChevElemByFC(U_G2, [ [3,1], [1,0], [0,1] ], [a,b,c] );
x_{[ 3, 1 ]}( a ) * x_{[ 1, 0 ]}( b ) * x_{[ 0, 1 ]}( c )
gap> CanonicalForm(x);
x_{[ 1, 0 ]}( b ) * x_{[ 0, 1 ]}( c ) * x_{[ 3, 1 ]}( a ) *
x_{[ 3, 2 ]}( a*c )
gap> CanonicalForm(x^-1);
x_{[ 1, 0 ]}( -b ) * x_{[ 0, 1 ]}( -c ) * x_{[ 1, 1 ]}( b*c ) *
x_{[ 2, 1 ]}( -b^2*c ) * x_{[ 3, 1 ]}( -a+b^3*c ) * x_{[ 3, 2 ]}( b^3*c^2 )
Unipot manual