Atlas of Lie Groups and Representations

Documentation contents

Script File

coherent_irreducible.at

Source
atlas-scripts/coherent_irreducible.at (532 lines)
Definitions
89
Loads
Loaded by
none of the other all.at files

Definitions in source order

length_sign

L7length_sign (int k,int l) = int

sign

L8sign (Param p,Param q) = int

also defined in basic.at, tits_centralizer.at

W_graph_of

L12W_graph_of (Param p)
W_graph@Param is built-in, returns (int,WGraph)
here is just the W_graph, analogous to block_of@Param

mu 2 overloads

L15mu (WGraph graph,int i,int j) = int
The mu function, obtained from W_graph
L20mu([Param] params,WGraph graph, Param p,Param q) = int
matrix of Hecke algebra operator $T_\alpha$, given by a W-graph, at $q=1$
on the basis of length-parity flipped irreducibles

Note: the Hecke action on W-generators is given by the negated matrices of the
coherent continuation action. Basis change from irreducibles to length-parity
flipped irreducibles restores non-negative off-diagonal entries (same ones as
coherent continuation matrices). but diagonal entries remain opposite.

In practice one should avoid building the full |graph_Hecke_action| sparse
matrix, prefer using |graph_Hecke_action_column|
L23

graph_Hecke_action

L35graph_Hecke_action (WGraph graph,int s) = sparse_mat

also in this file at line 101

graph_Hecke_action_column

L60graph_Hecke_action_column (WGraph graph,int col_number,int s) = sparse_column
single column of matrix of Hecke action of T_s, coming from W-graph, with q=1
Example: big block of SL(2,R)
graph_Hecke_action_column(graph,0,0)=[(0,-1),(2,1)]
graph_Hecke_action_column(graph,1,0)=[(1,-1),(2,1)]
graph_Hecke_action_column(graph,2,0)=[(2,1)]
graph_Hecke_action(graph,0)= (list of these columns) -> matrix

-1  0  0
 0 -1  0
 1  1  1

 see filtrations.pdf
same as previous, except in the basis of irreducibles. Since length difference
is odd across all graph edges, just multiply off-diagonal part by -1
L72

graph_Hecke_irr_action_column

L75graph_Hecke_irr_action_column (WGraph graph,int col_number,int s) = sparse_column

graph_Hecke_irr_action

L89graph_Hecke_irr_action ([Param] params,WGraph graph,int s) = sparse_mat
just as graph_Hecke_action was mainly for testing, this function
isn't essential but is a useful tool

graph_Hecke_action

L101graph_Hecke_action ([sparse_mat] matrices,int col_number,int s) = sparse_column

also in this file at line 35

coherent_irr 7 overloads

L108coherent_irr([Param] block,WGraph graph,Param p,int s) = ParamPol
coherent continuation of irreducibles is defined using the W-graph,
keeping in mind the W-graph is the action in the basis of (-1)^length(p)p
L117coherent_irr ([Param] block,WGraph graph,ParamPol P,int s) = ParamPol
variants: ParamPol P, [int] w, WeylElt w
L119coherent_irr ([Param] block,WGraph graph,Param p,[int] w) = ParamPol
L123coherent_irr ([Param] block,WGraph graph,ParamPol P,[int] w) = ParamPol
L125coherent_irr ([Param] block,WGraph graph,Param p,WeylElt w) = ParamPol
L127coherent_irr ([Param] block,WGraph graph,ParamPol P,[int] w) = ParamPol
L129coherent_irr ([Param] block,WGraph graph,ParamPol P,WeylElt w) = ParamPol

coherent_irr_new 6 overloads

L133coherent_irr_new (Param p,int s) = ParamPol
replace coherent_irr(p,i) with coherent_irr(block_of(p),W_graph_of(p),p,s)
L135coherent_irr_new (ParamPol P,int s) = ParamPol
L137coherent_irr_new (Param p,[int] w) = ParamPol
L139coherent_irr_new (ParamPol P,[int] w) = ParamPol
L141coherent_irr_new (Param p,WeylElt w) = ParamPol
L143coherent_irr_new (ParamPol P,WeylElt w) = ParamPol

