2 The GAP Package Unipot

UnipotChevInfo is an InfoClass used in this package. InfoLevel of this InfoClass is set to 1 by default.

2.2 Unipotent subgroups of Chevalley groups

In this section we will describe the functionality for unipotent subgroups provided by this package.

Category for unipotent subgroups.

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 types A to D, n must be a positive integer.

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> U_E3 := UnipotChevSubGr("E", 3, Rationals);
Error <n> must be one of 6, 7, 8 for type E  at
Error( "<n> must be one of 6, 7, 8 for type E " );
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>

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>

Special methods for unipotent subgroups. Return the identity of U.

Size returns the size of a unipotent subgroup. This is a special method for unipotent subgroups.

Size can be computed using the result in Carter Carter72, Theorem 5.3.3 (ii).

This method is similar to the method RootSystem for semisimple Lie algebras (see GAP4.1 Reference Manual, section 58.7 for further information). RootSystem calculates the root system of the unipotent subgroup U. The output is a record with the following components:

-

fundroots A set of fundamental roots

-

posroots The set of positive roots of the root system. The positive roots are listed according to increasing height.

gap> RootSystem(U_G2);
rec( posroots := [ [ 2, -1 ], [ -3, 2 ], [ -1, 1 ], [ 1, 0 ], [ 3, -1 ], [ 0, 1 ] ], 
    fundroots := [ [ 2, -1 ], [ -3, 2 ] ] )
gap>

2.3 Elements of unipotent subgroups of Chevalley groups

In this section we will describe the functionality for unipotent elements provided by this package.

Category for elements of a unipotent subgroup.

IsUnipotChevRepByRootNumbers, IsUnipotChevRepByFundamentalCoeffs and IsUnipotChevRepByRoots are different representations for unipotent elements.

Roots of elements with representation IsUnipotChevRepByRootNumbers are represented by their numbers (positions) in RootSystem(U).posroots.

Roots of elements with representation IsUnipotChevRepByFundamentalCoeffs are represented by coefficients of linear combinations of fundamental roots RootSystem(U).fundroots.

Roots of elements with representation IsUnipotChevRepByRoots are represented by roots themself.

(See UnipotChevElemByRootNumbers, UnipotChevElemByFundamentalCoeffs and UnipotChevElemByRoots for examples)

UnipotChevElemByRootNumbers returns an element of a unipotent subgroup U with representation IsUnipotChevRepByRootNumbers (see IsUnipotChevRepByRootNumbers).

list should be a list of records with components r and x representing the number of the root in RootSystem(U).posroots and a ring element, respectively.

The second variant of UnipotChevElemByRootNumbers is an abbreviation for the first one if list contains only one record.

UnipotChevElemByRN is a synonym for UnipotChevElemByRootNumbers.

gap> IsIdenticalObj( UnipotChevElemByRN, UnipotChevElemByRootNumbers );
true
gap> y := UnipotChevElemByRootNumbers(U_G2, [rec(r:=1, x:=2), rec(r:=5, x:=7)]);
x_{1}( 2 ) * x_{5}( 7 )
gap> x := UnipotChevElemByRootNumbers(U_G2, 1, 2);
x_{1}( 2 )

In this example we create two elements: x_r1( 2 ) ·x_r5( 7 ) and x_r1( 2 ), where r_i, i = 1, ..., 6 are the positive roots in RootSystem(U).posroots and x_ri(t), i = 1, ..., 6 the corresponding root elements.

UnipotChevElemByFundamentalCoeffs returns an element of a unipotent subgroup U with representation IsUnipotChevRepByFundamentalCoeffs (see IsUnipotChevRepByFundamentalCoeffs).

list should be a list of records with components coeffs and x representing a root in RootSystem(U).posroots as coefficients of a linear combination of fundamental roots RootSystem(U).fundroots and a ring element, respectively.

The second variant of UnipotChevElemByFundamentalCoeffs is an abbreviation for the first one if list contains only one record.

