atlas Library · Script File

`induction.at`

! Parabolic induction from real and $\theta$-stable parabolics; cuspidal and
$\theta$-stable data of a parameter, and some functions related to $\theta$-stable parabolics.

Parabolic induction:
_________________________

| If L is a $\theta$-stable Levi subgroup of G, then KGB for L embeds into KGB for G.
| For parabolic induction, a parameter p_L for the Levi L is assigned a parameter p_G for G:
|
| p_L=(x_L,lambda,nu) -> p_G=(embed_KGB(x_L,G),lambda + appropriate rho-shift,nu).
|
| For real parabolic induction, the rho-shift is: $\rho_r(G)-\rho_r(L)+(1-\theta)(\rho_S(G)-\rho_S(L))$.
| (Here $\rho_S$ is a certain half sum of complex roots.)
| The Levi L must be the Levi factor of a REAL parabolic subgroup.
|
| For $\theta$-stable (cohomological parabolic) induction, the rho-shift is:
| $\rho_i(G)-\rho_i(L)+\rho_{complex}(G)-\rho_{complex}(L)  =\rho(G)-\rho_r(G)-\rho(L)+\rho_r(L)$.
|  Since $\mathfrak q$ is $\theta$ -stable, $\rho_r(G)-\rho_r(L)=0$, so the shift is $\rho(G)-\rho(L)=\rho(\mathfrak u)$.
| The group L must be the Levi factor of a THETA-STABLE parabolic subgroup of G.
|
| Then $\operatorname{Ind}_P^G I(p_L)=I(p_G)$.
|
| In the $\theta$-stable case, the shifted parameter p_G may be non-standard and needs to be standardized:
| If p=(x,lambda,nu), and $\langle \text{lambda},\alpha^{\vee}\rangle <0$ for some imaginary root $\alpha$ (i.e. non-standard),
| let i_root_system=imaginary roots for x(p). Find $w$ so that $w^{-1}\cdot$lambda is dominant for
| imaginary roots, set p_dom=parameter(x,$w^{-1}\cdot$lambda,nu) and return coherent continuation
| action (wrt imaginary roots) of $w$ on p_dom.
|
$A_q(\lambda)$ construction:
______________________________________________

| Note: theta_induce_irreducible(pi_L,G) has infinitesimal character:
| infinitesimal character(pi_L)+rho(u).
| Aq(x,lambda,lambda_q) is defined as follows:
| if lambda_q is weakly dominant set q=q(x,lambda_q),
| apply derived functor to the one-dimensional lambda-rho(u) of L.
|
| REQUIRE: lambda-rho(u) must be in X^*.
|
| Aq(x,lambda,lambda_q) has infinitesimal character lambda+rho_L,
| thus the one-dimensional with weight lambda has infinitesimal character
| lambda+rho_L for L, and goes to a representation with
| infinitesimal character lambda+rho_L for G; i.e., Aq takes infinitesimal
| character gamma_L to SAME infinitesimal character for G.
| If lambda_q is not weakly dominant, define
| Aq(x,lambda,lambda_q)=Aq(wx,w\lambda,w\lambda_q),
| where w\lambda_q is weakly dominant.
|

Good/Fair conditions:
________________________

| Condition on the roots of $\mathfrak u$:
| For theta_induce(pi_L,G), gamma_L -> gamma_G=gamma_L+rho_u.
| Then:
| GOOD:  <gamma_L+rho_u,alpha^vee> > 0;
| WEAKLY GOOD:  <gamma_L+rho_u,alpha^vee> \ge 0;
|
| For  Aq(x,lambda,lambda_q): gamma_L=lambda+rho_L;
| gamma_L -> gamma_G=gamma_L = lambda+rho_L
| Aq(x,lambda)=theta_induce(x,lambda-rho_u)
| Then:
| GOOD: <lambda+rho_L,alpha^vee> > 0;
| WEAKLY GOOD: <lambda+rho_L,alpha^vee> >= 0;
| FAIR: <lambda,alpha^vee> > 0;
| WEAKLY FAIR: <lambda,alpha^vee> \ge 0.
|
| theta_induce(pi_L,G) = Euler-Poincare characteristic of the
| cohomological induction functor.
|
| fair => vanishing outside middle degree => honest representation
| weakly fair: same implication.
| NB: <gamma_L-rho_L_rho_u,alpha^vee> >= 0 does NOT imply vanishing (in general) if pi_L is not weakly unipotent (e.g.,
| one-dimensional), hence "weakly fair" is only defined if pi_L is one-dimensional.
|
!

Source

atlas-scripts/induction.at (1124 lines)

Definitions

110

Loads