Hecke action L147

the action of \tilde T_alpha=v^{-1}(-T_alpha+v^2)
 see filtrations.pdf in Dropbox
\tilde T_alpha(J(delta))=(v+1/v)J + \sum J(delta') + \sum mu(gamma,delta)J(gamma)
L149

tT 5 overloads

L156tT ([Param] params,WGraph graph,Param p,int i ) = hodgeParamLaurentPol
tT stands for \tilde T=v^{-1}(-T+v^2)
action of \tilde T_\alpha in basis of irreducibles
simple root
L170tT ([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i) = hodgeParamLaurentPol
action of \tilde T_\alpha on hodgeParamLaurentPol
L181tT ([Param] params,WGraph graph,hodgeParamPol hpp,int i) = hodgeParamLaurentPol
action of \tilde T_\alpha on hodgeParamPol
L186tT ([Param] params,WGraph graph,hodgeParamLaurentPol hplp,[int] w) = hodgeParamLaurentPol
action Weyl group element [int] on hodgeParamLaurentPol
L191tT ([Param] params,WGraph graph,hodgeParamLaurentPol hplp,WeylElt w) = hodgeParamLaurentPol
action Weyl group element WeylElt on hodgeParamLaurentPol

T 5 overloads

L196T ([Param] params,WGraph graph,Param p,int i) = hodgeParamLaurentPol
get ordinary T_alpha from tT=\tilde T: T=v\tilde T+v^2
L202T([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i) = hodgeParamLaurentPol
get ordinary T_alpha from tT=\tilde T: T=v\tilde T+v^2
acting on hodgeParamLaurentPol
L207T ([Param] params,WGraph graph,hodgeParamPol hpp,int i) = hodgeParamLaurentPol
get ordinary T_alpha from tT=\tilde T: T=v\tilde T+v^2 acting on hodgeParamPol
L212T ([Param] params,WGraph graph,hodgeParamLaurentPol hplp,[int] w) = hodgeParamLaurentPol
get ordinary product of T_alpha's, given by [int]
L217T([Param] params,WGraph graph,hodgeParamPol hpp,WeylElt w) = hodgeParamLaurentPol
get ordinary product of T_alpha's, given by WeylElt

T_inv 2 overloads

L222T_inv ([Param] params,WGraph graph,Param p,int i) = hodgeParamLaurentPol
T^{-1}=v^{-2}T +(v^2-1)
L225T_inv([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i) = hodgeParamLaurentPol

S 7 overloads

L230S([Param] params,WGraph graph,Param p,int i) = hodgeParamLaurentPol
S=-T: S at v=1 is coherent continuation, i.e.
S(b,g,p,i).v_to_1=coherent_irr(p,i)
L231S([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i) = hodgeParamLaurentPol
L232S([Param] params,WGraph graph,hodgeParamPol hpp,int i) = hodgeParamLaurentPol
L234S([Param] params,WGraph graph, hodgeParamLaurentPol hplp,[int] w) = hodgeParamLaurentPol
L237S([Param] params,WGraph graph,Param p,[int] w) = hodgeParamLaurentPol
L240S([Param] params,WGraph graph, hodgeParamLaurentPol hplp,WeylElt w) = hodgeParamLaurentPol
L243S([Param] params,WGraph graph, Param p,WeylElt w) = hodgeParamLaurentPol

S_inv 9 overloads

L247S_inv([Param] params,WGraph graph,Param p,int i) = hodgeParamLaurentPol
S_inv=S^{-1}=(-T)^-1
L248S_inv([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i) = hodgeParamLaurentPol
L249S_inv([Param] params,WGraph graph,hodgeParamPol hpp,int i) = hodgeParamLaurentPol
L251S_inv([Param] params,WGraph graph, hodgeParamLaurentPol hplp,[int] w) = hodgeParamLaurentPol
L254S_inv([Param] params,WGraph graph,Param p,[int] w) = hodgeParamLaurentPol
L257S_inv([Param] params,WGraph graph, hodgeParamPol hpp,[int] w) = hodgeParamLaurentPol
L260S_inv([Param] params,WGraph graph, hodgeParamLaurentPol hplp,WeylElt w) = hodgeParamLaurentPol
L263S_inv([Param] params,WGraph graph, Param p,WeylElt w) = hodgeParamLaurentPol
L266S_inv([Param] params,WGraph graph, hodgeParamPol hpp,WeylElt w) = hodgeParamLaurentPol

graded_standard

L270graded_standard(Param std) = hodgeParamLaurentPol
hodgeParamPol giving grading on standard module

also defined in jantzen.at

reverse

L284reverse(hodgeParamLaurentPol hplp) = ParamPol

also defined in basic.at

quad_test 3 overloads

L286quad_test([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i)
L292quad_test([Param] params,WGraph graph,Param p,int i)
L295quad_test([Param] params,WGraph graph,[Param] list,int i)

cross 8 overloads

L303cross([Param] params,WGraph graph, hodgeParamLaurentPol hplp,int i)
cross(p)=q^{-1/2}(tTp-q^{-1/2}
         =v^{-1}(tTp)-v^{-2}p
L306cross([Param] params,WGraph graph, hodgeParamPol hpp,int i)
L309cross([Param] params,WGraph graph, ParamPol P,int i)
L312cross([Param] params,WGraph graph, Param p,int i)
L315cross([Param] params,WGraph graph,hodgeParamLaurentPol hplp,[int] w)
L318cross([Param] params,WGraph graph,hodgeParamPol hpp,[int] w)
L321cross([Param] params,WGraph graph,ParamPol P,[int] w)
L324cross([Param] params,WGraph graph,Param p,[int] w)

also in this file at line 330; also defined in basic.at

icross

L327icross([Param] params,WGraph graph,hodgeParamLaurentPol hplp,int i)

also in this file at line 339, line 342

cross

L330cross([Param] params,WGraph graph,hodgeParamPol hpp,int i) = hodgeParamLaurentPol

also in this file at line 303, line 306, line 309, line 312, line 315, line 318, line 321, line 324; also defined in basic.at

cross_graded 2 overloads

L333cross_graded([Param] params,WGraph graph,Param p,int i)
L336cross_graded([Param] params,WGraph graph,Param p,[int] w)

icross 2 overloads

L339icross([Param] params,WGraph graph, hodgeParamPol hpp,int i) = hodgeParamLaurentPol
L342icross([Param] params,WGraph graph, Param p,int i)

also in this file at line 327

icross_graded

L345icross_graded([Param] params,WGraph graph, Param p,int i)

cross_square 4 overloads

L348cross_square([Param] params,WGraph graph, hodgeParamLaurentPol hplp,int i)
L351cross_square([Param] params,WGraph graph, hodgeParamPol hpp,int i)
L354cross_square([Param] params,WGraph graph, Param p,int i)
L357cross_square([Param] params,WGraph graph, ParamPol P,int i)

cross_square_test 2 overloads

L360cross_square_test([Param] params,WGraph graph, ParamPol P,int i) = bool
L363cross_square_test([Param] params,WGraph graph, Param p,int i) = bool
moved from induction.at to avoid circularity issue
L366
in singular case,
move to regular infinitesimal character, apply w, and move back
Dangerous Bend (example):

atlas> set G=Sp(6,R)
atlas> set p=parameter(KGB(G,3),[3,2,2],[0,0,0])
Value: zero parameter (x=3,lambda=[3,2,2]/1,nu=[0,0,0]/1)

the root e2-e3 is compact, so this limit of DS is zero
however its coherent continuation is not zero

atlas> coherent_std(0,p)
Value:
-1*final parameter (x=4,lambda=[3,2,2]/1,nu=[0,0,0]/1)
1*final parameter (x=9,lambda=[3,2,2]/1,nu=[1,-1,0]/2)
L368
action of simple root on parameter, basis of standards
L385
need to provide block and graph at regular infinitesimal character
L386
Commented-out code, lines 387–398 (10 lines)
set coherent_irr ([Param] block_reg,WGraph graph_reg,Param p,int s) = ParamPol:
  if is_regular(p) then
    let block_gamma=for q in block_reg do first_param(T_irr(q,p.infinitesimal_character)) od in
    coherent_irr_reg(block_gamma,graph,p,s)
  else
    let gamma=infinitesimal_character(p)
    then p_reg=T(p,gamma+rho(real_form(p))) then
    block_gamma=for q in block_reg do first_param(T_irr(q,p.infinitesimal_character)) od
    in T(coherent_irr_reg(block_gamma,graph,p_reg,s),gamma)
  fi

h_init

L405h_init(RealForm G)
use: set (G,p,b,g,gs,w)=h_init(G)
then
show_long(S_inv(b,g,gs,w)

is_positive

L415is_positive(hodgeParamLaurentPol hplp) = bool

S_inv_plus

L419S_inv_plus([Param] params,WGraph graph, hodgeParamLaurentPol hplp,[int] w)
keep all the intermediate results

h_test

L429h_test(RealForm G)
G should be split

also in this file at line 444

then valid=all(for (,,,x) in rv do x od) in
prints("number of terms: ", #rv,new_line,"result: ",valid);
(rv,valid)
L439

h_test

L444h_test([RealForm] list) = void

also in this file at line 429

list

L446list = [SL(2,R),SL(3,R),SL(4,R),GL(4,R),Sp(4,R), Sp(6,R),Spin(4,3),Spin(5,4),G2_s]

also defined in basic.at

normalized version of S_inv L450

for Stephen Miller
intended for use (only?) with minimal principal series:
 given a parameter p of a minimal principal series, replace p with
 p_new, so that S_inv(params,graph,p_new,w) has the same composition
 factors as p
 Note: S_inv(params,graph,p,w) replaces the M-parameter lambda of p with w\times\lambda,
 so for p_new use: lambda_new=cross(w^{-1},p).lambda
L452
Commented-out code, lines 461–467 (6 lines)
typical usage:
set p=parameter(G.x_open,lambda,nu)  {at regular infinitesimal character}
set b=block_of(p)
set g=W_graph_of(p)
for w=[int] or WeylElt do:
show_long(millers_crossing(b,g,p,w))

millers_crossing 2 overloads

L470millers_crossing([Param] params,WGraph graph, Param p,WeylElt w) = hodgeParamLaurentPol
compute graded composition series of principal series in the w-chamber
L480millers_crossing([Param] params,WGraph graph, Param p,[int] w) = hodgeParamLaurentPol

millers_crossing_sing 2 overloads

L490millers_crossing_sing([Param] params,WGraph graph, Param p,WeylElt w) = hodgeParamLaurentPol
singular infinitesimal character
L497millers_crossing_sing([Param] params,WGraph graph, Param p,[int] w) = hodgeParamLaurentPol
Second version using coherent continuation of irreducibles:
 using W_graph version of coherent_continuation
block: block for G of the induced representation
graph: W_graph of the block
L500

theta_induce_irreducible_wgraph 2 overloads

L506theta_induce_irreducible_wgraph ([Param] block, WGraph graph, Param p, RealForm G) = ParamPol
L519theta_induce_irreducible_wgraph (Param p, RealForm G) = ParamPol
this is slow and probably negates the possible speed advantage of theta_induce_irreducible_wgraph,
but useful for testing

Generated from atlas-scripts at commit 7e1b958 (2026-09-17).