UnipotChevElemByFC is a synonym for UnipotChevElemByFundamentalCoeffs.

gap> y1 := UnipotChevElemByFundamentalCoeffs( U_G2,
>      [ rec( coeffs := [ 1, 0 ], x := 2 ),
>        rec( coeffs := [ 3, 1 ], x := 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 ] = 1r₁ + 0r₂ = r₁ and [ 3, 1 ] = 3r₁ + 1r₂=r₅ are the first and the fifth positive roots of RootSystem(U).posroots respectively.

UnipotChevElemByRoots returns an element of a unipotent subgroup U with representation IsUnipotChevRepByRoots (see IsUnipotChevRepByRoots).

list should be a list of records with components r and x representing the root in RootSystem(U).posroots and a ring element, respectively.

The second variant of UnipotChevElemByRoots is an abbreviation for the first one if list contains only one record.

UnipotChevElemByR is a synonym for UnipotChevElemByRoots.

gap> y2 := UnipotChevElemByRoots( U_G2,
>      [ rec( r := [ 2, -1 ], x := 2 ),
>        rec( r := [ 3, -1 ], x := 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 ] = r₁ and [ 3, -1 ] = r₅ are the first and the fifth positive roots of RootSystem(U).posroots respectively.

UnipotChevElemByRootNumbers is provided for converting elements to the representation IsUnipotChevRepByRootNumbers. If x has already the representation IsUnipotChevRepByRootNumbers, then x itself is returned. Otherwise a new element with representation IsUnipotChevRepByRootNumbers is generated.

UnipotChevElemByFundamentalCoeffs and UnipotChevElemByRoots do the same for the representations IsUnipotChevRepByFundamentalCoeffs and IsUnipotChevRepByRoots, respectively.

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!UnipotChevElem), CanonicalForm (see CanonicalForm)), then they are ``converted'' to the new representation, too.

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 F is uniquely expressible in the form

Õ ri Î F+  xri(ti),

where the product is taken over all positive roots in increasing order.

gap> z := UnipotChevElemByFC( U_G2,
>      [ rec( coeffs := [0,1], x := 3 ),
>        rec( coeffs := [1,0], x := 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 ) 

Special methods for unipotent elements. (see GAP Reference Manual, section View and Print for general information on View and Print)

gap> Print(x);
UnipotChevElemByRootNumbers( UnipotChevSubGr( "G", 2, Rationals ), [ rec(
      r := 1,
      x := 2 ) ] )gap> View(x);
x_{1}( 2 )

gap> Print(x1);
UnipotChevElemByFundamentalCoeffs( UnipotChevSubGr( "G", 2, Rationals ),
[ rec(
      coeffs := [ 1, 0 ],
      x := 2 ) ] )gap> View(x1);
x_{[ 1, 0 ]}( 2 )

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)

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.

gap> y := UnipotChevElemByRootNumbers( U_G2, [ rec(
>        r := 1,
>        x := 2 ), rec(
>        r := 5,
>        x := 7 ) ] );
x_{1}( 2 ) * x_{5}( 7 )
gap>
gap> z := UnipotChevElemByRootNumbers( U_G2, [ rec(
>        r := 5,
>        x := 7 ), rec(
>        r := 1,
>        x := 2 ) ] );
x_{5}( 7 ) * x_{1}( 2 )
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>

Special method for unipotent elements. The expressions in the form x_r(t)x_r(u) will be reduced to x_r(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: If both arguments have the same representation, the product will have it too. But if the representations are different, the representation of the first argument will become the representation of the product.

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 )

Special method for unipotent elements. OneOp returns the multiplicative neutral element of x. This is equal to x^0.

Special methods for unipotent elements. We are using the fact

æ è xr1(t1) ¼xrm(tm) ö ø -1   = xrm(-tm) ¼xr1(-t1) .

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 returns true if and only if x is a root element, i.e x =x_r(t) for some root r. We store this property just after creating objects.

Note: the canonical form of x may be a root element even if x isn't one.

[Up] [Previous] [Next] [Index]