K_Nilpotent.at

kn_verbose

vector 2 overloads

given basis [Param] convert ParamPol to a vector in this basis
assuming ParamPol has integer coefficients
returns a vector if all entries in the ParamPol occur in the basis
otherwise returns no_vec

also defined in basic.at

Vector 2 overloads

versions that will fail is P not in span of basis

KNilpotentData type

set_type
[ KNilpotentData =
  ( RealForm real_form
  , int N              {K_norm bound}
  , ratvec v   {for use in K_norm in reductive case, default is rho_check(G)}
  , [ComplexNilpotent] complex_orbits
     {complex nilpotent orbits, sorted by increasing dimension}
  {,bool precompute_real_orbits
    {flag to use the Vogan algorithm to compute real orbits}
    DISABLED}
  , bool  include_Q_and_P_X_matrices
  , [RealNilpotent] real_orbits {real forms of each complex orbit}
  , [[(KType,KTypePol)]] pairs
    {one pair for each real orbit O
    O-> an array [(mu_L,P)] of pairs L\cap K-type mu_L and KTypePol:Phi(mu_L)
    where P=Phi(mu_L)}
  , [([KType],[KType],mat) ] T_matrices
    {one matrix for each real orbit O
     O->(K_basis,L_cap_K_basis,T)
     K_basis: K_types (for G) coming from O (#=m)
     L_cap_K_basis: K_type for L coming from O (#=n)
     T=mxn matrix given the operator Phi in these bases}
  , [([KType],[KType],mat)] Y_matrices
    {one matrix for each complex orbit OC
     OC->(K_basis,L_cap_K_basis,Y)
     K_basis,L_cap_K_basis: coming from all
      (real forms of complex) orbits of smaller dimension
     Y is the matrix giving the image of Phi in these bases}
  , [([KType],[KType],mat,mat)] Q_and_P_X_matrices
    {one pair of matrices for each complex orbit OC
     (K_basis,L_cap_K_basis,Q,P_X):
     K_basis and L_cap_K_basis: closure of OC,
      i.e. all real forms of OC and all orbits of smaller dimension
     Q=matrix of T/T\cap Y
     P_X=projector_mod_image(Y)=projection to X=W/Y}
  )
]

Fields: real_form, N, v, complex_orbits, include_Q_and_P_X_matrices, real_orbits, pairs, T_matrices, Y_matrices, Q_and_P_X_matrices

principal data structure for KNilpotent calculation

root_datum

also defined in basic.at, W_reps.at, sommers.at

Q_matrices

P_X_matrices

complex_orbit_number

also in this file at line 76, line 77

real_orbit_number

complex_orbit_number 2 overloads

also in this file at line 74

real_forms_of

all real forms of given complex orbit

other_real_forms

given a real orbit O, all of the other real forms of complexification OC of O

closure

"closure" means: smaller dimension

complex nilpotent -> orbit itself and all complex nilpotents of smaller dimension

closure_real

all real forms of given complex orbit, and all real
forms of smaller orbits

closure_of_real_orbit

real orbit and all real orbits of smaller dimension

smaller_orbits

real orbit -> all orbits of strictly smaller dimension

K_basis 4 overloads

K-types occurring in given KTypePol

K-types occurring in given KTypePols

all K-types coming from given KNilpotentData

K-Types coming from given orbits

also in this file at line 144

K_basis_closure

K-types coming from all real forms of complex orbit,
and all real forms of smaller orbits

K_basis_closure_of_real_orbit

K-types coming from real orbit, and all real orbits of smaller dimension

K_basis

K-types from all orbits
this should be the same as K_parameter_norm_upto(G,data.N)

also in this file at line 115, line 118, line 121, line 126

change_basis

given a matrix in K_basis, convert to K_basis_new
requirement: K_basis is a subset of K_basis_new (unless n_columns(M)=0)

L_cap_K_basis 3 overloads

L\cap K-types coming from given orbit

L\cap K-types coming from given orbits

L_cap_K_basis_opp

T_matrix

matrix constructed from list of pairs [(KType,KTypePol)]
 defining a map from L\cap K-types to K-types
 each KTypes if for L\cap K, each KTypePol is for G
rows <-> K-types (for G)
columns <-> L\cap K-types
each column gives Phi(L\cap K-type) as a sum of K-types

merge_matrices

merge_T_matrices

merge_P_X_matrices

compute_Y_matrix

(K_basis,L_cap_K_basis,Y) all for smaller orbits,not including P_X

theta_orbit_reps

given a theta_x-stable set of roots R, return subset of R
consisting of each imaginary root alpha\in R, and one of each pair
alpha,theta(alpha)
if R isn't theta-stable this will fail with an error

s_one_roots

roots of H in s[1]
s = -1 eigenspace of theta_x
s[1] = 1 H-eigenspace of H on s

s_one_roots_restricted

restriction of s_one_roots to H^{theta_x}
each pair (alpha,theta(alpha)) contributes
a single root restriction(alpha)=restriction(theta(alpha)),
corresponding to the single vector X_\alpha-\theta(X_\alpha) in s[1]
characters of H^theta are elements of X^*/(1-theta)X^*

s_one_nc_cx_restricted_roots

only want the non-compact imaginary roots after restriction
these are the nci roots, and one of each pair of complex roots

subsets_of_s_one_nc_cx_restricted_roots

all non-empty subsets of the set of restrictions of roots of s[1] to H^{theta_x}
see KNilpotent paper, Corollary 7.3(6)

rho_shifts

H is in \mathfrak h, not \mathfrak h^*

twist_by_minus_2rho_u_cap_s 2 overloads

given Q theta-stable, and the K-type formula P for a K-type mu_L of L=Levi(Q),
return the K-type formula for mu_L twisted by -2rho(u\cap s)
algorithm: apply  twist_by_minus_2rho_u_cap_s to P (see induction.at)
term by term,  each individual term in the result may
be a non-standard parameter for L, apply standardize to each term,
to give a sum of STFL parameters for L:
this is the K-type formula for a single L\cap K-type
STFL: standard final limit parameter

replace K-type mu with mu\otimes (-2\rho(u\cap s))

Phi

also in this file at line 379, line 380, line 382

Phi 3 overloads

variants of Phi

also in this file at line 325

functions_on_real_orbit

functions on real orbit as K-representation

in_span 2 overloads

given KTypePols list=[Q_1,...,Q_n] and KTypePol:P test if
P=\sum a_i Q_i with a_i\in Z
return true/false, and [KTypePol] R,[int] a so that
P=sum a[i]*R[i]

convenient to define in_span([[KTypePol]] list,KTypePol P)=
in_span( flatten the list,P)

Phi_upto 2 overloads

returns all (?) [(mu_L,extension)], such that all terms in extension have K_norm <= N

initialize_KNilpotent 4 overloads

initialize KNilpotentData for G, with given bound, optional ratvec, optional
"compute" flag to compute nilpotent orbits using Vogan's algorithm

update_pairs

crude guess of possible real orbits, given complex orbits
the actual real orbits are a subset of these
this command is not needed if using Vogan algorithm to compute real orbits

set potential_real_nilpotent_orbits(RealForm G,[ComplexNilpotent] complex_orbits)=[RealNilpotent]:
let delta=distinguished_involution(G) in
##for (rd,H)@i in complex_orbits
 do
  if H*delta=H {H must be ^delta-fixed to give a real orbit} then
   let roots_of_Levi=simple_roots_from_coweight(rd,H) then
   P_complex= (rd,roots_of_Levi) then
   theta_stable_parabolics=theta_stable_parabolics(G,P_complex) in
   for P in theta_stable_parabolics do RealNilpotent:(H,x_min(P),[]) od
   else []
  fi
 od

set potential_real_nilpotent_orbits(RealForm G)=[RealNilpotent]:
potential_real_nilpotent_orbits(G,complex_nilpotent_orbits(G))

are these necessary? there must be a more elegant way to do this

update_T_matrices

update_Y_matrices

update_Q_and_P_X_matrices

fill_one_step

assume things computed up to complex orbit i-1
(not including Q and P_X)
fill data up to complex orbit i

KNilpotentData:

fill 2 overloads

fill orbits 0,1,...,n-1

completely fill KNilpotentData, inductively starting at orbit 0

failed

default failed values

could use unions instead

failed_av_ann

failed_av

search 2 overloads

find P in terms coming from given list of real orbits

returns (failed or):
K_basis from list of orbits
vector w in basis of K-types (expressing given P in this basis)
L_cap_K basis from list of orbits
matrix T of map from L\cap K-types to K-types
vector v in basis of L\cap K-types
satisfying Tv=w
bool indicating success

same as previous, where P=Phi(O,mu_L)

also in this file at line 601

search

given complex orbit OC,
 w=vector of ParamPol P in basis of K-types from OC
 solve Qv=w if possible
return values as in search (above)
returns (failed or):
 [KType]: K_basis from list of orbits
 [KType]: L_cap_K basis from list of orbits
 mat: matrix Q of map from L\cap K-types to K-types
 vec: vector v in basis of L\cap K-types
 vec: vector w expressing P in basis of K-types
 v is solution to: Qv=w (should be unique if it exists)
 bool: success

also in this file at line 554, line 565

av_ann 2 overloads

same as previous where the complex orbit OC isn't specified, return values
include an int giving OC

associated variety of annihilator of Param p
apply the previous to K-types of p, i.e. character_formula(p)*0

projector

given v=[a_1,a_2,...,a_n]
return diag[0^{a+1},...,1^{a_i},...0^{a_n}]

also defined in projectors_using_character_tables.at

av_from_av_ann 2 overloads

compute the associated variety given av_ann
algorithm: given O (complex) with real forms O_0,...,O_n
Q,P_X for O
solve Qv=P_X(w)
Q has a large kernel, but anything in the kernel has to do with smaller orbits
write v=[v_0,v_1,..,v_k,v_{k+1},..,v_{k+n}]
where [v_0,...,v_{k-1}] from smaller orbits
[v_k,...,v_{k+n}] on given orbit
the associated variety is those O_i such that v_{k_i}\ne 0

av 3 overloads

compute associated variety of irreducible J(p)

av_ann_elem_long

also in this file at line 699

av_ann_elem_long

also in this file at line 688

av_from_av_ann_elem_long 2 overloads

associated variety of P, assuming associatevariety OC of ann(P) is known

algorithm: run over subsets of real forms of OC
and try to solve Tv=w

associated variety of p, assuming OC=associated variety of ann(p) is known

av_elem_long 2 overloads

same as previous but computed av_ann_elem(P)

associated variety of p from scratch, by computing
OC=av_ann_elem(p) first

av_ann_elem 2 overloads

shorter versions

av_from_av_ann_elem 2 overloads

av_elem 2 overloads

stringify

useful for including "(a,b)" in a sequence of strings to be printed

display_string

show

highly customized function for displaying KNilpotentData

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

test_minimal_orbits 2 overloads

display K-types as highest weights for K_0

print K-types as KHighestWeights

test_all_orbits 2 overloads

display K-types as highest weights for K_0

print K-types as KHighestWeights