<basic.at
<parabolics.at
<kl.at { for |character_formula| }
<coherent.at
<synthetic.at { for |unnormalized_torus_factor| }
<Weylgroup.at { for |to_no_Cminus@Param| }
<K.at
<W_K.at { for |cross_divide| }
<finite_dimensional.at

Loaded by

adams_johnson.at speh.at K_highest_weights.at nilpotent_orbits.at nci_nilrad_roots.at convert_c_form.at

Definitions in source order

`ind_verbose`

L88ind_verbose = false

`embed_KGB`

L91embed_KGB (KGBElt x_L,RealForm G) = KGBElt

If L is a theta-stable Levi factor in G,  KGB for L embeds in KGB for G.

also defined in parabolics.at

`inverse_embed_KGB`

L95inverse_embed_KGB (KGBElt x_G,RealForm L) = KGBElt

Given a KGB element of G, find one for the theta-stable Levi L which maps to it.

also defined in parabolics.at

real parabolic induction L99

`makeS` 2 overloads

L104makeS (mat theta,RootDatum rd) = mat

Given an involution theta and a root datum, return the set S of complex roots
containing the first positive representative of each quadruple
($\pm$ alpha,$\pm$ theta(alpha)).

L109makeS (KGBElt x) = mat

As the previous function, with argument a KGB element x determining the
involution and root datum

also defined in parabolics.at, nci_nilrad_roots.at

`rho_S` 2 overloads

L112rho_S ((mat,RootDatum)pair) = ratvec

Half sum of roots in chosen set S of complex roots, described above.

L115rho_S (KGBElt x) = ratvec

As previous function, with argument KGB element x.

also defined in parabolics.at

`make_parabolic`

L119make_parabolic (RealForm L,RealForm G) = Parabolic

Given a Levi subgroup L of G, construct the parabolic with Levi L
(this reverses Levi(P) defined in parabolics.at).

also defined in parabolics.at

Real Levi subgroups need not be standard. A real Levi L of G containing the
Cartan of x is generated by that Cartan and the roots beta with beta-theta*beta
in some subspace of the -1 eigenspace of theta: L is the centralizer of a
split torus, contains every imaginary root of x, and is the Levi of a real
parabolic. The functions below take the positive roots of L to be the positive
roots of G lying in L; with that choice the rho-shift of real induction is the
same formula for standard and nonstandard L, and nothing in it refers to the
simple roots of G. The KGB element of L has the involution and torus factor of
the KGB element of G (embed_KGB, inverse_embed_KGB).

L125

`real_Levi_of_posroots`

L138real_Levi_of_posroots (KGBElt x, [int] js) = (RealForm,KGBElt)

The real form and KGB element on the Levi subgroup of the Cartan of x whose
positive roots are the positive roots of G with indices js; js must be the
roots of a real Levi, as described above.

`real_Levi_of_cwt`

L154real_Levi_of_cwt (KGBElt x, ratvec tau) = (RealForm,KGBElt)

Real Levi of the Cartan of x centralizing the coweight tau, which must
satisfy tau*theta=-tau: the roots beta with tau*beta=0. Need not be standard.

`real_Levi_of_span`

L162real_Levi_of_span (KGBElt x, mat V) = (RealForm,KGBElt)

Real Levi of the Cartan of x with the roots beta such that beta-theta*beta
lies in the column span of V (a subspace of the -1 eigenspace of theta).
Need not be standard.

`is_real_Levi_for`

L171is_real_Levi_for (RealForm L, KGBElt x_G) = bool

Whether L is a real Levi subgroup of G for the Cartan of x_G (standard or
not): the positive roots of L are positive roots of G, and the roots of L are
exactly the roots beta of G for which beta-theta*beta lies in the span of the
alpha-theta*alpha for alpha in L (so L contains all imaginary roots).

`real_Levi_shift`

L182real_Levi_shift (KGBElt x_G, KGBElt x_L) = ratvec

The rho-shift from the real Levi L to G at the involution of x_G.

`real_induce_standard`

L189real_induce_standard (Param p_L,RealForm G) = Param

Real parabolic induction of a standard module of real Levi L (i.e., L
must be the Levi factor of a real parabolic subgroup, not necessarily
standard, with positive roots those of G) to G

also in this file at line 205

`real_restrict`

L198real_restrict (Param p,RealForm L) = Param

Inverse of real_induce_standard: p on G, L a real Levi (not necessarily
standard) for the Cartan of x(p), such as real_Levi_of_cwt(x(p),tau). Returns
p_L on L with Ind(I(p_L))=I(p).

`real_induce_standard`

L205real_induce_standard (ParamPol P,RealForm G) = ParamPol

