Atlas of Lie Groups and Representations

Documentation contents

atlas Library · Script File

K_highest_weights.at

Source
atlas-scripts/K_highest_weights.at (738 lines)
Definitions
68
Loads
Loaded by
print_K_types.at finite_dimensional_signature.at dirac_index.at geck_generic.at K_norm.at coherent_characters.at K_types.at hodgeParamPol.at disconnected.at tensor_product.at K_types_plus.at aql.at

Definitions in source order

LKT_verbose

L57LKT_verbose = false
! Functions involving K-types (final tempered limit parameters) and
   K-highest weights.
   The main reference is Vogan, "Branching to a Maximal Compact Subgroup"
     [KHatHowe].
   See also the notes on "K-types in atlas" in the Dropbox.

   The main functions are:

1) highest_weights: Given a K_type tau=(x,lambda), find all K-highest weights
   corresponding to the K_#-types in the restriction of tau.

(x,lambda) -> {(,x_K,mu)} multivalued; find one value (,x_K,mu), then
   take the R(K)-orbit <-> |R(K)/R(K,mu)| K-highest weights. Here R(K,mu) is
   the stabilizer of mu in the R-group R(K) of K.

Algorithm:

i) If G is relatively split, Cartan is (relatively) split, all roots in the
   tau-invariant, this is the "G-spherical" case of KHatHowe, Section 8.

ii) If p is final standard limit tempered, it has a unique LKT,
    use theta_stable_data (see induction.at) to write p as cohomologically
    induced from a relatively split L.

iii.) Apply ii) to all terms of finalize(p.at_nu_0).


2) K_types: Given a KHighestWeight mu=(,x,kappa), find all K_types containing
   the corresponding K_#-type.

   (,x_K,mu) -> {tau=(x,lambda)} multivalued; find $\theta$-stable data
   (Q=LU,p_L=(x_L,lambda_L,0)) for one K-type tau first, then
   compute all (L-spherical) $(L\cap K)$-types p_L'=(x_L,lambda_L')
   with the same infinitesimal character. There will be
   |R(K,mu)| of them.

Algorithm:

   This is the Vogan algorithm, version in [KHatHowe] Section 13, a
   slight modification of Vogan's Big Green Book Prop. 5.3.3.

   Given (,x_K,mu), compute mu+2rho_K(x_K), choose positive chamber for G,
   -> mu_0=mu+2rho_K(x_K)-rho; project on the given dominant Weyl chamber -> xi;
   then the simple roots contributing to difference between xi and
   mu_0 determine the $\theta$-stable parabolic Q=LU that is
   part of the $\theta$-stable data for tau=(x,lambda). The parameter for
   (relatively split) L is obtained from xi by a $\rho$-shift.
!
see K.at: K-types as final tempered limit parameters
(x,lambda) <-> representations of K
K_highest_weights.at: KHighestWeights (,x,mu) <-> representations of K_#
L58
KHighestWeight: mu    K_types tau
see KHatHowe Section 4, especially Theorem 4.10
notation:
  KHatHowe   Atlas
    T_{f0}    T_K0
    T_f       T_K=H^\delta
    T_fl      T_{K,large}

 R(K)=|K/K_#|=|T_{K,large}/T_K|

 given mu a character of T_K

 T_K \subset T_K(\mu) \subset T_{K,large}
 |-----a-------|--------b-------|
 ab=|R(K)|
 a=|R(K,mu)|,  b=|R(K)/R(K,mu)|
 software: R(K)=R_K_dom(x)
           R(K,mu)=R_K_dom(mu)

 {mu_i|i=1,...,b} characters of T_K  <->
   {\tilde\mu_j|j=1,...,a} irreps of T_{K,large}

 {mu_i}= orbit of R(K) acting acting on mu=mu_1, stabilizer is R(K,mu)
 {\tilde\mu_j|j=1,...,a} irreducible representations of T_{K,large}

 mu_i -> Ind_{T_K}^{T_{K,large}})(mu_i)= \sum_{j=1}^a \tilde\mu_j
 \tilde\mu_j -> Res^{T_{K,large}}_{T_K}(\tilde\mu_j)=\sum_{i=1}^a\mu_i

 mu_i -> a choices of extension to T_K(mu_i)
   -> induce irreducibly to T_{K,large}
   each mu_i (i=1,...,a) -> same set of \tilde\mu_j (j=1,...,b)
 dim(\tilde\mu_j)=|R(K)/R(K,mu)|
 mu_i -> tau(mu_i) irreducible of K_#,
    dimension given by Weyl dimension formula
 \tilde\mu_j -> \tau(\tilde\mu_j) irreducible of K
 dim(\tau(\tilde\mu_j))=dim(\tau(\mu_j))*b=dim(\tau(\mu_j))|R(K)/R(K,mu_j)|
   (See Theorem 4.10(1))
