This chapter discusses the commands available for computations (in positive characteristic \(p\)) with Weyl modules, quotient Weyl modules, submodules of Weyl modules, and submodules of quotient Weyl modules. Here the underlying Lie algebra is simply-connected and simple.
WARNING. In most cases, the dimension of space of maximal vectors of a given dominant weight is either \(0\) or \(1\). Cases for which there exist two or more independent maximal vectors of the same weight can lead to complications, such as a lack of rigidity in the submodule structure. Such situations are relatively rare (and interesting). An example in Type \(D_4\) is the Weyl module of highest weight \([0,1,0,0]\), as pointed out on page 173 of [CPS75]. (I am grateful to Anton Cox for this reference.)
A Weyl module (as in the previous paragraph) with at least one weight space containing multiple linearly independent maximal vectors is called ambiguous. Extra care is needed when studying ambiguous modules.
Here we consider functions that create Weyl modules, quotients of Weyl modules, submodules of Weyl modules, and submodules of quotient Weyl modules (subquotients).
‣ WeylModule( p, wt, t, r ) | ( operation ) |
‣ WeylModule( V, wt ) | ( operation ) |
Returns: a WeylModule
The first form of the command (with four arguments) constructs a Weyl module of highest weight wt in characteristic p of type t and rank r. The second form of the command (with two arguments) constructs a Weyl module of highest weight wt of the same characteristic and root system as the first parameter V, which must be an existing Weyl module.
gap> V:= WeylModule(2,[1,0],"A",2); V[ 1, 0 ] gap> W:= WeylModule(V,[1,2]); V[ 1, 2 ]
Weyl modules are attribute-storing objects (they remember their attributes after the first time they are computed).
‣ QuotientWeylModule( S ) | ( operation ) |
Returns: a QuotientWeylModule
Constructs the quotient module \(V/S\) corresponding to the given submodule S. Here V is the ambient Weyl module of the given submodule S.
gap> W:= WeylModule(2,[2,0],"A",2); V[ 2, 0 ] gap> Q:= QuotientWeylModule(SocleWeyl(W)); 3-dimensional quotient of V[ 2, 0 ]
Quotient Weyl modules are attribute-storing objects.
‣ SubWeylModule( V, v ) | ( operation ) |
‣ SubWeylModule( S, v ) | ( operation ) |
‣ SubWeylModule( V, list ) | ( operation ) |
‣ SubWeylModule( S, list ) | ( operation ) |
‣ SubWeylModuleDirectSum( V, list ) | ( operation ) |
Returns: a SubWeylModule
Submodules are attribute-storing objects. The first form constructs the submodule of the given Weyl module V generated by the given element v. The second form constructs the submodule (of the ambient Weyl module) generated by the given submodule S and given element v. The third form constructs the submodule of the given Weyl module V generated by the given element list of elements. The fourth form constructs the submodule generated by the given submodule S and given list of elements. The fifth form constructs the submodule of the Weyl module V which is the direct sum of the given list of submodules (which are assumed to be linearly independent, without checking).
gap> W:= WeylModule(2,[2,0],"A",2); V[ 2, 0 ] gap> m:= MaximalVectors(W); [ 1*v0, y1*v0 ] gap> S:= SubWeylModule(W, m[2]); 3-dimensional submod of V[ 2, 0 ] gap> SubWeylModule(S, m[1]); 6-dimensional submod of V[ 2, 0 ] gap> SubWeylModule(W, m); 6-dimensional submod of V[ 2, 0 ] gap> SubWeylModule(S, m); 6-dimensional submod of V[ 2, 0 ]
‣ SubWeylModule( Q, v ) | ( operation ) |
‣ SubWeylModule( S, v ) | ( operation ) |
‣ SubWeylModule( Q, list ) | ( operation ) |
‣ SubWeylModule( S, list ) | ( operation ) |
‣ SubWeylModuleDirectSum( Q, list ) | ( operation ) |
Returns: a SubQuotientWeylModule
Subquotients are attribute-storing objects. The first form constructs the submodule of the given quotient Weyl module Q generated by the given element v. The second form constructs the subquotient Weyl module (of the ambient quotient) generated by the given subquotient S and given element v. The third form constructs the submodule of the given quotient Weyl module Q generated by the given element list of elements. The fourth form constructs the subquotient Weyl module generated by the given subquotient S and given list of elements. The fifth form constructs the submodule of the quotient Weyl module Q which is the direct sum of the given list of subquotients (which are assumed to be linearly independent, without checking).
gap> W:= WeylModule(2,[2,0],"A",2); V[ 2, 0 ] gap> Q:= QuotientWeylModule(SocleWeyl(W)); 3-dimensional quotient of V[ 2, 0 ] gap> m:= MaximalVectors(Q); [ 1*v0 ] gap> S:= SubWeylModule(Q,m[1]); 3-dimensional submod of 3-dimensional quotient of V[ 2, 0 ] gap> SubWeylModule(Q,m); 3-dimensional submod of 3-dimensional quotient of V[ 2, 0 ]
The following filters can be used to query whether or not an object has the indicated type.
‣ IsWeylModule( V ) | ( filter ) |
Returns: true or false
‣ IsQuotientWeylModule( V ) | ( filter ) |
Returns: true or false
‣ IsSubWeylModule( V ) | ( filter ) |
Returns: true or false
‣ IsSubQuotientWeylModule( V ) | ( filter ) |
Returns: true or false
This section documents operations and attributes that can be applied to Weyl modules, quotients, submodules, and subquotients. In the following, V is a Weyl module, Q is a quotient, S is a submodule, and T is a subquotient. Section 2.1 documents the constructors for these objects. Furthermore, wt is a weight.
In all the examples in this section, we take V, S, Q, and T to be as follows.
gap> V:=WeylModule(V,[4,0]); V[ 4, 0 ] gap> Dim(V); 15 gap> m:= MaximalVectors(V); [ 1*v0, y1*v0 ] gap> S:= SubWeylModule(V,m[2]); 9-dimensional submod of V[ 4, 0 ] gap> Q:= QuotientWeylModule(S); 6-dimensional quotient of V[ 4, 0 ] gap> mm:= MaximalVectors(Q); [ 1*v0, y1^(2)*v0 ] gap> T:= SubWeylModule(Q, mm[2]); 3-dimensional submod of 6-dimensional quotient of V[ 4, 0 ]
‣ BasisVecs( Q ) | ( operation ) |
‣ BasisVecs( S ) | ( operation ) |
‣ BasisVecs( T ) | ( operation ) |
‣ BasisVecs( V ) | ( operation ) |
gap> BasisVecs(V); [ 1*v0, y1*v0, y3*v0, y1^(2)*v0, y1*y3*v0, y1^(3)*v0, y3^(2)*v0, y1^(2)*y3*v0, y1^(4)*v0, y1*y3^(2)*v0, y1^(3)*y3*v0, y3^(3)*v0, y1^(2)*y3^(2)*v0, y1*y3^(3)*v0, y3^(4)*v0 ] gap> BasisVecs(S); [ y1*v0, y3*v0, y1*y3*v0, y1^(3)*v0, y1*y3^(2)*v0, y1^(2)*y3*v0, y3^(3)*v0, y1^(3)*y3*v0, y1*y3^(3)*v0 ] gap> BasisVecs(Q); [ 1*v0, y1^(2)*v0, y3^(2)*v0, y1^(4)*v0, y1^(2)*y3^(2)*v0, y3^(4)*v0 ] gap> BasisVecs(T); [ y1^(2)*v0, y3^(2)*v0, y1^(2)*y3^(2)*v0 ]
‣ Character( Q ) | ( attribute ) |
‣ Character( S ) | ( attribute ) |
‣ Character( T ) | ( attribute ) |
‣ Character( V ) | ( attribute ) |
Returns: a list
This function returns the character (as a list of weights and their multiplicities) of the given module.
gap> Character(V); [ [ 4, 0 ], 1, [ 2, 1 ], 1, [ 3, -1 ], 1, [ 0, 2 ], 1, [ 1, 0 ], 1, [ -2, 3 ], 1, [ 2, -2 ], 1, [ -1, 1 ], 1, [ -4, 4 ], 1, [ 0, -1 ], 1, [ -3, 2 ], 1, [ 1, -3 ], 1, [ -2, 0 ], 1, [ -1, -2 ], 1, [ 0, -4 ], 1 ] gap> Character(Q); [ [ 4, 0 ], 1, [ 0, 2 ], 1, [ 2, -2 ], 1, [ -4, 4 ], 1, [ -2, 0 ], 1, [ 0, -4 ], 1 ] gap> Character(S); [ [ 2, 1 ], 1, [ 3, -1 ], 1, [ 1, 0 ], 1, [ -2, 3 ], 1, [ 0, -1 ], 1, [ -1, 1 ], 1, [ 1, -3 ], 1, [ -3, 2 ], 1, [ -1, -2 ], 1 ] gap> Character(T); [ [ 0, 2 ], 1, [ 2, -2 ], 1, [ -2, 0 ], 1 ]
‣ DecompositionNumbers( Q ) | ( attribute ) |
‣ DecompositionNumbers( S ) | ( attribute ) |
‣ DecompositionNumbers( T ) | ( attribute ) |
‣ DecompositionNumbers( V ) | ( attribute ) |
Returns: a list
Returns a list of highest weights of simple composition factors (in the underlying characteristic) and their corresponding multiplicities in the given module.
gap> DecompositionNumbers(V); [ [ 4, 0 ], 1, [ 2, 1 ], 1, [ 0, 2 ], 1 ] gap> DecompositionNumbers(Q); [ [ 4, 0 ], 1, [ 0, 2 ], 1 ] gap> DecompositionNumbers(S); [ [ 2, 1 ], 1 ] gap> DecompositionNumbers(T); [ [ 0, 2 ], 1 ]
‣ Dim( Q ) | ( attribute ) |
‣ Dim( S ) | ( attribute ) |
‣ Dim( T ) | ( attribute ) |
‣ Dim( V ) | ( attribute ) |
Returns: an integer (the dimension of the module)
gap> Dim(V); 15 gap> Dim(Q); 6 gap> Dim(S); 9 gap> Dim(T); 3
‣ DominantWeights( Q ) | ( attribute ) |
‣ DominantWeights( S ) | ( attribute ) |
‣ DominantWeights( T ) | ( attribute ) |
‣ DominantWeights( V ) | ( attribute ) |
Returns: a list
This function lists the dominant weights occurring in the given module (with nonzero multiplicity). The multiplicities are not given.
gap> DominantWeights(V); [ [ 4, 0 ], [ 2, 1 ], [ 0, 2 ], [ 1, 0 ] ] gap> DominantWeights(Q); [ [ 4, 0 ], [ 0, 2 ] ] gap> DominantWeights(S); [ [ 2, 1 ], [ 1, 0 ] ] gap> DominantWeights(T); [ [ 0, 2 ] ]
‣ DominantWeightSpaces( Q ) | ( attribute ) |
‣ DominantWeightSpaces( S ) | ( attribute ) |
‣ DominantWeightSpaces( T ) | ( attribute ) |
‣ DominantWeightSpaces( V ) | ( attribute ) |
Returns: a list
The output of this function is a list consisting of a weight followed by a list of basis vectors for the corresponding weight space.
gap> DominantWeightSpaces(V); [ [ 4, 0 ], [ 1*v0 ], [ 2, 1 ], [ y1*v0 ], [ 0, 2 ], [ y1^(2)*v0 ], [ 1, 0 ], [ y1*y3*v0 ] ] gap> DominantWeightSpaces(Q); [ [ 4, 0 ], [ 1*v0 ], [ 0, 2 ], [ y1^(2)*v0 ] ] gap> DominantWeightSpaces(S); [ [ 2, 1 ], [ y1*v0 ], [ 1, 0 ], [ y1*y3*v0 ] ] gap> DominantWeightSpaces(T); [ [ 0, 2 ], [ y1^(2)*v0 ] ]
‣ Weights( Q ) | ( attribute ) |
‣ Weights( S ) | ( attribute ) |
‣ Weights( T ) | ( attribute ) |
‣ Weights( V ) | ( attribute ) |
Returns: a list
Lists the weights in the given module.
gap> Weights(V); [ [ 4, 0 ], [ 2, 1 ], [ 3, -1 ], [ 0, 2 ], [ 1, 0 ], [ -2, 3 ], [ 2, -2 ], [ -1, 1 ], [ -4, 4 ], [ 0, -1 ], [ -3, 2 ], [ 1, -3 ], [ -2, 0 ], [ -1, -2 ], [ 0, -4 ] ] gap> Weights(Q); [ [ 4, 0 ], [ 0, 2 ], [ 2, -2 ], [ -4, 4 ], [ -2, 0 ], [ 0, -4 ] ] gap> Weights(S); [ [ 2, 1 ], [ 3, -1 ], [ 1, 0 ], [ -2, 3 ], [ 0, -1 ], [ -1, 1 ], [ 1, -3 ], [ -3, 2 ], [ -1, -2 ] ] gap> Weights(T); [ [ 0, 2 ], [ 2, -2 ], [ -2, 0 ] ]
‣ WeightSpaces( Q ) | ( attribute ) |
‣ WeightSpaces( S ) | ( attribute ) |
‣ WeightSpaces( T ) | ( attribute ) |
‣ WeightSpaces( V ) | ( attribute ) |
Returns: a list
Computes a list consisting of weights followed by a basis of their corresponding weight spaces, for each weight of the given module.
gap> WeightSpaces(V); [ [ 4, 0 ], [ 1*v0 ], [ 2, 1 ], [ y1*v0 ], [ 3, -1 ], [ y3*v0 ], [ 0, 2 ], [ y1^(2)*v0 ], [ 1, 0 ], [ y1*y3*v0 ], [ -2, 3 ], [ y1^(3)*v0 ], [ 2, -2 ], [ y3^(2)*v0 ], [ -1, 1 ], [ y1^(2)*y3*v0 ], [ -4, 4 ], [ y1^(4)*v0 ], [ 0, -1 ], [ y1*y3^(2)*v0 ], [ -3, 2 ], [ y1^(3)*y3*v0 ], [ 1, -3 ], [ y3^(3)*v0 ], [ -2, 0 ], [ y1^(2)*y3^(2)*v0 ], [ -1, -2 ], [ y1*y3^(3)*v0 ], [ 0, -4 ], [ y3^(4)*v0 ] ] gap> WeightSpaces(Q); [ [ 4, 0 ], [ 1*v0 ], [ 0, 2 ], [ y1^(2)*v0 ], [ 2, -2 ], [ y3^(2)*v0 ], [ -4, 4 ], [ y1^(4)*v0 ], [ -2, 0 ], [ y1^(2)*y3^(2)*v0 ], [ 0, -4 ], [ y3^(4)*v0 ] ] gap> WeightSpaces(S); [ [ 2, 1 ], [ y1*v0 ], [ 3, -1 ], [ y3*v0 ], [ 1, 0 ], [ y1*y3*v0 ], [ -2, 3 ], [ y1^(3)*v0 ], [ 0, -1 ], [ y1*y3^(2)*v0 ], [ -1, 1 ], [ y1^(2)*y3*v0 ], [ 1, -3 ], [ y3^(3)*v0 ], [ -3, 2 ], [ y1^(3)*y3*v0 ], [ -1, -2 ], [ y1*y3^(3)*v0 ] ] gap> WeightSpaces(T); [ [ 0, 2 ], [ y1^(2)*v0 ], [ 2, -2 ], [ y3^(2)*v0 ], [ -2, 0 ], [ y1^(2)*y3^(2)*v0 ] ]
‣ WeightSpace( Q, wt ) | ( operation ) |
‣ WeightSpace( S, wt ) | ( operation ) |
‣ WeightSpace( T, wt ) | ( operation ) |
‣ WeightSpace( V, wt ) | ( operation ) |
Returns: a list
Gives a basis for the weight space of the given weight wt.
gap> WeightSpace(V, [2,1]); [ y1*v0 ] gap> WeightSpace(Q, [2,1]); [ ] gap> WeightSpace(S, [2,1]); [ y1*v0 ] gap> WeightSpace(T, [2,-2]); [ y3^(2)*v0 ]
‣ TheCharacteristic( Q ) | ( operation ) |
‣ TheCharacteristic( S ) | ( operation ) |
‣ TheCharacteristic( T ) | ( operation ) |
‣ TheCharacteristic( V ) | ( operation ) |
Returns: an integer
Gives the characteristic of the base field.
gap> TheCharacteristic(V); 2 gap> TheCharacteristic(Q); 2 gap> TheCharacteristic(S); 2 gap> TheCharacteristic(T); 2
‣ TheLieAlgebra( Q ) | ( attribute ) |
‣ TheLieAlgebra( S ) | ( attribute ) |
‣ TheLieAlgebra( T ) | ( attribute ) |
‣ TheLieAlgebra( V ) | ( attribute ) |
Returns: a Lie algebra
Gives the underlying Lie algebra for the given module.
gap> TheLieAlgebra(V); <Lie algebra of dimension 8 over Rationals> gap> TheLieAlgebra(Q); <Lie algebra of dimension 8 over Rationals> gap> TheLieAlgebra(S); <Lie algebra of dimension 8 over Rationals> gap> TheLieAlgebra(T); <Lie algebra of dimension 8 over Rationals>
The GAP manual gives additional operations for various properties and attributes of such Lie algebras and their enveloping algebras.
In the following, Q is a quotient Weyl module, S is a submodule, and V is a Weyl module.
‣ MaximalVectors( Q, wt ) | ( operation ) |
‣ MaximalVectors( Q ) | ( attribute ) |
‣ MaximalVectors( S, wt ) | ( operation ) |
‣ MaximalVectors( S ) | ( attribute ) |
‣ MaximalVectors( V, wt ) | ( operation ) |
‣ MaximalVectors( V ) | ( attribute ) |
Returns: a list
Returns a list of linearly independent maximal vectors for the given dominant weight wt or for all dominant weights of the module. The maximal vectors of a particular weight form a basis of the space of maximal vectors of that weight.
In the following example, we assume that V, Q, and S are the same modules as defined in the example at the beginning of Section 2.3.
gap> MaximalVectors(V); [ 1*v0, y1*v0 ] gap> m:= MaximalVectors(V); [ 1*v0, y1*v0 ] gap> List(m, Weight); [ [ 4, 0 ], [ 2, 1 ] ] gap> MaximalVectors(V, [2,1]); [ y1*v0 ] gap> m:= MaximalVectors(Q); [ 1*v0, y1^(2)*v0 ] gap> List(m, Weight); [ [ 4, 0 ], [ 0, 2 ] ] gap> MaximalVectors(Q, [0,2]); [ y1^(2)*v0 ] gap> m:= MaximalVectors(S); [ y1*v0 ] gap> List(m, Weight); [ [ 2, 1 ] ] gap> MaximalVectors(S, [2,1]); [ y1*v0 ]
‣ IsAmbiguous( Q ) | ( attribute ) |
‣ IsAmbiguous( S ) | ( attribute ) |
‣ IsAmbiguous( V ) | ( attribute ) |
Returns: true or false
The module is ambiguous if it has two or more linearly independent maximal vectors of the same weight.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> IsAmbiguous(V); true
‣ AmbiguousMaxVecs( Q ) | ( attribute ) |
‣ AmbiguousMaxVecs( S ) | ( attribute ) |
‣ AmbiguousMaxVecs( V ) | ( attribute ) |
Returns: a list
This function lists a basis for the subspace of ambiguous maximal vectors.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> AmbiguousMaxVecs(V); [ y1*y3*v0, y4*v0 ]
In the following, Q is a quotient Weyl module and V is a Weyl module.
‣ ActOn( Q, u, v ) | ( operation ) |
‣ ActOn( V, u, v ) | ( operation ) |
Returns: An element of the Weyl module or quotient
This function returns the result of acting by the hyperalgebra element u on the given vector v. Here v must be an element of the given Weyl module V or quotient Weyl module Q. The command LatticeGeneratorsInUEA is a pre-existing GAP command; see the chapter on Lie algebras in the GAP reference manual for further details. The lattice generators are regarded as standard generators of the hyperalgebra for computing the action.
gap> V:= WeylModule(2, [1,0], "G", 2); V[ 1, 0 ] gap> L:= TheLieAlgebra(V); <Lie algebra of dimension 14 over Rationals> gap> g:= LatticeGeneratorsInUEA(L); [ y1, y2, y3, y4, y5, y6, x1, x2, x3, x4, x5, x6, ( h13/1 ), ( h14/1 ) ] gap> b:= BasisVecs(V); [ 1*v0, y1*v0, y3*v0, y4*v0, y5*v0, y6*v0, y1*y6*v0 ] gap> ActOn(V, g[1]^2 + g[7], b[1]); 0*v0 gap> ActOn(V, g[1]*g[6], b[1]); y1*y6*v0
‣ Generator( Q ) | ( operation ) |
‣ Generator( V ) | ( operation ) |
Returns: a highest weight vector
This returns a generating vector of the given module.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> Generator(V); 1*v0
‣ GensSocleLayers( Q ) | ( attribute ) |
‣ GensSocleLayers( V ) | ( attribute ) |
Returns: a list
Returns a list of lists, such that the \(i\)th list gives a list of generators of the \(i\)th module in the socle series of the input.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> GensSocleLayers(V); [ [ y1*y4*v0, y1*y3*y4*v0+y1*y6*v0+y3*y5*v0, y1*y4*y6*v0+y3*y4*y5*v0+y4^(3)*v0 ], [ y4*v0, y1^(2)*y3*y6*v0 ], [ y1*y3*v0 ], [ y5*y6*v0 ], [ y1*y6*v0+y4^(2)*v0 ], [ 1*v0 ] ]
‣ PrintSocleLayers( Q ) | ( operation ) |
‣ PrintSocleLayers( V ) | ( operation ) |
Returns: nothing
Prints the weights of the generators of the socle layers corresponding to the output of the previous command. These are the highest weights of the simple composition factors in each socle layer.
In the following example, we assume that V is the same Weyl module defined in the preceding example.
gap> PrintSocleLayers(V); Printing highest weights of simples in socle layers of V[ 3, 0 ] Layer 1: [ [ 0, 1 ], [ 1, 0 ], [ 0, 0 ] ] Layer 2: [ [ 2, 0 ], [ 0, 0 ] ] Layer 3: [ [ 2, 0 ] ] Layer 4: [ [ 0, 0 ] ] Layer 5: [ [ 1, 0 ] ] Layer 6: [ [ 3, 0 ] ]
‣ SocleSeries( Q ) | ( attribute ) |
‣ SocleSeries( V ) | ( attribute ) |
Returns: a list
Returns the socle series of its input module, as a list of submodules.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> SocleSeries(V); [ 21-dimensional submod of V[ 3, 0 ], 28-dimensional submod of V[ 3, 0 ], 34-dimensional submod of V[ 3, 0 ], 35-dimensional submod of V[ 3, 0 ], 41-dimensional submod of V[ 3, 0 ], 77-dimensional submod of V[ 3, 0 ] ]
‣ SocleWeyl( V ) | ( attribute ) |
‣ SocleWeyl( Q ) | ( attribute ) |
Returns: a submodule
This function returns the socle of the given module.
gap> V:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> SocleWeyl(V); 21-dimensional submod of V[ 3, 0 ]
This section documents additional operations that can be applied to an existing Weyl module V.
‣ MaximalSubmodule( V ) | ( attribute ) |
Returns: a submodule
Calculates and returns the unique maximal submodule of the given Weyl module V.
gap> V:= WeylModule(3,[3,0],"A",2); V[ 3, 0 ] gap> MaximalSubmodule(V); 7-dimensional submod of V[ 3, 0 ]
‣ SimpleQuotient( V ) | ( attribute ) |
Returns: a quotient Weyl module
Calculates and returns the simple quotient by the unique maximal submodule of the given Weyl module.
gap> V:= WeylModule(3,[3,0],"A",2); V[ 3, 0 ] gap> Q:= SimpleQuotient(V); 3-dimensional quotient of V[ 3, 0 ]
In the following, Q is a quotient Weyl module.
‣ AmbientWeylModule( Q ) | ( operation ) |
Returns: a Weyl module
This returns the ambient Weyl module V corresponding to the given quotient Q.
In the following example, we assume that Q is the same as the quotient module defined in the preceding example.
gap> AmbientWeylModule(Q); V[ 3, 0 ]
‣ DefiningKernel( Q ) | ( operation ) |
Returns: a submodule
This returns the kernel corresponding to the given quotient Q. In other words, it returns the submodule S such that \(Q\) is isomorphic to \(V/S\), where V is the ambient Weyl module.
In the following example, we assume that Q is the same as the quotient module in the preceding example.
gap> DefiningKernel(Q); 7-dimensional submod of V[ 3, 0 ]
In the following, S is a submodule.
‣ AmbientWeylModule( S ) | ( operation ) |
Returns: a Weyl module
This function returns the ambient Weyl module containing the given submodule S.
gap> V:= WeylModule(3,[3,0],"A",2); V[ 3, 0 ] gap> S:= MaximalSubmodule(V); 7-dimensional submod of V[ 3, 0 ] gap> AmbientWeylModule(S); V[ 3, 0 ]
‣ Generators( S ) | ( operation ) |
Returns: a list
Returns a list of generators of the given submodule S. In the following example, we assume that S is the same as in the preceding example.
gap> Generators(S); [ y1*v0 ]
‣ IsWithin( S, v ) | ( operation ) |
Returns: true or false
This function returns true if and only if the given vector v lies in the given submodule S.
gap> V:= WeylModule(3,[3,0],"A",2); V[ 3, 0 ] gap> S:= MaximalSubmodule(V); 7-dimensional submod of V[ 3, 0 ] gap> g:= Generators(S); [ y1*v0 ] gap> IsWithin(S, g[1]); true
‣ NextSocle( S ) | ( operation ) |
Returns: a SubWeylModule
This function returns the maximal submodule T containing the given submodule S such that \(T/S\) is semisimple. If S happens to be an element of the socle series then the function returns the next element in the socle series.
gap> W:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> g:= Generators(SocleWeyl(W)); [ y1*y4*v0, y1*y3*y4*v0+y1*y6*v0+y3*y5*v0, y1*y4*y6*v0+y3*y4*y5*v0+y4^(3)*v0 ] gap> S:= SubWeylModule(W, g[1]); 14-dimensional submod of V[ 3, 0 ] gap> T:= NextSocle(S); 21-dimensional submod of V[ 3, 0 ] gap> DecompositionNumbers(T); [ [ 0, 1 ], 1, [ 1, 0 ], 1, [ 0, 0 ], 1 ]
In the above example, S is a simple submodule of the socle, and NextSocle(S) computes an extension of it by two simples.
‣ GensNextSocle( S ) | ( operation ) |
Returns: a list
This function returns a list of generators of the submodule returned by NextSocle(S). In the example below, S is the submodule constructed in the preceding example.
gap> g:= GensNextSocle(S); [ y1*y6*v0+y3*y5*v0, y4^(3)*v0 ] gap> List(g, Weight); [ [ 1, 0 ], [ 0, 0 ] ]
‣ SocleLengthTwoQuotient( S ) | ( attribute ) |
Returns: a QuotientWeylModule
This function returns a quotient of the ambient Weyl module V with socle series length at most two such that S lies in its defining kernel.
gap> W:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> ss:= SocleSeries(W); [ 21-dimensional submod of V[ 3, 0 ], 28-dimensional submod of V[ 3, 0 ], 34-dimensional submod of V[ 3, 0 ], 35-dimensional submod of V[ 3, 0 ], 41-dimensional submod of V[ 3, 0 ], 77-dimensional submod of V[ 3, 0 ] ] gap> amv:= AmbiguousMaxVecs(W); [ y1*y3*v0, y4*v0 ] gap> Q1:= SocleLengthTwoQuotient(ss[4]); 42-dimensional quotient of V[ 3, 0 ] gap> PrintSocleLayers(Q1); Printing highest weights of simples in socle layers of 42-dimensional quotient of V[ 3, 0 ] Layer 1: [ [ 1, 0 ] ] Layer 2: [ [ 3, 0 ] ] gap> Q2:= SocleLengthTwoQuotient(SubWeylModule(W,amv[1]+amv[2])); 48-dimensional quotient of V[ 3, 0 ] gap> PrintSocleLayers(Q2); Printing highest weights of simples in socle layers of 48-dimensional quotient of V[ 3, 0 ] Layer 1: [ [ 2, 0 ], [ 1, 0 ] ] Layer 2: [ [ 3, 0 ] ]
Here we see an example of an ambiguous Weyl module with different quotients of socle length two.
‣ TwoFactorQuotientsContaining( S ) | ( attribute ) |
Returns: a list of QuotientWeylModules
This returns a list of quotients of the ambient Weyl module, each having exactly two composition factors, each of which contain S in their defining kernel. Such quotients realize non-split extensions of the simple top composition factor of V. NOTE. Even when S is the trivial module, we do not claim that the output will give all of the extensions.
In the following example, we assume that W, amv are as defined in the preceding example.
gap> Q:= TwoFactorQuotientsContaining(SubWeylModule(W,amv[1]+amv[2])); [ 42-dimensional quotient of V[ 3, 0 ], 42-dimensional quotient of V[ 3, 0 ] ] gap> PrintSocleLayers(Q[1]); Printing highest weights of simples in socle layers of 42-dimensional quotient of V[ 3, 0 ] Layer 1: [ [ 1, 0 ] ] Layer 2: [ [ 3, 0 ] ] gap> PrintSocleLayers(Q[2]); Printing highest weights of simples in socle layers of 42-dimensional quotient of V[ 3, 0 ] Layer 1: [ [ 2, 0 ] ] Layer 2: [ [ 3, 0 ] ]
Here we see that the ambient Weyl module has at least two non-isomorphic extensions realized in its second radical. Comparing with information from an earlier example (see PrintSocleLayers (2.5-4)) reveals that the Weyl module in question is non-rigid (its socle and radical series do not coincide).
In the following, T is a subquotient.
‣ AmbientQuotient( T ) | ( operation ) |
Returns: a QuotientWeylModule
This function returns the ambient quotient Weyl module containing the given subquotient T.
gap> W:= WeylModule(2,[3,0],"G",2); V[ 3, 0 ] gap> m:= AmbiguousMaxVecs(W); List(m, Weight); [ y1*y3*v0, y4*v0 ] [ [ 2, 0 ], [ 2, 0 ] ] gap> Q:= QuotientWeylModule(SubWeylModule(W,m[1])); 64-dimensional quotient of V[ 3, 0 ] gap> subQ:= SubWeylModule(Q, m[2]); 21-dimensional submod of 64-dimensional quotient of V[ 3, 0 ] gap> AmbientQuotient(subQ); 64-dimensional quotient of V[ 3, 0 ]
‣ Generators( T ) | ( operation ) |
Returns: a list
This returns a list of generators for the given subquotient T. In the next example, we assume that subQ is the subquotient constructed in the example for the AmbientQuotient (2.9-1) command, documented above.
gap> Generators(subQ); [ y4*v0 ]
‣ IsWithin( T, v ) | ( operation ) |
Returns: true or false
This returns true if and only if the image of the given vector v (under the quotient map from the ambient Weyl module to the ambient quotient) lies in the given subquotient T. In the next example, we assume that subQ, Q, and m are as defined in the example for AmbientQuotient (2.9-1) above.
gap> IsWithin(subQ,m[2]); true gap> IsWithin(subQ, Generator(Q)); false
‣ NextSocle( T ) | ( operation ) |
Returns: a SubQuotientWeylModule
This function returns the maximal subquotient T containing the given subquotient S such that \(T/S\) is semisimple. If S happens to be an element of the socle series then the function returns the next element in the socle series.
In the next example, we assume that subQ is the subquotient constructed in the example for the AmbientQuotient (2.9-1) command, documented above.
gap> DecompositionNumbers(subQ); [ [ 2, 0 ], 1, [ 0, 1 ], 1, [ 0, 0 ], 1 ] gap> N:= NextSocle(subQ); 22-dimensional submod of 64-dimensional quotient of V[ 3, 0 ] gap> DecompositionNumbers(N); [ [ 2, 0 ], 1, [ 0, 1 ], 1, [ 0, 0 ], 2 ]
generated by GAPDoc2HTML