Real parabolic induction of standards, applied to a formal sum of
parameters (ParamPol).

also in this file at line 189

`real_induce_irreducible_as_sum_of_standards`

L211real_induce_irreducible_as_sum_of_standards (Param p_L, RealForm G) = ParamPol

Write the (real) induced of an irreducible J(p_L) of L as a formal sum of
standards for G; uses the character formula to write J(p_L)
as a formal sum of standards for L first. (Auxiliary function)

`real_induce_irreducible_final`

L220real_induce_irreducible_final (Param p_L, RealForm G) = ParamPol

Write the (real) induced $Ind(J(p_L))$ of an irreducible of |L| as a sum of
irreducibles for |G|; uses composition series to convert output of the
|real_induce_irreducible_as_sum_of_standards| into sum of irreducibles.
The real form |L| of |p_L| must be the Levi factor of a real parabolic
subgroup; and the parameter p_L must be final.

`real_induce_irreducible`

L225real_induce_irreducible (ParamPol P,RealForm G) = ParamPol

Given a polynomial of parameters of L, real induce each term,
and write the result as a polynomial of parameters for G.

`real_induce_is_irreducible`

L236real_induce_is_irreducible (Param p_L, Param p) = bool

Whether Ind(J(p_L))=J(p), for final p_L on a real Levi and final p on G.
Compares expansions in standard modules, so it needs character_formula(p)
but no composition series (4.7x faster than comparing
real_induce_irreducible(p_L,G) with p, on E7_s).

`real_induce_irreducible_final_verbose`

L243real_induce_irreducible_final_verbose (Param p_L, RealForm G) = ParamPol

print out partial information along the way
the terms reported at length L are precisely those of length L in the final result
set composition_series_verbose in kl.at

`real_induce_irreducible_verbose`

L251real_induce_irreducible_verbose (ParamPol P,RealForm G) = ParamPol

print out partial information along the way
the terms reported at length L are precisely those of length L in the final result
set composition_series_verbose in kl.at

|real_induce_irreducible@(Param,RealForm)| not defined, as the |ParamPol|
version suffices: implicit conversion |Param->ParamPol| will apply

L259

`cuspidal_data`

L266cuspidal_data (Param p) = (Parabolic,Param)

----------------------   cuspidal data   -----------------------------

Cuspidal data associated to a parameter p: a cuspidal parabolic subgroup P=MN
and parameter p_M for a relative limit of discrete series so that
Ind(I(p_M))=I(p); uses real_parabolic(x) of parabolics.at

theta-stable data L279

`theta_stable_data`

L285theta_stable_data (Param p) = (Parabolic,Param)

Theta-stable data associated to a parameter p: a theta-stable parabolic P=LN
with L relatively split, and parameter p_L for a principal series representation
so that p is obtained by cohomological parabolic induction
from p_L; uses theta_stable_parabolic(x) of parabolics.at.

`theta_stable_quasi_data`

L303theta_stable_quasi_data (Param q) = (Parabolic,Param)

Theta-stable data associated to a parameter q: a theta-stable parabolic Q=LU
with L quasisplit, and parameter q_L for a fine principal series
representation
so that is obtained by cohomological parabolic induction
from q_L.

standardize L313

`coherent_std_compact_Cartan`

L320coherent_std_compact_Cartan(WeylElt w,Param p) = ParamPol

on the compact Cartan, coherent continuation is well defined even
if the infinitesimal character is singular
translate out -> coherently continue -> translate back
p equivalent to p' => p=p' on the Compact Cartan so this is
well defined

`coherent_std_imaginary`

L340coherent_std_imaginary (WeylElt w,Param p) = ParamPol

coherent continuation using only imaginary roots
to avoid technical issues involving the fact that atlas automatically
finalizes terms in a ParamPol, pass to the cuspidal Levi,
on which all the roots are imaginary, apply coherent continuation
there, and induce back
example: Sp(4,R)
  p=param(KGB(G,7),[3,-2],[1,0])
  p_dom=param(KGB(G,7),[3,2],[1,0])  (lambda is dominant, but not gamma)
  is not dominant, so atlas changes this to the equivalent parameter
  param(KGB(G,5),[2,1],[0,1])
  tricky to keep track of this
  the cuspidal Levi is M=SL(2,R)xGL(1) with root [0,2]
  coherent continuation is going on in M

`standardize` 2 overloads

L348standardize (Param p) = ParamPol

find w so that w*lambda_dom=lambda, this should be in the imaginary Weyl group
then compute coherent continuation by passing to the cuspidal Levi M

From the earlier documentation

Convert a possibly non-standard parameter into a linear combination of
standard ones

L361standardize (ParamPol P) = ParamPol