L62

=

L103= (KHighestWeight khw0, KHighestWeight khw1) = bool
Equality of KHighestWeights; (,x,mu)=(,x',mu') iff x=x', and mu and mu'
differ by (1-theta)X^* or compact Weyl group action.

also defined in basic.at, combinatorics.at, modules.at, parabolics.at, synthetic.at, hash.at, tits.at, nilpotent_orbits.at, cyclotomic.at, polynomial.at, W_reps_type_BC.at, hodgeParamLaurentPol.at, hodgeParamPol.at, laurentPolynomial.at, extended.at, disconnected.at, cyclotomic_Lie_algebra.at, cyclotomicMat.at, bracket.at

LKTs 2 overloads

L127LKTs (KType t) = [KType]
List of LKTs (as final tempered limit parameters) of a module given by a
parameter.
L129LKTs (Param p) = [KType]

LKT 2 overloads

L131LKT (KType t) = KType
L134LKT (Param p) = KType

From the earlier documentation

LKT of module given by a parameter, if it is unique (otherwise error message)

final

L137final = LKT@KType
Replace a K-type mu by its (supposed) unique final K-type

map from K_types to KHighestWeights L140

is_split_spherical 2 overloads

L145is_split_spherical (KType t) = bool
Test if parameter p for G is G-spherical: G must be rel. split, all roots
in tau(p).
L154is_split_spherical(Param p) = bool
Test if a K-type is G-spherical: must be LKT of G-spherical p.

highest_weight_split_spherical 4 overloads

L157highest_weight_split_spherical (KType t) = KHighestWeight
Highest weight of a G-spherical K-type (necessarily unique).
L170highest_weight_split_spherical (Param p) = KHighestWeight
Highest weight of LKT of a G-spherical parameter (is unique).
L174highest_weight_split_spherical (KType t,KGBElt x_K) = KHighestWeight
Highest weight of LKT of G-spherical K-type w.r.t. x_K (is unique).
L178highest_weight_split_spherical (Param p,KGBElt x_K) = KHighestWeight
Highest weight of LKT of a G-spherical parameter w.r.t. x_K (is unique).

highest_weight_one 2 overloads

L183highest_weight_one (KType t) = KHighestWeight
This function returns just ONE KHighestWeight of a K-type
(auxiliary function).
L203highest_weight_one (KType t,KGBElt x_K) = KHighestWeight
ONE KHighestWeight of a K-type w.r.t. x_K (auxiliary function).

highest_weights 4 overloads

L208highest_weights (KType t) = [KHighestWeight]
All highest weights of a K-type; R-group acts on one KHighestWeight of
previous function (number of terms is |R(K)/R(K,mu)|).
L212highest_weights (KType t,KGBElt x_K) = [KHighestWeight]
All highest weights of a K-type w.r.t. x_K.
L216highest_weights (Param p) = [KHighestWeight]
List of all highest weights of all LKTs of a parameter.
L220highest_weights (Param p,KGBElt x_K) = [KHighestWeight]
List of all highest weights of all LKTs of a parameter w.r.t. x_K.

highest_weight 3 overloads

L224highest_weight (KType t) = KHighestWeight
Unique highest weight of a K-type (or error if not unique).
L230highest_weight (KType t,KGBElt x_K) = KHighestWeight
Unique highest weight of a K-type w.r.t. x_K (or error if not unique).
L237highest_weight (Param p) = KHighestWeight
Unique highest weight of (unique) LKT of a parameter
(or error if not unique).

KHighestWeight to K_types L244

Vogan algorithm L246

centralizer

L252centralizer(KGBElt x,ratvec v) = KGBElt
function called by project_on_dominant_cone
(Auxiliary function)

also defined in good_W_representatives.at, nilpotent_centralizer.at, subgroups.at, conjugate.at, cyclotomic_Lie_algebra.at, bracket.at, weyl_character_formula.at

