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 (1049 lines)

Definitions

103

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_induce_standard` 2 overloads

L127real_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) to G

L138real_induce_standard (ParamPol P,RealForm G) = ParamPol

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

`real_induce_irreducible_as_sum_of_standards`

L144real_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`

L153real_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`

L158real_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_irreducible_final_verbose`

L168real_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`

L176real_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

L184

`cuspidal_data`

L191cuspidal_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 L204

`theta_stable_data`

L210theta_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`

L228theta_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 L238

`coherent_std_compact_Cartan`

L245coherent_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`

L265coherent_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

L273standardize (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

L286standardize (ParamPol P) = ParamPol

standardize a formal linear combination of possibly non-standard parameters

also defined in good_W_representatives.at

`is_good`

L290is_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 694, line 731

`is_weakly_good`

L304is_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 699, line 745

`project_on_center`

L312project_on_center (ratvec v, RootDatum L) = ratvec

`is_fair`

L319is_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 704, line 756

`is_weakly_fair`

L334is_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 709, line 772

`goodness`

L351goodness (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 715, line 784

theta-stable parabolic induction L366

`theta_induce_standard`

L371theta_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`

L399theta_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`

L407theta_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`

L422theta_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`

L434theta_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

L441

`map_into_distinguished_fiber`

L444map_into_distinguished_fiber (KGBElt x) = KGBElt

`u`

L456u (KGBElt x) = mat

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

set of coroots

`dim_u` 3 overloads

L460dim_u(Parabolic P) = int

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

L463dim_u(KGBElt x) = int

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

L466dim_u (ratvec H,KGBElt x)

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

`dim_u_cap_k` 3 overloads

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

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

L480dim_u_cap_k (KGBElt x) = int

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

L484dim_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

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

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

L501dim_u_cap_p (KGBElt x) = int

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

L505dim_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`

L511dim_u_cap_k_2 (Parabolic P,ratvec H ) = int

(Auxiliary function)

a coweight

`dim_u_cap_k_ge2`

L522dim_u_cap_k_ge2 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_p_ge2`

L533dim_u_cap_p_ge2 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_k_1`

L544dim_u_cap_k_1 (Parabolic P,ratvec H) = int

(Auxiliary function)

`dim_u_cap_p_1`

L555dim_u_cap_p_1(Parabolic P, ratvec H)

(Auxiliary function)

alternative versions of theta_induce_irreducible L565

`find_N`

L567find_N (Param p_L,RealForm G) = int

also in this file at line 1023

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

L580

`theta_induce_irreducible_coherent`

L584theta_induce_irreducible_coherent (Param p, RealForm G) = ParamPol

moved to coherent_irreducible.at

L596

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

L597

Commented-out code, lines 602–625 (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 L626

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

L628

`make_dominant`

L635make_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`

L643Aq_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

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

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

L668Aq (KGBElt x,ratvec lambda) = Param

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

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

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

L676Aq(RealForm G,ratvec lambda) = Param

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

Good/Fair conditions L680

`is_one_dimensional`

L683is_one_dimensional(Param p) = bool

Decide whether a parameter defines a one-dimensional representation.

`is_unitary_character`

L687is_unitary_character(Param p) = bool

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

`is_good`

L694is_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 290, line 731

`is_weakly_good`

L699is_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 304, line 745

`is_fair`

L704is_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 319, line 756

`is_weakly_fair`

L709is_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 334, line 772

`goodness`

L715goodness(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 351, line 784

`is_good`

L731is_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 290, line 694

`is_weakly_good`

L745is_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 304, line 699

`is_fair`

L756is_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 319, line 704

`is_weakly_fair`

L772is_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 334, line 709

`goodness`

L784goodness (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 351, line 715

`Aq_packet` 2 overloads

L800Aq_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.

L809Aq_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 811–813 (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`

L817Aq_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`

L824theta_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

L832theta_stable_parabolics_with(KGBElt x) = [Parabolic]

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

L839theta_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`

L846is_theta_x(KGBElt x) = bool

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

`is_coh_ind_from_finite_dimensional`

L849is_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`

L856is_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`

L878reduce_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`

L899is_weakly_good_Aq(Param p) = bool

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

`is_good_Aq`

L904is_good_Aq(Param p) = bool

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

`is_proper_Aq`

L909is_proper_Aq(Param p) = bool

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

`all_real_induced_one_dimensional`

L914all_real_induced_one_dimensional (RealForm G) = [Param]

some rho-shifts involving theta L919

define "two" versions which are vecs

L921

`two_rho_S` 2 overloads

L923two_rho_S(KGBElt x) = vec

L925two_rho_S ((mat,RootDatum) pair)

also in this file at line 936, line 944

`two_rho_u`

L927two_rho_u(Parabolic P) = vec

`two_rho_S` 2 overloads

L936two_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

L944two_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 923, line 925

`rho_u_cx`

L947rho_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)

L950

`rho_u_cx_T`

L963rho_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`

L968rho_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`

L981two_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`

L994two_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`

L1003twist_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`

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

`select_class_terms_from_ParamPol`

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

`p_N`

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

`move_P_down_by_N`

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

`find_N`

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

also in this file at line 567

`is_standard`

L1032is_standard ([int] Levi, Param p)

`is_final`

L1035is_final ([int] Levi, Param p)

`induce_from_gen_parabolic_irr`

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

`L_infinitesimal_character`

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

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

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_induce_standard 2 overloads

real_induce_irreducible_as_sum_of_standards

real_induce_irreducible_final

real_induce_irreducible

real_induce_irreducible_final_verbose

real_induce_irreducible_verbose

cuspidal_data

theta-stable data L204

theta_stable_data

theta_stable_quasi_data

standardize L238

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 L366

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 L565

find_N

theta_induce_irreducible_coherent

some representations L626

make_dominant

Aq_reducible

Aq 4 overloads

Good/Fair conditions L680

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

some rho-shifts involving theta L919

two_rho_S 2 overloads

two_rho_u

`induction.at`

`ind_verbose`

`embed_KGB`

`inverse_embed_KGB`

`makeS` 2 overloads

`rho_S` 2 overloads

`make_parabolic`

`real_induce_standard` 2 overloads

`real_induce_irreducible_as_sum_of_standards`

`real_induce_irreducible_final`

`real_induce_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

`rho_u_cx`

`rho_u_cx_T`

`rho_u_ic`

`two_rho_u_cap_k`

`two_rho_u_cap_s`

`twist_by_minus_2rho_u_cap_s`

`is_in_list`

`select_class_terms_from_ParamPol`