standardize a formal linear combination of possibly non-standard parameters

also defined in good_W_representatives.at

`is_good`

L365is_good (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the good range for G; this only
makes sense if L is the Levi of a (standard) theta-stable parabolic.

also in this file at line 769, line 806

`is_weakly_good`

L379is_weakly_good (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the weakly good range for G; this only
makes sense if L is the Levi of a theta-stable parabolic.

also in this file at line 774, line 820

`project_on_center`

L387project_on_center (ratvec v, RootDatum L) = ratvec

`is_fair`

L394is_fair (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the fair range for G; this only
makes sense if L is the Levi of a theta-stable parabolic.

also in this file at line 779, line 831

`is_weakly_fair`

L409is_weakly_fair (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the weakly fair range for G; this only
makes sense if L is the Levi of a theta-stable parabolic.

also in this file at line 784, line 847

`goodness`

L426goodness (Param p_L,RealForm G) = string

Determine the "goodness" of a parameter for L; returns "good", "weakly good",
"fair", "weakly fair", or "none"; only makes sense if L is Levi of theta-stable
parabolic.

also in this file at line 790, line 859

theta-stable parabolic induction L441

`theta_induce_standard`

L446theta_induce_standard (Param p_L,RealForm G) = ParamPol

Theta-stable (cohomological) parabolic induction of a standard module for
the Levi L of a theta-stable parabolic; if outside of weakly good range,
must apply standardize.

`theta_induce_parampol`

L474theta_induce_parampol (ParamPol P, RealForm G) = ParamPol

Given a ParamPol P, form a new ParamPol by theta-inducing each
summand.

`theta_induce_irreducible_as_sum_of_standards`

L482theta_induce_irreducible_as_sum_of_standards (Param p_L, RealForm G) = ParamPol

Write the (theta-stable) induced of an irreducible J(p_L) of L as a formal
sum of standards for G; uses the character formula to write J(p_L)
as a formal sum of standards for L first. (Auxiliary function)

`theta_induce_irreducible_final`

L497theta_induce_irreducible_final (Param p_L, RealForm G) = ParamPol

Write the (theta-stable) induced Ind(J(p_L)) of an irreducible of L
as a sum of irreducibles for G; uses composition series to convert
output of the previous function into sum of irreducibles. The subgroup
L must be the Levi factor of a theta-stable parabolic. The parameter
p_L must be final.

`theta_induce_irreducible`

L509theta_induce_irreducible (ParamPol P,RealForm G) = ParamPol

Given a polynomial of parameters, theta-induce each constituent, and
write the result as a polynomial of parameters.

|theta_induce_irreducible@(Param,RealForm)| not defined, as the |ParamPol|
version suffices: implicit conversion |Param->ParamPol| will apply

L516

`map_into_distinguished_fiber`

L519map_into_distinguished_fiber (KGBElt x) = KGBElt

`u`

L531u (KGBElt x) = mat

Positive coroots in the nilradical of the theta-stable parabolic determined
by x.

set of coroots

`dim_u` 3 overloads

L535dim_u(Parabolic P) = int

Dimension of $\mathfrak u$ (nilrad of theta-stable parabolic).

L538dim_u(KGBElt x) = int

Dimension of the nilradical of the theta-stable parabolic determined by KGB elt x.

L541dim_u (ratvec H,KGBElt x)

Dimension of the nilradical of the parabolic determined by a weight H.

`dim_u_cap_k` 3 overloads

L544dim_u_cap_k (Parabolic (,x):P) = int

Dimension of $\mathfrak u\cap\mathfrak k$ for theta-stable parabolic.

L555dim_u_cap_k (KGBElt x) = int

Dimension of $\mathfrak u\cap\mathfrak k$ for theta-stable parabolic determined
by x.

L559dim_u_cap_k(ratvec lambda,KGBElt x) = int

Dimension of $\mathfrak u\cap\mathfrak k$ for theta-stable parabolic determined by
weight lambda.

`dim_u_cap_p` 3 overloads

L565dim_u_cap_p (Parabolic (,x):P) = int

Dimension of $\mathfrak u\cap\mathfrak p$ for theta-stable parabolic.

L576dim_u_cap_p (KGBElt x) = int

Dimension of $\mathfrak u \cap\mathfrak p$ for theta-stable parabolic associated
to x.

L580dim_u_cap_p (ratvec lambda,KGBElt x) = int

Dimension of $\mathfrak u\cap\mathfrak p$ for theta-stable parabolic determined by
weight lambda.

`dim_u_cap_k_2`

L586dim_u_cap_k_2 (Parabolic P,ratvec H ) = int

(Auxiliary function)

a coweight

`dim_u_cap_k_ge2`

L597dim_u_cap_k_ge2 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_p_ge2`

L608dim_u_cap_p_ge2 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_k_1`

L619dim_u_cap_k_1 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_p_1`

L630dim_u_cap_p_1(Parabolic P, ratvec H)

(Auxiliary function)

alternative versions of theta_induce_irreducible L640

`find_N`

L642find_N (Param p_L,RealForm G) = int

also in this file at line 1098

First version using coherent continuation of irreducibles:
coherent_irr(p,w) uses character_formula and composition_series

L655

`theta_induce_irreducible_coherent`

L659theta_induce_irreducible_coherent (Param p, RealForm G) = ParamPol

moved to coherent_irreducible.at

L671

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

L672

Commented-out code, lines 677–700 (22 lines)

set theta_induce_irreducible_wgraph ([Param] block, WGraph graph, Param p, RealForm G)=ParamPol:
   let rd=root_datum(G), N=find_N (p,G), rho_u=rho(G)-rho(real_form(p))
   then q=translate_param_by (p,ratvec_as_vec(N*two_rho(G))){.monomials[0]}
   then ind=parameter(embed_KGB(x(q),G),lambda(q)+rho_u,nu(q))
   then (w,gamma_dom)=from_dominant(rd,p.infinitesimal_character+rho_u)
    {w:gamma_dom -> p.infinitesimal_character _rho_u}
   then P=coherent_irr(block,graph,ind,w.inverse)
   in G.null_module + for c@q in P do c*T_param(q,gamma_dom) od

{this is slow and probably negates the possible speed advantage of theta_induce_irreducible_wgraph,
but useful for testing
}
set theta_induce_irreducible_wgraph (Param p, RealForm G)=ParamPol:
   let rd=root_datum(G), N=find_N (p,G), rho_u=rho(G)-rho(real_form(p))
   then q=translate_param_by (p,ratvec_as_vec(N*two_rho(G))){.monomials[0]}
   then ind=parameter(embed_KGB(x(q),G),lambda(q)+rho_u,nu(q))
   then block=block_of(ind)
   then graph=W_graph_of(ind)
   then (w,gamma_dom)=from_dominant(rd,p.infinitesimal_character+rho_u)
    {w:gamma_dom -> p.infinitesimal_character _rho_u}
   then P=coherent_irr(block,graph,ind,w.inverse)
   in G.null_module + for c@q in P do c*T_param(q,gamma_dom) od

some representations L701

Aq(x,lambda,lambda_q)=Aq(wx,wlambda,wlambda_q) so we can assume
lambda_q is dominant

L703

`make_dominant`

L710make_dominant (KGBElt x,ratvec lambda, ratvec lambda_q) = (KGBElt,ratvec,ratvec)

Conjugate the triple (x,lambda, lambda_q) to make lambda_q weakly
dominant (auxiliary function).

`Aq_reducible`

L718Aq_reducible (KGBElt x,ratvec lambda, ratvec lambda_q) = ParamPol

A_q(lambda) module; $\mathfrak q$ is defined by the weight lambda_q; x_in
must be attached to the fundamental Cartan. The module is defined as a ParamPol,
in case it is reducible.

`Aq` 4 overloads

L735Aq (KGBElt x_in,ratvec lambda, ratvec lambda_q) = Param

A_q(lambda) module defined as above, but as a parameter, assuming it is
irreducible.

L743Aq (KGBElt x,ratvec lambda) = Param

If not provided, assume lambda_q=lambda in the definition of A_q.

L747Aq (RealForm G,ratvec lambda, ratvec lambda_q) = Param

A_q(lambda), specify G, not x, to use x=KGB(G,0).

L751Aq(RealForm G,ratvec lambda) = Param

A_q(lambda), specify G, not x, and use lambda_q=lambda.

Good/Fair conditions L755

`is_one_dimensional`

L758is_one_dimensional(Param p) = bool

Decide whether a parameter defines a one-dimensional representation.

`is_unitary_character`

L762is_unitary_character(Param p) = bool

Decide whether a parameter defines a unitary one-dimensional character.

`is_good`

L769is_good(KGBElt x_in,ratvec lambda_in,ratvec lambda_q_in) = bool

Decide whether A_q(lambda) is good.

also in this file at line 365, line 806

`is_weakly_good`

L774is_weakly_good(KGBElt x_in,ratvec lambda_in,ratvec lambda_q_in) = bool

Decide whether A_q(lambda) is weakly good.

also in this file at line 379, line 820

`is_fair`

L779is_fair(KGBElt x_in,ratvec lambda_in,ratvec lambda_q_in) = bool

Decide whether A_q(lambda) is fair.

also in this file at line 394, line 831

`is_weakly_fair`

L784is_weakly_fair(KGBElt x_in,ratvec lambda_in,ratvec lambda_q_in) = bool

Decide whether A_q(lambda) is weakly fair.

also in this file at line 409, line 847

`goodness`

L790goodness(KGBElt x,ratvec lambda_in,ratvec lambda_q) = string

Determine the "goodness" of an Aq(lambda); returns "good", "weakly good",
"fair", "weakly fair", or "none".

also in this file at line 426, line 859

`is_good`

L806is_good (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the good range for G; this only
makes sense if L is the Levi of a (standard) theta-stable parabolic.

also in this file at line 365, line 769

`is_weakly_good`

L820is_weakly_good (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the weakly good range for G; this only
makes sense if L is the Levi of a theta-stable parabolic.

also in this file at line 379, line 774

`is_fair`

L831is_fair (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the fair range for G; this only
makes sense if L is the Levi of a theta-stable parabolic, and is only
defined if p_L is one_dimensional.

also in this file at line 394, line 779

`is_weakly_fair`

L847is_weakly_fair (Param p_L,RealForm G) = bool

Decide whether a parameter for L is in the weakly fair range for G; this only
makes sense if L is the Levi of a theta-stable parabolic, and is only defined
if p_L is one-dimensional.

also in this file at line 409, line 784

`goodness`

L859goodness (Param p_L,RealForm G) = string

Determine the "goodness" of a parameter for L; returns "good", "weakly good",
"fair", "weakly fair", or "none"; only makes sense if L is Levi of theta-stable
parabolic.

also in this file at line 426, line 790

`Aq_packet` 2 overloads

L875Aq_packet (RealForm G,ComplexParabolic P) = [Param]

List all A_q(0) (actually: R_q(trivial): infinitesimal character rho(G))
modules with Q a theta-stable parabolic of type P.

L884Aq_packet(RealForm G,[int] S) = [Param]

List all A_q(0) (infinitesimal character rho(G)) modules
with Q a theta-stable parabolic of type S (list of simple roots).

Commented-out code, lines 886–888 (2 lines)

This axis version does not allow declaring universal list type argument
set Aq_packet(RealForm G,[*] S)=[Param]:Aq_packet(G,[int]:S)

`Aq_zeros`

L892Aq_zeros(RealForm G) = [Param]

List all good Aq(0) (inf. char. rho) of G; this is more or less
blocku (there may be duplications).

`theta_stable_parabolics_max`

L899theta_stable_parabolics_max(KGBElt x) = [Parabolic]

Given a KGB element x, list all theta-stable parabolics in G
with maximal element x.

`theta_stable_parabolics_with` 2 overloads

L907theta_stable_parabolics_with(KGBElt x) = [Parabolic]

Given a KGB element x, list all theta-stable parabolics in G
determined by x.

L914theta_stable_parabolics_with([Parabolic] tsp,KGBElt x) = [Parabolic]

Same as previous function, but takes the output of
theta_stable_parabolics(G) as additional input for efficiency.

`is_theta_x`

L921is_theta_x(KGBElt x) = bool

Decide whether there is a theta-stable parabolic determined by x.

`is_coh_ind_from_finite_dimensional`

L924is_coh_ind_from_finite_dimensional (Param p) = bool

test if p is cohomologically induced from a finite dimensional in the good range

`is_good_range_induced_from`

L931is_good_range_induced_from (Param p) = [Param]

List of parameters p_L in the (weakly) good range for G so that p is
theta-induced from p_L; may be more than one.

`reduce_good_range`

L953reduce_good_range (Param p) = (Parabolic,Param)

Find the parabolic P and parameter p_L so that p is cohomologically induced,
in the (weakly) good range, from p_L, with L minimal (may be G).

`is_weakly_good_Aq`

L974is_weakly_good_Aq(Param p) = bool

Determine whether p is a weakly good unitary Aq(lambda).

`is_good_Aq`

L979is_good_Aq(Param p) = bool

Determine whether p is a good unitary Aq(lambda).

`is_proper_Aq`

L984is_proper_Aq(Param p) = bool

Determine whether p is a proper (weakly) good unitary Aq(lambda).

`all_real_induced_one_dimensional`

L989all_real_induced_one_dimensional (RealForm G) = [Param]

some rho-shifts involving theta L994

define "two" versions which are vecs

L996

`two_rho_S` 2 overloads

L998two_rho_S(KGBElt x) = vec

L1000two_rho_S ((mat,RootDatum) pair)

also in this file at line 1011, line 1019

`two_rho_u`

L1002two_rho_u(Parabolic P) = vec

`two_rho_S` 2 overloads

L1011two_rho_S(Parabolic P,KGBElt x) = vec

recall rho_S(x)=sum \alpha,
  each {\pm alpha,\pm\theta\alpha} contributes \alpha
 convenient to define two_rho_S(x)
and a relative version two_rho_S(P,x)
Note: two_rho_S(x,P) =\sum \alpha
  one \alpha for each complex pair {\alpha,\theta\alpha} of roots in u

L1019two_rho_S(Parabolic P) = vec

two_rho_S(P)=\sum \alpha, one \alpha from each
pair of complex roots {\alpha,\theta\alpha}
where \theta=theta_{x_min(P)}

also in this file at line 998, line 1000

`rho_u_cx`

L1022rho_u_cx (Parabolic P,KGBElt x) = ratvec

Half sum of complex roots in the nilradical of P

From the earlier documentation (documented there as rho_u_cx:Parabolic P->ratvec)

Half sum of positive complex roots (on fundamental Cartan) in the nilradical of P;
P must be theta-stable.

rho_u_cx(P) is not necessarily in X^*
rho_u_cx(P) restricted to T=H^theta is a character of T
  because (1/2)(\alpha+\theta(\alpha))(t)=\alpha(t)=\theta(\alpha(t) (t\in T)
so define rho_u_cx_T(P) \in X^* to have the same restriction to T=H^\theta
rho_u_cx is a sum of terms (alpha+theta(alpha)/2;
  replace each such term with alpha, which has the same restriction to T
recall two_rho_S is the sum of each \alpha, i.e. rho_cx_u_T=two_rho_S
more precisely: rho_u_cx_T(P,x)=two_rho_S(P,x)

L1025

`rho_u_cx_T`

L1038rho_u_cx_T (Parabolic P) = vec

Element of $X^*$ with same restriction to $(X^*)^{\theta}$ as rho_u_cx(P);
P must be theta-stable.

`rho_u_ic`

L1043rho_u_ic (Parabolic P, KGBElt x) = ratvec

rho_u_ic(P,x)=half the sum of the imaginary, compact roots in u
this is an element of X^*(H)/2

From the earlier documentation (documented there as rho_u_ic:Parabolic P->ratvec)

Half sum of imaginary compact roots in nilradical of (theta-stable) P.

`two_rho_u_cap_k`

L1056two_rho_u_cap_k (Parabolic P,KGBElt x) = vec

2*rho(u\cap k) is a character of H^\theta
need to write it as the restriction of a character of H
2*rho(u\cap k) is the sum of:
all compact imaginary roots of u and
for each {\alpha,\theta\alpha} in u, contribution of alpha
=> two_rho_u_cap_k(P,x)=two_rho_u_ic(P,x) + two_rho_S(P)

Sum of compact roots of H in u for theta-stable parabolic P
with respect to x on fundamental Cartan(L)=fundamental Cartan(G)
warning message if x is not in the class of P

`two_rho_u_cap_s`

L1069two_rho_u_cap_s (Parabolic P,KGBElt x) = vec

2*rho(u\cap s) is a character of H^\theta
need to write it as the restriction of a character of H
2*rho(u\cap s) is the sum of:
all noncompact imaginary roots of u and
for each {\alpha,\theta\alpha} in u, contribution of alpha
=> two_rho_u_cap_s(P,x)=2*rho_u_ic(P,x) + two_rho_S(P)
also can be written:
2*rho(u\cap s)=2*rho(u)-2*rho(u\cap k)

Sum of non-compact roots in $\mathfrak u$ (for theta-stable parabolic).

`twist_by_minus_2rho_u_cap_s`

L1078twist_by_minus_2rho_u_cap_s(Parabolic P,Param p_L) = Param

P is a theta-stable parabolic
p_L is a STFL for L
construct a new, possibly non-standard parameter for L
by subtracting the appropriate 2\rho(u\cap s) from lambda(p_L)
the resulting term might not be standard

also defined in K_Nilpotent.at

`is_in_list`

L1085is_in_list (KGBElt x, [KGBElt] list) = bool

`select_class_terms_from_ParamPol`

L1087select_class_terms_from_ParamPol ([KGBElt] class, ParamPol P) = ParamPol

`p_N`

L1090p_N (Param p, int N, [int] S) = Param

`move_P_down_by_N`

L1094move_P_down_by_N (ParamPol P, int N, [int] Levi) = [(Split,Param)]

`find_N`

L1098find_N ([int] Levi, Param p) = int

also in this file at line 642

`is_standard`

L1107is_standard ([int] Levi, Param p)

`is_final`

L1110is_final ([int] Levi, Param p)

`induce_from_gen_parabolic_irr`

L1113induce_from_gen_parabolic_irr ([int] Levi, Param p) = ParamPol

`L_infinitesimal_character`

L1122L_infinitesimal_character ([int] Levi, Param p) = ratvec

Generated from atlas-scripts at commit f42b20e (2026-10-17).

induction.at

Definitions in source order

ind_verbose

embed_KGB

inverse_embed_KGB

real parabolic induction L99

makeS 2 overloads

rho_S 2 overloads

make_parabolic

real_Levi_of_posroots

real_Levi_of_cwt

real_Levi_of_span

is_real_Levi_for

real_Levi_shift

real_induce_standard

real_restrict

real_induce_standard

real_induce_irreducible_as_sum_of_standards

real_induce_irreducible_final

real_induce_irreducible

real_induce_is_irreducible

real_induce_irreducible_final_verbose

real_induce_irreducible_verbose

cuspidal_data

theta-stable data L279

theta_stable_data

theta_stable_quasi_data

standardize L313

coherent_std_compact_Cartan

coherent_std_imaginary

standardize 2 overloads

is_good

is_weakly_good

project_on_center

is_fair

is_weakly_fair

goodness

theta-stable parabolic induction L441

theta_induce_standard

theta_induce_parampol

theta_induce_irreducible_as_sum_of_standards

theta_induce_irreducible_final

theta_induce_irreducible

map_into_distinguished_fiber

u

dim_u 3 overloads

dim_u_cap_k 3 overloads

dim_u_cap_p 3 overloads

dim_u_cap_k_2

dim_u_cap_k_ge2

dim_u_cap_p_ge2

dim_u_cap_k_1

dim_u_cap_p_1

alternative versions of theta_induce_irreducible L640

find_N

theta_induce_irreducible_coherent

some representations L701

make_dominant

Aq_reducible

Aq 4 overloads

Good/Fair conditions L755

is_one_dimensional

is_unitary_character

is_good

is_weakly_good

is_fair

is_weakly_fair

goodness

is_good

is_weakly_good

is_fair

is_weakly_fair

goodness

Aq_packet 2 overloads

Aq_zeros

theta_stable_parabolics_max

theta_stable_parabolics_with 2 overloads

is_theta_x

is_coh_ind_from_finite_dimensional

is_good_range_induced_from

`induction.at`

`ind_verbose`

`embed_KGB`

`inverse_embed_KGB`

`makeS` 2 overloads

`rho_S` 2 overloads

`make_parabolic`

`real_Levi_of_posroots`

`real_Levi_of_cwt`

`real_Levi_of_span`

`is_real_Levi_for`

`real_Levi_shift`

`real_induce_standard`

`real_restrict`

`real_induce_standard`

`real_induce_irreducible_as_sum_of_standards`

`real_induce_irreducible_final`

`real_induce_irreducible`

`real_induce_is_irreducible`

`real_induce_irreducible_final_verbose`

`real_induce_irreducible_verbose`

`cuspidal_data`

`theta_stable_data`

`theta_stable_quasi_data`

`coherent_std_compact_Cartan`

`coherent_std_imaginary`

`standardize` 2 overloads

`is_good`

`is_weakly_good`

`project_on_center`

`is_fair`

`is_weakly_fair`

`goodness`

`theta_induce_standard`

`theta_induce_parampol`

`theta_induce_irreducible_as_sum_of_standards`

`theta_induce_irreducible_final`

`theta_induce_irreducible`

`map_into_distinguished_fiber`

`u`

`dim_u` 3 overloads

`dim_u_cap_k` 3 overloads

`dim_u_cap_p` 3 overloads

`dim_u_cap_k_2`

`dim_u_cap_k_ge2`

`dim_u_cap_p_ge2`

`dim_u_cap_k_1`

`dim_u_cap_p_1`

`find_N`

`theta_induce_irreducible_coherent`

`make_dominant`

`Aq_reducible`

`Aq` 4 overloads

`is_one_dimensional`

`is_unitary_character`

`is_good`

`is_weakly_good`

`is_fair`

`is_weakly_fair`

`goodness`

`is_good`

`is_weakly_good`

`is_fair`

`is_weakly_fair`

`goodness`

`Aq_packet` 2 overloads

`Aq_zeros`

`theta_stable_parabolics_max`

`theta_stable_parabolics_with` 2 overloads

`is_theta_x`

`is_coh_ind_from_finite_dimensional`

`is_good_range_induced_from`

`reduce_good_range`

`is_weakly_good_Aq`

`is_good_Aq`

`is_proper_Aq`

`all_real_induced_one_dimensional`

`two_rho_S` 2 overloads

`two_rho_u`

`two_rho_S` 2 overloads