Documentation contents

atlas Library · Script File

parameters.at

various ways of defining parameters
Source
atlas-scripts/parameters.at (220 lines)
Definitions
32
Loads
Loaded by
galois.at stable.at synthetic.at nilpotent_orbits.at Vogan-dual.at extended_misc.at extended.at dual.at

Definitions in source order

unnormalized_torus_factor

L17unnormalized_torus_factor (KGBElt x) = ratvec
torus_factor, aka "normalized torus factor", is $\theta$-fixed,
$\xi=\exp_1(torus_factor/2)\exp_1(\rho^\vee/2)\sigma_w\xi_0$ where
$\exp_1(t)=\exp(2\pi i t)$ is the "base 1 exponential function"; note
"over 2" in those $\exp_1$ terms, Marc writes $\exp_{-1}(x)=\exp(\pi ix)$
instead, for which $\xi=\exp_{-1}(torus_factor+\rho^\vee)\sigma_w\xi_0$.
Jeff prefers $\xi=exp_1(unnormalized_torus_factor)\sigma_w\xi_0$
Therefore:
 |unnormalized_torus_factor=(torus_factor+rho^\vee)/2|
 |torus_factor=2*unnormalized_torus_factor-rho^\vee|
NOTE: result of |unnormalized_torus_factor| is not $\theta-fixed$
probably better not to use |unnormalized_torus_factor|

also defined in synthetic.at

square_unnormalized

