new_conjugacy.at

nc_verbose

test_enumerated_class

enumerate_class

conjugacy class of w -> ([WeylElt] class, [(int,int)] pairs)
class is the list of elements in the conjugacy class of w
pairs[i]=(j,s) means:
 j<i, s=simple root number,
 class[i]=s#class[j]#s
given simple operators, use this to recursively
compute the operators of the class

enumerate_classes

operator 2 overloads

build an operator from a word [int] and list of sparse operators (and dimension)

build a single operator from a WeylElt and list of sparse operators (and dimension)

this will run once for each class, to construct a single operator
for the base point w of the class, using the word for w

also defined in W_reps.at

operators 6 overloads

construct operators for all elements of a conjugacy class, starting with
the base element, and proceeding recursively

use enumerate_class(w) to generate (class,pairs)
note: be careful not to use this in a loop where enumerate_class(w)
 will get run more then necessary

operators for single w, multiple cells, run enumerate_class(w) only once

complete list of operators for all of W in cell, organized
by conjugacy class
set ops=operators(ct,cell)
 ops=[[mat]]
 #ops=#conjugacy classes of W
 #(ops[i])= size of i^th conjugacy class
 ops[i] = [A_1,...,A_n] operators of elements in i^th class

set ops=operators(ct,cells)
ops=[[[mat]]]
#ops = #cells
ops[i]=[[mat]]
ops[i] = [ [A_1,...,A_n], [B_1,...,B_m],...]
ops[i][j]=[mat]=[A_1,...A_n]  n=order of conjugacy class #j
##ops[i] = [mat]: one entry for each element of W
only run enumerate_classes(ct.class_representatives) once

projector_new_plus

returns ([mat] op_sums,mat P)
op_sums: sum of operators over each conjugacy class (without weighting by character)
P= sum_i character_value[i]* op_sums[i]

projectors_new_plus

projector_new

only return the final operator P, which should be a projection up to scalar

projectors_new

test_projector

test: P^2=(constant)*P