Weight Sets

Module for doing computations with the weights of a weight module and action of Weyl group.

class bggcohomology.weight_set.WeightSet(root_system, hot_start=None)[source]

Class to do simple computations with the weights of a weight module.

Parameters:

root_system (str) – String representing the root system (e.g. ‘A2’)

Variables:
  • root_system (str) – String representing the root system (e.g. ‘A2’)
  • W (WeylGroup) – Object encoding the Weyl group.
  • weyl_dic (dict(str, WeylGroup.element_class)) – Dictionary mapping strings representing a Weyl group element as reduced word in simple reflections, to the Weyl group element.
  • reduced_words (list[str]) – Sorted list of all strings representing Weyl group elements as reduced word in simple reflections.
  • simple_roots (list[RootSpace.element_class]) – List of the simple roots
  • rank (int) – Rank of root system
  • rho (RootSpace.element_class) – Half the sum of all positive roots
  • pos_roots (List[RootSpace.element_class]) – List of all the positive roots
  • action_dic (Dict[str, np.array(np.int32, np.int32)]) – dictionary mapping each string representing an element of the Weyl group to a matrix expressing the action on the simple roots.
  • rho_action_dic (Dict[str, np.array(np.int32)]) – dictionary mapping each string representing an element of the Weyl group to a vector representing the image of the dot action on rho.
compute_weights(weights)[source]

Find dot-regular weights and associated dominant weights of a set of weights.

Parameters:weights (iterable(iterable(int))) – Iterable of weights
Returns:list of triples consisting of dot-regular weight, associated dominant, and the length of the Weyl group element making the weight dominant under the dot action.
Return type:list(tuple[tuple(int), tuple(int), int])
dot_action(w, mu)[source]

Compute the dot action of w on mu.

The dot action \(w\cdot\mu = w(\mu+\rho)-\rho\), with \(\rho\) half the sum of all the positive roots.

Parameters:
  • w (str) – string representing the weyl group element
  • mu (iterable(int)) – the weight
Returns:

vector encoding the new weight

Return type:

np.array[np.int32]

dot_orbit(mu)[source]

Compute the orbit of the Weyl group action on a weight.

Parameters:mu (iterable(int)) – A weight
Returns:Dictionary mapping Weyl group elements to weights encoded as numpy vectors.
Return type:dict(str, np.array[np.int32])
classmethod from_bgg(BGG)[source]

Initialize from an instance of BGGComplex.

Some data can be reused, and this gives roughly 3x faster initialization.

Parameters:BGG (BGGComplex) – The BGGComplex to initialize from.
get_action_dic()[source]

Compute weyl group action as well as action on rho.

Returns:
  • Dict[str, np.array(np.int32, np.int32)] (dictionary mapping each string representing an) – element of the Weyl group to a matrix expressing the action on the simple roots.
  • Dict[str, np.array(np.int32)] (dictionary mapping each string representing an) – element of the Weyl group to a vector representing the image of the dot action on rho.
get_vertex_weights(mu)[source]

For a given dot-regular mu, return its orbit under the dot-action.

Parameters:mu (iterable(int)) –
Returns:list of weights
Return type:list[tuple[int]]
highest_weight_rep_dim(mu)[source]

Give dimension of highest weight representation of integral dominant weight.

Parameters:mu (tuple(int)) – A integral dominant weight
Returns:dimension of highest weight representation.
Return type:int
is_dominant(mu)[source]

Use sagemath built-in function to check if weight is dominant.

Parameters:mu (iterable(int)) – the weight
Returns:True if weight is dominant
Return type:bool
is_dot_regular(mu)[source]

Check if mu has a non-trivial stabilizer under the dot action.

Parameters:mu (iterable(int)) – The weight
Returns:True if the weight is dot-regular
Return type:bool
make_dominant(mu)[source]

For a dot-regular weight mu, w such that if w.mu is dominant.

Such a w exists iff mu is dot-regular, in which case it is also unique.
Parameters:mu (iterable(int)) – the dot-regular weight
Returns:
  • tuple(int) – The dominant weight w.mu
  • str – the string representing the Weyl group element w.
tuple_to_weight(t)[source]

Inverse of weight_to_tuple.

Parameters:t (tuple[int]) –
Returns:
Return type:RootSpace.element_class
weight_to_tuple(weight)[source]

Convert element of weight lattice to a sum of simple roots.

Parameters:weight (RootSpace.element_class) –
Returns:tuple representing root as linear combination of simple roots
Return type:tuple[int]