Atlas of Lie Groups and Representations

Documentation contents

Script File

jantzen.at

I=standard, J'=irreducible
 Q(J',I)=\sum a_i q^i
 a_{(l(I)-l(J')-n)/2}=mult of J' in level n F_n of Jantzen filtration
where I=I_0\supset I_1\supset ...
F_0=I_0/I_1 is unique irreducible quotient
F_i=I^i/I_{i+1}
 =>
 a_m = mult of J' in level (length(I)-length(J')-2m) of the Jantzen filtration

Write multiplicity vector as [b_0,b_1,...,b_{r-1}]
where r=length(I)-length(J') and
where b_i = multiplicity of J' in F_i

So if Q(J',I)=a_0+a_1*q+...+a_kq^k   (k=floor( (l(I)-l(J')-1)/2))
then the multiplicity vector is:

[1]                           if J'=I

[0,a_k,0,a_{k-1},0,...,a_0]   if length(I)-length(J') is odd
[0,0,a_k,0,a_{k-1},0,...,a_0] if length(I)-length(J') is even

Thus [0,a_k,0,a_{k-1},0,...,a_0] means:

multiplicity of J' in F^1 is a_k
multiplicity of J' in F^3 is a_{k-1}
...
multiplicity of J' in F^{1+2r} is a_{k-r}
...
multiplicity of J' in F^{1+2k} is a_0  [note: 1+2k=l(I)-l(J')]

similarly

[0,0,a_k,0,a_{k-1},0,...,a_0] means:

multiplicity of J' in F^2 is a_k
multiplicity of J' in F^4 is a_{k-1}
...
multiplicity of J' in F^{2+2r} is a_{k-r}
...
multiplicity of J' in F^{2+2k} is a_{0}  [note: 2+2k=l(I)-l(J')]
Source
atlas-scripts/jantzen.at (247 lines)
Definitions
12
Loads
Loaded by
none of the other all.at files

Definitions in source order

graded_multiplicity 3 overloads

L53graded_multiplicity ([Param] B,i_poly_mat Q,Param irr, Param std) = i_poly
singular infinitesimal character:
B should be singular_block_of(Param p), so that non-final and non-normal
parameters are discarded
Q should be KL_Q_polynomials(p) which correctly deals with cumulation etc.,
 rather than KL_Q_polynomials(block_of(p)) which gives the wrong size matrix
 or KL_Q_polynomials(singular_block_of(p)) which fails with an error
L63graded_multiplicity ([Param] B,Param irr, Param std) = i_poly
B should be singular_block_of(irr)
L66graded_multiplicity (Param irr, Param std) = i_poly

graded_standard

L70graded_standard(Param std) = hodgeParamPol
\sum Q(gamma,delta)J(gamma)

also defined in coherent_irreducible.at

graded_composition_series 3 overloads

L81graded_composition_series ([Param]B,i_poly_mat Q,Param std) = hodgeParamPol
B should be singular_block_of(std), and Q should be KL_Q_polynomials(std)
similar to graded_standard but include shift by difference in lengths
L90graded_composition_series ([Param] B,Param std) = hodgeParamPol
B should be singular_block_of(std)
L92graded_composition_series (Param std) = hodgeParamPol
Commented-out code, lines 202–247 (43 lines)
set print_graded_composition_series([Param] B,i_poly_mat Q, (Param->i_laurent_poly) shifts, Param std)=void:
let gs=graded_standard(std) then
factors=monomials(gs) then
gcs=graded_composition_series(singular_block_of(std),Q,std) then
factors=std.composition_series.monomials then
i=find(B,std) then
lowest_power=min(for p in factors do lowest_power(shifts(p)) od) then
shift_term=v_laurent_power(max(0,-lowest_power)) then
max_length_diff=length(B~[0])-length(B[0])
   then max_length_vector = max_length_diff+1
in prints("G=", real_form(std));
   prints("graded composition series of standard module:");
   prints(std);
   prints("length=", length(std));
   prints("l=length, ld=length difference, Q=Q(irr,std)");
{   let gcs=graded_composition_series(singular_block_of(std),std)} let ()=1 then
        max_0=max(for (p,) in gcs do #to_string(p) od)
   ,    max_1=max(for (p,) in gcs do #to_string(length(p)) od)
   ,    max_2=max(for (p,) in gcs do #to_string(length(std)-length(p)) od)
   ,    max_3=max(for (p,) in gcs
                  do #to_string(poly_format(KL_Q_polynomial(B,Q,p,std),"q"))
                  od)
in prints(pad("parameter",max_0), "  ",pad("l",max_1),"  "
         ,pad("ld",max_2),"  ", pad("Q",max_3), "  ", pad("f", max_3));
   for (p,m)@j in gcs
   do
   let f=shifts(p)  {laurent polynomial} then
   f_as_poly=laurent_poly_as_poly(shift_term*f) then
{   m=poly_product(Q[j][i],f_as_poly)  then}
   g=KL_Q_polynomial(B,Q,p,std) then
   string_m=string:"" in
      for k:max_length_vector
      do string_m +:=
         if k<=#m-1 and is_even(#m-1-k) then m[k]+" " else ". " fi
      od
   ;  prints(pad(to_string(p),max_0), "  "
            ,pad(to_string(length(p)),max_1),"  "
            ,pad(to_string(length(std)-length(p)),max_2), "  "
            ,pad(poly_format(KL_Q_polynomial(B,Q,p,std),"q"),max_3), "  "
	    ,pad(poly_format(f_as_poly,"q"),max_3)
            , "  [", string_m,"]"
            )
   od

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