class_tables.at

combine

The following method to combine conjugacy class tables of Weyl groups for root
subdata whose simple roots form a mutually orthogonal partition of the simple
roots of |rd| can be given before doing any of the case-by-case stuff.
Explicitly passing |rd| as argument allows the proper renumbering to be
applied when passing to and from the Weyl group of the full root datum.

also defined in generics.at, character_tables_reductive.at, springer_tables_reductive.at

conjugacy_class_S

get an actual WeylElt from a partition <-> conjugacy class in W

for GL(n)

conjugacy_class_A

for other type A root data like SL(n), we need to work a bit harder

cycle_type_GL

The inverse operation, find cycle type of a WeylElt for GL(n). This could be
done using |classic_permutation| and |cycle_type| from combinatorics.at, but
knowing that we have a GL(n) element, we can be a bit more efficient.

unsorted_cycle_type_GL

sometimes we can avoid sorting the cycles into decreasing length order

class_table_S

class_table_A

BC_classes

class_word_BC

word representative in types B and C of conjugacy class for partition pair;
the parts of P correspond to are cycles without flip, those of Q with flip

conjugacy_class_B

for general type B root data, we need to look up and use the diagram order

class_table_B 2 overloads

conjugacy_class_C

for general type C root data, we need to look up and use the diagram order

class_table_C 2 overloads

in class table construction we prefer |BiPartition| over |Signed_cycles|

class_word_D 2 overloads

word representative in types D of unsplit conjugacy class for partition pair

word representative in types D of split conjugacy class for partition pair

class_word

conjugacy_class_SO

conjugacy_class_D

for general type D root data, we need to look up and use the diagram order

class_table_D 2 overloads

G2_class_words

class_table_G 2 overloads

class_signature_F4

orbit sizes on long respectively short roots; these characterise classes

classes_Kondo_F4

list conjugacy classes in Kondo order; non standard ordering of diagram is
allowed: |map| maps Bourbaki indices to corresponding indices in |rd|

class_table_F 2 overloads

class_signature_E6

orbit sizes on roots; these characterise conjugacy classes for W(E6)

class_table_E6

also in this file at line 410, line 419

standard_datum_E6

we shall do storage of the class table for one particular E6 root datum

class_table_E6 2 overloads

voluntarily override previous definition to memoize for |standard_datum_E6|

also in this file at line 388

E7_signature type

set_type E7_signature = (Partition,int)

class_signature_E7

leq_E7_signatures

comparison of root cycle types first, use second component to disambiguate

class_table_E7

Compared to other types, fast construction of a class table for E7 is a bit
more complicated. We prepare a list |sigs_sorted| of class signatures sorted
by |leq_E7_signatures| (so first lexicographically by the root partition type,
then for those pairs where it is necessary by the second component), in which
we can do binary search for the signature of a |WeylElt|. For the table of
powers of classes, we could use this to look up powers of a class
representative, but with a bit of effort we can manage using signatures only.

For classes with an unambiguous root partition type, their powers will
similarly have unambiguous types, so we can use |cycle_power@(partition,int)|
to get the new root partition type and look it up using |binary_lookup_by|. In
the remaining "ambiguous" classes, the even powers are unambiguous (so looking
up the type suffices), while their odd powers are ambiguous, but retain their
relative position (first or second) among the classes with their root
partition type. (Most of the time these odd powers determine the base class
itself, but for the case where the base class has order 6, the third power has
order 2.) So to compute the |k|-th power of a class, we take the partition for
the class, apply |cycle_power| to get the |k|-th power cycle type, and look up
its first occurrence in |sigs_sorted|. The position found will be the value
returned, unless the base class was the second of an ambiguous pair and |k| is
odd, in which case we add 1 to the position. Below we hard-code the positions
6,17,36 of the second elements of ambiguous pairs; being positions in a sorted
list these should never change, but we include as comment code that makes
explicit the condition by which those numbers were singled out.

also in this file at line 508, line 517

standard_datum_E7

we shall do storage of the class table for one particular E6 root datum

class_table_E7 2 overloads

voluntarily override previous definition to memoize for |standard_datum_E6|

also in this file at line 472

class_signature_E8

orbit sizes on roots; these characterise conjugacy classes for W(E8)

class_table_E8

the code below hard-codes some tables, presumably for faster construction of
the E8 class table. We provide equivalent code that will reproduce the data.

also in this file at line 627, line 636

standard_datum_E8

we shall do storage of the class table for one particular E8 root datum

class_table_E8 2 overloads

voluntarily override previous definition to memoize for |standard_datum_E8|

also in this file at line 530

class_table_E

simple_class_table

class_table_simple

construct_class_table

the name of this function highlights that it does considerable work