geck_generic.at

set_generic_degree 2 overloads

has_generic_degree

update_generic_degrees

set generic_degrees(CharacterTable ct,[WCell] cells) = [int]:
   let Wct = ct.class_table in
( ct.n_irreps { size of degree lists being summed }
# for cell in cells
  do assert(Wct.root_datum=cell.root_datum,"Root datum ismatch in cell")
  ;  let cell_char = [int]: ct.decompose(cell_character(Wct,cell))
     then d() = ct.degree(special_irreducible(ct,cell_char))
  in for i:ct.n_irreps
     do if =cell_char[i] then 0 else ct.set_generic_degree(i,d,true) fi
     od
   od
).sum

if only side-effect of |generic_degrees| is desired, have name reflect that

also in this file at line 37, line 40, line 41, line 42

generic_degrees

also in this file at line 46

update_generic_degrees 4 overloads

also in this file at line 30

generic_degrees

also in this file at line 33

show_degrees

gg_verbose

equal_subgroups

find_Levi

conjugacy_classes_reflections_simple

representatives of conjugacy classes of reflections:
one simple reflection of each root length

conjugacy_classes_reflections 2 overloads

1 or 2 for each simple factor

if you have the WeylClassTable this is better:

omega_L

function defined in Geck just before Definition 4.1

default_weight_function

max_standard_Levi_conjugacy_representatives

adapted from standard_Levi_conjugacy_representatives in Levi_subgroups.at

max_Levi_subgroups

lookup_character_table_old

find character table for given G in given list

lookup_character_table

a_prime

to compute a'_E (of Geck), denoted a_prime here, you need to know
all of the functions a_E for proper Levis; this is assumed to
be known by induction

update_one_table_geck

given a list of tables, where tables for proper Levis are found to the right
update a single table, assuming complete tables are known for all proper Levis
use the Geck algorithm for all (unfilled) entries of the specified table

show

also defined in modules.at, K_Nilpotent.at, good_W_representatives.at, arthur_parameters.at, sub_cells.at, associated_variety_annihilator.at, L_packet.at

has_all_generic_degrees

update_one_table_mixed_strategy

given a list of tables, where tables for proper Levis are found to the right
update a single table, assuming complete tables are known for all proper Levis
use cell algorithm up to given size, then Geck

update_generic_degrees_geck_long 2 overloads

update all tables, reading from the right, assuming all the Levis
of table at index j are found at index k>j
modifies the given list of tables, the return value is void

update all tables, reading from the right, assuming all the Levis
of table at index j are found at index k>j
use the cell algorithm up to given cutoff, and then Geck

update_generic_degrees_geck

just return the updated single table

also in this file at line 473

all_levi_tables

this is the precomputation step:
compute the character tables of all Levis
no including generic degrees

all_levi_tables_plus

in this version precompute generic degrees using the
*cell* computation, which (depending on the rank) may be
faster

set_generic_degrees_geck_long

compute character tables of all Levis, then populate
their generic degrees inductively from the right

set_generic_degrees_geck

set_generic_degrees_plus

compute character tables of all Levis
then compute all generic degrees using cell calculation
then use the Geck algorithm for the remaining ones

set_generic_degrees

update_generic_degrees_using_sign 2 overloads

Geck gives a formula (using omega_L) for generic_degree(sigma\otimes
sign) in terms of generic_degree(sigma). This can be used to fill
in some missing values.

set_generic_degrees_2

set_generic_degrees_3

character_table_generic_degrees

Springer_table_generic_degrees

test_geck_generic_degrees