L27square_unnormalized ( InnerClass ic,mat theta,ratvec unnormalized_torus_factor) = ratvec
compute xi^2 and test if it is central
this is formula when v= unnormalized_torus_factor
xi=exp(2\pi iv)\sigma_w\xi_0
xi^2=exp(2\pi i[(1+^theta)*v+(1-^theta)*rho^v/2]
    =v*(1+theta)+rho^v*(1-theta)/2
    =rho^v + (2*v-rho^v)*(1+theta)/2

square_normalized

L31square_normalized (InnerClass ic,mat theta,ratvec torus_factor) = ratvec

square

L37square = square_normalized@(InnerClass,mat,ratvec)
for valid arguments one should have
square(ic,theta,tf)=square(real_form(ic,theta,tf))

also in this file at line 42, line 43; also defined in synthetic.at

square2

L38square2 (InnerClass ic,mat theta,ratvec tf) = ratvec
this should always be twice |square|

square 2 overloads

L42square (RealForm G) = ratvec
the following is the same as central_cocharacter@RealForm in Vogan-dual.at
L43square (KGBElt x) = ratvec

also in this file at line 37; also defined in synthetic.at

square_is_central

L48square_is_central (InnerClass ic,mat theta,ratvec tf) = bool
tf=normalized torus_factor: xi=exp(\pi i(tf\rho^v))\sigma_w\xi_0
so square_is_central(ic,theta(x),torus_factor(x)) should always be true

also defined in synthetic.at, extended_misc.at

parity

L52parity (Param p,vec alpha_hat) = bool
parity condition

dual_inner_class

L60dual_inner_class (Param p) = InnerClass
to compute y values over a block of parameters, precompute dual inner class
Removing things related to duality, see Vogan-dual.at
L64
In duality, y is a KGBElt for G^\vee(gamma), but only its torus factor as a
generalized KGB element for G^\vee is what is easily computed, namely as
infinitesimal_character(p)-lambda(p). To correctly compute a corresponding
true KGB element under the embedding of G^\vee(gamma) into G^\vee is quite
difficult. The code below tries to obtain a vector giving the correct
grading by first computing the vector that would directly give the grading
for G^\vee (by adding rho_r(x)), and then subtracting the similar difference
|dual_shift| between grading vector and torus_factor for G^\vee(gamma).

However this correction is not always by an element of X^*, so that the
value of square(y) need not be what it should be, and the construction of a
KGB_elt may consequently fail with "Not a valid strong involution" error.

A probably more successful attempt is in Vogan-dual.at:  dual_KGB and y_alt.
L66
Commented-out code, lines 81–87 (5 lines)
set y (Param p, InnerClass G_vee) = KGBElt:
  let x = x(p) then dual_theta = -^involution(x)
  then grading_vector = infinitesimal_character(p) - lambda(p) + rho_r(x)
  , dual_shift = rho_check_i(G_vee,dual_theta)/2
  in KGB_elt(G_vee,dual_theta,grading_vector-dual_shift)
caution: this function builds an inner class on the fly; if called multiple
times even with the same argument, the results will be incompatible
L88

lambda 2 overloads

L92lambda (ratvec gamma,mat theta,KGBElt y) = ratvec
L97lambda (ratvec gamma,KGBElt x,KGBElt y) = ratvec

also defined in basic.at

nu 2 overloads

L100nu (ratvec gamma,KGBElt x) = ratvec
L101nu (ratvec gamma,KGBElt x,KGBElt y) = ratvec
allow unused y

also defined in basic.at, extended.at

make_regular

L105make_regular (RootDatum rd, ratvec v) = ratvec
sometimes gamma returned by y^2 is not regular, need to make it regular

also defined in stable.at

choose_g 3 overloads

L113choose_g (RealForm G, RootDatum dual_integral) = ratvec
choose infinitesimal character appropriate for dual parameter
L116choose_g (KGBElt x, KGBElt y) = ratvec
L128choose_g (Param p) = ratvec

tits

L132tits(KGBElt x) = Tits_elt
contragredient of a parameter

KGB_elt

L133KGB_elt (Tits_elt t)

also defined in basic.at, synthetic.at

inverse

L134inverse(KGBElt x)

also defined in basic.at, combinatorics.at, ratmat.at, tits.at, affine.at, cyclotomic.at, Gaussian_elim.at, cyclotomic_Gaussian_elim.at, lazy_lists.at

contragredient

L142contragredient(Param p) = Param
contragredient: (x,lambda,nu) -> (w_0\times x,-w_0\lambda,-w_0\nu)
sketch: the contragredient is given by the Chevalley involution (of the real group)
which acts by -1 on lambda,nu, but keeps the same x (it doesn't change the "group")
-lambda,-nu are in the wrong chamber (for our fixed parabolic), so use w_0 (the long
element of the Weyl group)

parameter 2 overloads

L146parameter (KGBElt x,KGBElt y,ratvec gamma) = Param
gamma=infinitesimal character to combine with x, found from real_form(y)
final argument gamma would work
L150parameter (KGBElt x, KGBElt y) = Param
the next function used to be wrong, with choose_g(x,y) instead
computes gamma from real_form(y), x-dominant

also defined in basic.at, L_packet.at, K.at, extended_misc.at

is_subset

L154is_subset([Param] A,[Param] B) = bool
A is a subset of B

also defined in basic.at

is_proper_subset

L158is_proper_subset([Param] A,[Param] B) = bool
A is a proper subset of B

also defined in misc.at

complement

L162complement([Param] A,[Param] B) = [Param]
complement of A in B

also defined in basic.at, misc.at

param_pol 2 overloads

L166param_pol ([Param] params,RealForm G) = ParamPol
turn [Param] into a ParamPol
L170param_pol ([Param] params) = ParamPol
turn [Param] into a ParamPol; error if #params=0

also defined in basic.at

remove_duplicates

L176remove_duplicates([Param] list) = [Param]
replace [Param] with list with multiplicity one
uses properties of ParamPols

also defined in restricted_roots.at, nilpotent_orbits.at, disconnected.at

compare

L180compare([Param] A_in,[Param] B_in)
compare two lists of parameters

compare_long

L193compare_long([Param] A_in,[Param] B_in)
see Vogan-dual.at
L205
this gives a parameter for the dual group with infinitesimal character g
L206
Commented-out code, lines 207–211 (3 lines)
set dual_parameter (KGBElt x, KGBElt y,ratvec g) = Param: parameter(y,x,g)
set parameter_pair (KGBElt x, KGBElt y,ratvec gamma,ratvec g) = (Param,Param):
(parameter(x,y,gamma), dual_parameter(x,y,g))
shift (up) a candidate dual infinitesimal character to strictly dominant
L213
Commented-out code, lines 214–220 (5 lines)
set shift_g_regular (RootDatum rd, ratvec g) = ratvec:
  for alpha@i in simple_roots(rd)
  do let (v,d) = %fundamental_coweight(rd,i)
     in g +:= (1-ceil(g*alpha/d)) * v
  od; g

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