Atlas of Lie Groups and Representations

Documentation contents

Script File

L_packet.at

Source
atlas-scripts/L_packet.at (283 lines)
Definitions
37
Loads
Loaded by
adams_johnson.at

Definitions in source order

block_decompose

L8block_decompose([Param] list) = [([Param],[Param])]
this is a convenient function, should be moved elsewhere
group list of parameters by block;
 returns an array of pairs (B,S) where B is a full block of parameters, and S is the subset
 of B occuring in the input

is_valid

L22is_valid(KGBElt_gen y,ratvec gamma) = bool

also defined in combinatorics.at

parameter

L24parameter(KGBElt x,KGBElt_gen y,ratvec gamma) = Param

also defined in basic.at

y_gen

L26y_gen(Param p) = KGBElt_gen

simple_imaginary_roots

L29simple_imaginary_roots(KGBElt x) = mat

simple_imaginary_reflections

L32simple_imaginary_reflections(KGBElt x) = [WeylElt]

fiber 2 overloads

L35fiber(KGBElt x) = [KGBElt]
L40fiber(RealForm G,mat theta) = [KGBElt]
if G is quasisplit this is guaranteed to work
if not, it will fail with an error if there is no x with x.involution=theta
given G, gamma,y -> defines an L-homomorphism phi: W_R -> LG
L43

L_packet 2 overloads

L48L_packet(RealForm G,ratvec gamma, KGBElt_gen y_gen) = [Param]
We think of an L-packet as a set of *parameters*
these should always be sorted according to the order given by monomials@Param
If we want to specify a set of irreducibles or standards we make this explicit
L57L_packet(Param p) = [Param]
L-packet of parameters, containing p

L_packet_representative

L63L_packet_representative(Param p) = Param
each L-packet has a preferred member: the first one, when sorted by monomials@Param

L_packet_representatives 2 overloads

L66L_packet_representatives([Param] params) = [Param]
L69L_packet_representatives(ParamPol P) = [Param]

L_packet_stable_sum

L72L_packet_stable_sum(Param p) = ParamPol
\sum I(p) where p runs over an L-packet of parameters

L_packets

L77L_packets([Param] params) = [[Param]]
union of L-packets, with multiplicity one, for each parameter occuring
these L-packets can contain parameters NOT in the given [Param]

is_stable_std

L86is_stable_std(ParamPol P) = bool
P is a sum of standards:

is_stable_irr

L94is_stable_irr(ParamPol P) = bool
P is a sum of irreducibles:

is_stable

L98is_stable(ParamPol P) = bool
default: sum of irreducibles
misguided:
L100
Commented-out code, lines 101–109 (9 lines)
set L_packet_representative(ParamPol P)=ParamPol:
let rv=null_module(P.real_form) in
while #P>0 do
 let (c,p)=first_term(P) in
 P+:=-c*p;
  if rv[L_packet_representative(p)] = 0 then
   rv+:=c*p
  fi
 od;rv

stable_sums_std

L117stable_sums_std([Param] list_of_params) = [ParamPol]
[Param] list_of_params is viewed as a set of standard modules,
return a basis of the space of stable virtual characters they span
algorithm: first extract list consisting of one member of each L-packet of parameters
Then for each such p, L_packet_stable_sum(p) is included if and only if all members
 of the L-packet of p occur in list_of_params

stable_sums_std_matrices

L132stable_sums_std_matrices([Param] list)
first break given [Param]:list up into blocks
for each block B the parameters in list_B=list\cap B is a subset of B
return a matrix where each column gives a stable sum of standards in list_B
one such matrix for each block
[([Param],mat)]:
given list \subset new_list (lists of parameters)
and a matrix, whose columns give sums of parameters in the list
return new matrix, same number of columns, but more rows, corresponding
to new_list (which should be a superset of list)
L152
Commented-out code, lines 156–166 (10 lines)
not needed
set change_basis([Param] list,[Param] new_list, mat M)=mat:
let rv=null(#new_list,n_columns(M)) in
for col@col_number in M do
 for i:#col do
  if col[i]!=0 then
   let new_row=find(new_list,list[i]) in
   rv[new_row,col_number]:=col[i] fi
 od
od;rv

irreducibles_as_sums_of_standards

L176irreducibles_as_sums_of_standards([Param] list)
write each irreducible in [Param]:list as a sum of standards
on a given block, these are a subset of the columns of the KL_P_signed_polynomials of the block, evaluated at 1
the given parameters can be a proper subset of the block
if several blocks, break into blocks and do each one for efficiency purposes
returns [(B_i,M_i)] where B_i is a block and M_i is a matrix:
  #rows of M_i = #B_i
  #columns of M_i = number of parameters in list in block B_i
[([Param],mat)]:

stable_sums_irr_in_basis_of_standards_as_matrices

L192stable_sums_irr_in_basis_of_standards_as_matrices([Param] list)
given set of irreducibles, find the stable subspace of their span, expressed in the basis of standards
do this by block
([Param],mat):

stable_sums_irr_in_basis_of_standards

L202stable_sums_irr_in_basis_of_standards([Param] list)
([Param],mat):

stable_sums_irr

L214stable_sums_irr([Param] list)
([Param],mat):

stable_sums_irr_mat

L220stable_sums_irr_mat([Param] list) = ([Param],mat)

show

L230show([Param] list,mat M) = void

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

show_stable_sums_irr

L238show_stable_sums_irr([Param] list) = void

q

L242q(RealForm G) = int

also defined in sommers.at

kottwitz_invariant

L244kottwitz_invariant(RealForm G) = int

kottwitz_sign

L246kottwitz_sign(RealForm G) = int

inner_lift_std

L253inner_lift_std(Param p,RealForm G) = ParamPol
lifting from quasisplit group to inner form
on parameter level: formal, take (x,lambda,nu)
to \sum (x_i,lambda,nu) for G where {x_i} is the fiber
for G over p.x.involution
Note that this ParamPol is stable (a stable sum of standards)

also in this file at line 261, line 274, line 275

David: maybe we should assume that p is the generic one in the packet?
L256

inner_lift_std

L261inner_lift_std(ParamPol P,RealForm G) = ParamPol
assume P is stable for quasisplit form of G
for each standard stable sum \sum p_i (over an L-packet) occuring,
extract a single p_i, and include inner_lift_std(p,G) (which is stable) in the result

also in this file at line 253, line 274, line 275

inner_lift

L271inner_lift(ParamPol P,RealForm G) = ParamPol
P is a sum of irreducibles; it  should be stable, although we don't test for this
inner_lift(P,G):
  P -> cf=character_formula(P)
    -> inner_lift_std(cf)
    -> composition_series($)

also in this file at line 276, line 277

inner_lift_std 2 overloads

L274inner_lift_std(Param p,int i) = ParamPol
L275inner_lift_std(ParamPol P,int i) = ParamPol

also in this file at line 253, line 261

inner_lift 2 overloads

L276inner_lift(Param p,int i) = ParamPol
L277inner_lift(ParamPol P,int i) = ParamPol

also in this file at line 271

p=parameter(p.x,p.y_gen,p.infinitesimal_character) should true
L280

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