set rec_fun geck_generic_degrees([CharacterTable] tables)=[CharacterTables]:
let table_index=last(for i:#tables do tables[i].generic_degrees[0] = -1 od) in
if table_index=-1 then [tables] else
 let table=tables[index_table] then
  H=table.root_datum then
  for class_index:table.n_classes do
  let a_prime=a_prime(H,tables,table_index,class_index)

  {def of a_prime_E:}
  let  a_prime_E(RootDatum L,CharacterTable ct_L,int index_L)=int:
  let value=
  if gg_verbose then prints("++++++++++++++++++++",new_line,"a_prime_E:",new_line,"L=", L) fi;
  if L.is_abelian then 1 else
   max(
   ##(##for M in  proper_Levi_subgroups(L) do
    let (index_M,P_M)=lookup_character_table(M,tables) then
    ct_M=tables[index_M] in
    for char_M@t in  ct_M.characters do
     let ind=ct_L.decompose(induce_character(M,L,ct_M,ct_L,char_M)) in
     let ()=if gg_verbose then prints("ind: ", ind, "t=",t) fi in
     if ind[index_L]>0 then [a_E(M,ct_M,t)] else [] fi
    od
   od))
  fi
  in if gg_verbose then prints("a_prime_E: ", value) fi;value

  then A=a_prime_E(H,ct_H,index_H),
  B=a_prime_E(H,ct_H,ct_H.tensor_sign_index(index_H)) then
  {()= prints("(1)H=",H,"  A=", A, new_line, "B=", B) then
  ()=prints("(2)H=",H,"   tensor sign: ", ct_H.tensor_sign_index(index_H)) then}
  max=max(A,B- omega_L(ct_H,index_H,default_weight_function@WeylElt))
  in
  if gg_verbose then
   prints("max=", max, " A=",A, " B=", B, new_line,"(4)H=",H,new_line," omega_L=", omega_L(ct_H,index_H,default_weight_function@WeylElt)) fi;
  max



set geck_generic_degree(RootDatum rd, CharacterTable ct,int index_rd)=
let counter=0 in
let rec_fun a_E(RootDatum H,CharacterTable ct_H, int index_H)=int:
 if gg_verbose then prints("-----------------",counter,"---------",new_line,"a_E: H=", H) fi;
 counter:=counter+1;
 if H.is_abelian then if gg_verbose then prints("H is abelian: H=",H) fi;0
 else

  {def of a_prime_E:}
  let  a_prime_E(RootDatum L,CharacterTable ct_L,int index_L)=int:
  let value=
  if gg_verbose then prints("++++++++++++++++++++",new_line,"a_prime_E:",new_line,"L=", L) fi;
  if L.is_abelian then 1 else
   max(
   ##(##for M in  max_Levi_subgroups(L) do
    let ct_M=M.character_table in
    for char_M@t in  ct_M.characters do
     let ind=ct_L.decompose(induce_character(M,L,ct_M,ct_L,char_M)) in
     let ()=if gg_verbose then prints("ind: ", ind, "t=",t) fi in
     if ind[index_L]>0 then [a_E(M,ct_M,t)] else [] fi
    od
   od))
  fi
  in if gg_verbose then prints("a_prime_E: ", value) fi;value
  {end if L.is_abelian}  {this is now the integer value of a_prime_E(...)}
  {end def function a_prime_E}
  then A=a_prime_E(H,ct_H,index_H),
  B=a_prime_E(H,ct_H,ct_H.tensor_sign_index(index_H)) then
  {()= prints("(1)H=",H,"  A=", A, new_line, "B=", B) then
  ()=prints("(2)H=",H,"   tensor sign: ", ct_H.tensor_sign_index(index_H)) then}
  max=max(A,B- omega_L(ct_H,index_H,default_weight_function@WeylElt))
  in
  if gg_verbose then
   prints("max=", max, " A=",A, " B=", B, new_line,"(4)H=",H,new_line," omega_L=", omega_L(ct_H,index_H,default_weight_function@WeylElt)) fi;
  max

 fi {end if H.is_abelian}
 {end def of recursive function a_E}
in
a_E(rd,ct,index_rd)


set geck_generic_degree(RootDatum rd,int i)=int:geck_generic_degree(rd,rd.character_table,i)
set geck_generic_degrees(RootDatum rd,CharacterTable ct)=[int]:
let ()=prints("number of characters: ", ct.n_classes) in
for i:ct.n_classes do
if gg_verbose then prints(new_line,"================================",new_line,"i=",i,new_line) fi;
let g=geck_generic_degree(rd,ct,i)  in
prints("i=",i, " dim=", dimension(ct,i),": g=",g);g od

set geck_generic_degrees(RootDatum rd)=[int]:geck_generic_degrees(rd,rd.character_table)

test_generic_degrees 2 overloads

update_generic_degrees_geck

also in this file at line 283

all_Levi_Springer_tables