find_nci_root

L263find_nci_root (KGBElt x,ratvec tau) = int
function called by project_on_dominant_cone
(Auxiliary function)
((),x,mu) is a KHighestWeight (see top of this file)
 x in the distinguished fiber, theta_x=delta
 mu\in X^*, viewed modulo (1-delta)X^*
in (X^*)^delta project it to X^*(T_K0) where T_K0=identity component of H^delta
L281
(x,mu) equivalent to (wx,w\mu) so WLOG mu is G-dominant
L285
sum of the roots of K as an element of (X^*)^delta\otimes Q
(it can be half-integral)
x is assumed to be in the distinguished fiber, defining K
in particular alpha complex posroot implies theta(alpha) is a posroot too
tworho_K(x)\in X^* and tworho_K_fixed(x)\in 1/2(X^*)^delta map
to same element 2*rho_K(x) in X^*(T_{K_0})
L287

tworho_K

L297tworho_K (KGBElt x) = ratvec
Sum of the roots of K as an element of $(X^*)^{\delta}\otimes\mathbb Q$
(this may be half-integral); x must be in the distinguished fiber.

project_on_dominant_cone 2 overloads

L306project_on_dominant_cone (KGBElt x, ratvec mu) = (KGBElt,ratvec,ratvec)
Vogan algorithm to project k_highest_weight(x,mu) on dominant cone; returns
(x',mu+2rho_K(x)-rho,tau) with tau dominant and x' corresponding to the new
Weyl chamber.
L347project_on_dominant_cone (KGBElt x, vec mu) = (KGBElt,ratvec,ratvec)
Vogan algorithm; previous function in case mu is given as a vec,
rather than ratvec.
possibly multivalued, coming from G-spherical case
L350
This function is the same as basis_lambda_differential_0 in all_parameters.at
   List of weights representative of a set of generators of the elementary
   2-group ker(1+theta(x))/im(1-theta(x)).
characters_order_2@KGBElt
returns [v_0,...,v_k], v_i\in X^*,
the characters of H^{theta_x} with differential 0
are \sum a_i v_i with a_i=0,1 (or [] -> [0,...,0])
L352

characters_order_2

L362characters_order_2 (KGBElt x) = [vec]
(Auxiliary function)

reduce 2 overloads

L373reduce ([Param] parameters) = [Param]
reduce [Param] by combining equivalent parameters;
returns a list of inequivalent parameters
L380reduce ([KType] Kparameters) = [KType]
to reduce a list of KParams, convert to list of parameters, reduce,
then convert back

also defined in extParamPol.at

cone

L388cone (rat limit, [rat] cs ) = mat
all nonnegative |vec:a| with $\sum_i(cs[i]*a[i]) \leq limit$
intended application: c_i = <rho_check,i^th fundamental weight>, which finds
all dominant weights at level <= limit, where simple roots have level 1
all >0
columns are weights
this file used to be called all_Kparameters.at;
it includes functions for constructing both Kparameters and parameters
L403

basis_lambda_differential_0

L412basis_lambda_differential_0 (KGBElt x) = mat
matrix whose columns are weights representative of a set of generators
of the elementary 2-group ker(1+theta(x))/im(1-theta(x)). Might do as well:
let (A,v) = adapted_basis(1-involution(x))
then (B,)=filter_units(A[:,:#v],v) in B
columns are weights

all_lambda_differential_0

L425all_lambda_differential_0 (KGBElt x) = [vec]
all 2^k vectors in X^* representing the characters of H^theta with
differential 0
k= number of R^* factors in H
if H^theta is connected, returns [[0,...,0]]

all_equal_dlambda_K_parameters

L430all_equal_dlambda_K_parameters (KType t) = [KType]
all K parameters with same d_lambda as (x,lambda)
for v in all_lambda_differential_0(x) do (x,lambda+v) od
L435

all_parameters

L438all_parameters (Param p) = [Param]
all actual parameters with same d_lambda as p, same nu

all_parameters_x_gamma

L443all_parameters_x_gamma (KGBElt x,ratvec gamma) = [Param]
all parameters with given infinitesimal character and attached to given x

also defined in G2_unitary_dual.at

keep only 1 from each equivalence class
L453

all_parameters_gamma

L456all_parameters_gamma (RealForm G,ratvec gamma) = [Param]
all parameters with given infinitesimal character
keep only 1 from each equivalence class
L467

all_G_spherical_same_differential 2 overloads

L471all_G_spherical_same_differential(KType mu) = [KType]
All G-spherical K-types with same differential as given one.
L478all_G_spherical_same_differential (Param p) = [KType]
All G-spherical K-types with same differential as the LKT of parameter p.
see KHatHowe, end of Section 13
 mu-> phi=lambda-mu_2-2rho_c+rho
   (=lambda-mu_3_orig from project_on_dominant_cone)
write phi is a non-negative rational combination of simple roots
the simple roots with strictly positive coefficient give the Levi factor L,
and q=l+u is the corresponding standard parabolic
L481

parabolic_LKT

L490parabolic_LKT (KHighestWeight(,x,mu)) = Parabolic
Parabolic attached to KHighestWeight by Vogan algorithm.
go from KHighestWeight mu to K_types [KType]  mu -> [t_1,...,t_r]
  multivalued: highest_weight(t_i)=mu
 algorithm:
 1) G-spherical case: mu\in X^*/(1-delta)X^*, satisfying <mu,\alpha^\vee>=0
    for all alpha in Delta(G,T_{K_0})
See KHatHowe, Section 15
L496

make_strongly_dominant

L504make_strongly_dominant (KHighestWeight(,x,v))

also defined in W_K.at

find_x_with_dominant_rho_c 2 overloads

L508find_x_with_dominant_rho_c (RealForm G) = KGBElt
L512find_x_with_dominant_rho_c (KGPElt Q) = (KGBElt,bool)

inds

L531inds (KHighestWeight mu_in) = [[Param]]
Auxiliary function: Given a highest weight mu, calculate the
corresponding one-dimensional parameter on the relatively split Levi
factor of the theta-stable parabolic determined by mu. Then for all
L-shperical parameters with the same infinitesimal character, theta-induce
to G, and make a list of the constituents of the induced. This results in
a list of parameters for each L-spherical parameter. If mu is strongly
dominant, the output should be a list of singletons.

choose_irred_inds

L547choose_irred_inds ([[[Param]]] list) = [[[Param]]]
Auxiliary function: For a list of lists as computed in the previous
function, pick out those consisting just of singletons. In the next function,
such a list (named "test") will be created, one list of lists for each weight
in an R-group orbit.
Choosing singletons corresponds to choosing the (unique) strongly dominant
weight in the orbit.

K_types

L554K_types (KHighestWeight(,x,v):mu_in) = [KType]
This function takes KHighestWeight mu -> |R(K,mu)| K_types,
see top of this file.

From the earlier documentation (documented there as K_types:KHighestWeight mu_in->[K_Type])

All K_types with the same KHighestWeight.

also defined in modules.at

K_type

L573K_type (KHighestWeight khwt) = KType
K_type with given KHighestWeight if unique (otherwise error).

KHighestWeight to K0_param L580

K0_param_from_highest_weight

L584K0_param_from_highest_weight (KHighestWeight(,x,mu)) = Param
Parameter for (the RealForm K_0) of the K_0-type with highest weight
(the restriction of) KHighestWeight mu.
dimension of KHighestWeight=dimension of representation of K_#
                             =dimension of representation of K_0,
			        given by Weyl dimension formula
L587

dimension 2 overloads

L592dimension (KHighestWeight mu) = int
Dimension of the K_#-type with KHighestWeight mu.
L596dimension (KType t) = int
Dimension of a K-type.

also defined in basic.at, finite_dimensional.at, nilpotent_orbits.at, character_tables.at, W_reps_type_BC.at, tensor_product.at, exceptional.at

given mu in X^*(T_K)=X^*(H)/(1-delta)X^*(H), choose representative in X^*(H)
giving a KHighestWeight ((),x,mu) cannot necessarily take mu to be \delta-fixed
L600

K_highest_weight_from_K0_weight

L608K_highest_weight_from_K0_weight (KGBElt x,vec mu_K) = KHighestWeight
Given the highest weight for K0 and a KGB element in the distinguished fiber
for the corresponding group G, compute (one of) the highest weight(s) for K;
(there may be more than one if K# is not equal K_0); in the unequal rank
case, mu_K will have fewer coordinates than the K-weight).

fundamental_weights_K_H

L613fundamental_weights_K_H (KGBElt x) = [ratvec]
this may be a ratvec, not vec
(Auxiliary function)

K0_param 2 overloads

L619K0_param (KType t,KGBElt x_K) = Param
ONE K_0-type in the restriction of a K_type to the identity component K_0 of K;
x_K must be in the fundamental fiber.

From the earlier documentation

ONE K_0-type in the restriction of a K_type to the identity component K_0 of K
(auxiliary function).
L625K0_param (KType t) = Param
ONE K_0-type in the restriction of a K_type to the identity component K_0 of K;
x_K is taken to be KGB element #0.

From the earlier documentation

ONE K_0-type in the restriction of a K_type to the identity component K_0 of K
(auxiliary function).

also in this file at line 640, line 646

K0_params 2 overloads

L630K0_params (Param p,KGBElt x_K) = [Param]
All K_0-types in the restriction of the LKTs of parameter p to K_0; x_K must
be in the distinguished fiber.
L636K0_params (Param p) = [Param]
All K_0-types in the restriction of the LKTs of parameter p to K_0; x_K is taken
to be KGB element #0.

K0_param 2 overloads

L640K0_param (Param p,KGBElt x_K) = Param
Unique K_0-type in the restriction of (unique) LKT to K_0 (error if not unique).
L646K0_param (Param p) = Param
Unique K_0-type in the restriction of (unique) LKT to K_0 (error if not unique).

also in this file at line 619, line 625

fundamental_weight_coordinates

L650fundamental_weight_coordinates (KHighestWeight(,x,mu)) = vec
(Auxiliary function)

also defined in finite_dimensional.at

K_highest_weight_from_fundamental_weights

L656K_highest_weight_from_fundamental_weights(KGBElt x,vec tau) = KHighestWeight
if possible, take weight of K_0, in fundamental weight coordinates, to
k_highest_weight(x,mu)
(Auxiliary function)

dimensions 3 overloads

L665dimensions (Param p, KGBElt x_K) = [int]
List of the dimensions of the K_0-types in the restriction of the LKTs of parameter p.
L669dimensions (Param p) = [int]
List of the dimensions of the K_0-types in the restriction of the LKTs of parameter p.
L673dimensions ([Param] B) = [[int]]
List of the dimensions of the K_0-types in the restriction of the LKTs of
a list of parameters.

test_K_types

L676test_K_types (RealForm G) = void
all discrete/minimal principal series
L683

all_discrete_series

L685all_discrete_series(RealForm G, ratvec gamma) = [Param]

all_minimal_principal_series

L698all_minimal_principal_series(RealForm G,ratvec gamma) = [Param]
there are 2^rank minimal principal series of a split group
with given infinitesimal character gamma, parameter(x,lambda,gamma)
where lambda runs over characters of M=Z_2^rank
warning: some parameters may fail to be final
all minimal principal series of split group with given infinitesimal character.

all_dominant_norm_upto

L718all_dominant_norm_upto (InnerClass ic, ratvec cowt,int N) = mat
all_dominant_norm_less_than(InnerClass ic,ratvec v,int N):
returns mu dominant (which will be 2*d*lambda=(1+theta)*lambda) such that
1) mu\in X^*
2) d*mu restricted to the center is trivial
3) <v,mu> = <=N
Note: default is v=rho_check(G), so condition is
<rho_check,mu> = 2d*<rho_check,lambda> <= N
in applications: mu is for L, a subgroup of G, and v=rho_check(G)
algorithm:
set [lambda_1,...,lambda_{m-1}]=fundamental weights
set [lambda_m,...,lambda_{n-1}]=lie_compact_radical_hat(G):
 this is a Z-basis of compact part of radical (see center.at)
[lambda_1,...,lambda_{n-1}] is Z-basis we want
set [rat]:c =[c_1,...,c_{n-1}] where c_i=<lambda_i,v>
use cone to find all mu=\sum a_i lambda_i such that <v,mu>=sum a_i*c_i<=N
columns are weights

lambda_rho_from_dominant_norm_upto

L732lambda_rho_from_dominant_norm_upto (KGBElt x, ratvec v, int N) = mat
filter and transform list of mu's into list of example lambda-rho values
wts

Generated from atlas-scripts at commit 648506c (2026-10-13).