Atlas of Lie Groups and Representations

Documentation contents

atlas Library · Script File

translate.at

Source
atlas-scripts/translate.at (233 lines)
Definitions
18
Loads
Loaded by
stable.at coherent.at

Definitions in source order

translate_debug

L3translate_debug = false
various versions of the Zuckerman translation principle
mainly staying within a Weyl chamber (for the integral roots)
L5

translate_param_by 2 overloads

L10translate_param_by (Param p, vec shift) = Param
translation of parameters
L14translate_param_by (ParamPol P, vec shift) = ParamPol
translate a |ParamPol| by translating each term
Problem: can't put non-standard Param in a ParamPol
L16

T_param 2 overloads

L20T_param (Param p, ratvec gamma_target) = Param
translate to infinitesimal character |gamma_target|, must lie in $\gamma+X^*
the result is a Param, possibly non-final, non-standard, or zero
L27T_param (ParamPol P, ratvec gamma_target) = ParamPol
T_param of ParamPol of parameters, assuming each term has the
same infinitesimal character
translation of standard modules
L36
recall p.final => p.normal => p.is_dominant
(infinitesimal character is (weakly) dominant for all positive roots
L38
translation of irreducible or standard modules is only reasonable
if the target is at least as singular as the origin, in other
words the target is not_less_singular
L41

is_not_less_singular

L45is_not_less_singular(RootDatum rd,ratvec gamma,ratvec gamma_target) = bool
T_std(p,gamma_target) is only defined if p.is_dominant
(recall final => normal => is_dominant, but p.is_standard does not imply p.is_dominant)
and target is integrally dominant
L49

T_std 3 overloads

L54T_std(Param p,ratvec gamma_target) = ParamPol
L61T_std (ParamPol P, ratvec gamma_target) = ParamPol
translate a |ParamPol| by translating each term
L66T_std (ParamPol P, ratvec gamma_target) = ParamPol
T_param of ParamPol of parameters, assuming each term has the
same infinitesimal character
irreducible module is non-zero when translated to a wall,
needed for T_irr
L73

I_will_survive

L80I_will_survive (Param p,ratvec gamma) = bool
corrected version handles non-integral infinitesimal character
whether translation of irreducible parameter p to gamma is non-zero
the name is too cute to change, but |J_will_survive| would be more accurate
no singular simple descents of integral subsystem
L83
translation of irreducible modules
L85
T_irr(p,gamma_target) is only defined if p.infinitesimal_character is
 dominant (for example if p is final) and gamma_target is integrally dominant
dominant condition avoid things like: parameter(KGB(G,2),[1],[-1/2])
for SL(2,R). This is integrally dominant but not dominant, and
putting it in a ParamPol automatically converts it to (KGB(G,2)),[1],[1/2])
L86

T_irr

L95T_irr (Param p,ratvec gamma_target) = ParamPol
translation functor of irreducible; returns |ParamPol| with at most one term
gamma_target must at least as singular and integrally dominant
with at most 1 term

also in this file at line 113

check: translate param(KGB(G,2),[1],[1/2])  -> -1/2: non-dominant gets made dominant
L102
Question: if p is not standard then trouble - allow this?
L103

T_irr_nonzero

L106T_irr_nonzero (Param p,ratvec v) = Param
return an actual Param if nonzero

T_irr

L113T_irr (ParamPol P, ratvec gamma_target) = ParamPol
translate a ParamPol of irreducibles by translating each term by the same shift

also in this file at line 95

to_wall

L123to_wall (RootDatum id, int k, ratvec gamma) = ratvec
weight such that shift by its negative sends |gamma| to integral wall |k|,
projecting parallel to all other walls

Psi_irr 3 overloads

L128Psi_irr (Param p, [int] S) = ParamPol
translate J(p) to intersection of set of simple root walls of integral system
get irreducible or 0
L138Psi_irr (ParamPol P,ratvec gamma,int k) = ParamPol
translate ParamPol of irreducibles, from assumed initial infinitesimal character |gamma| to the
root wall #k of the integral root system
L150Psi_irr (ParamPol P, [int] S) = ParamPol
translate ParamPol of irreducibles
to intersection of set of simple root walls of integral system
requirement: each term of P has same infinitesimal character, or get an error
from infinitesimal_character(P)

also defined in stable.at

Commented-out code, lines 157–163 (6 lines)
set Psi(ParamPol P,[int] v)= ParamPol:
let gamma=P.infinitesimal_character then
id = integrality_datum(root_datum(P),gamma) then
shift = - sum( rank(id) # for k in v  do to_wall(id,k,gamma) od ) then
rv= null_module(real_form(P))  in
 for w@q in P do rv+:=w*translate_by(q,shift) od;rv

make_regular_param

L172make_regular_param(Param p) = Param
translate an irreducible parameter from singular to regular
this is well defined, however it can happen that I(p)=I(p')
but p\ne p' (although they are equivalent), and
make_regular_irr(p)\ne make_regular_irr(p')
translate a ParamPol by translating each term
L174
the "pseudo-tau" invariant
L177
this is a subset of simple integral roots such that:
1) one can translate to this wall (i.e., the requisite translation is in X^*)
2) this translation is 0
If G is simply connected this should be the usual tau_invariant
Example: the trivial representation of SO(3), the unique simple root
is in the pseudo-tau invariant, but you can't translate to the wall,
since rho is not in the root lattice

root k of the integral roots is in pseudo-tau(p) if
<gamma,alpha_k^v>*fund_weight is integral, and
Psi(p,k)=0 or its x(Psi(p,k)) gets changed by finalize
(here Psi(p,k) is the translation of the standard module for p)
L178
Commented-out code, lines 191–213 (21 lines)
set pseudo_tau_bitset (Param p)= (int,(int->bool)):
  let gamma = infinitesimal_character(p)
  then id=integrality_datum(real_form(p),gamma)
  in
  ( semisimple_rank(id)
  , (int k): let (n,d)=%(fundamental_weight(id,k)*(coroot(id,k)*gamma))
    in d=1 and
      (let p0=first_param(translate_by_(p,-n))
       in is_zero(p0) or x(p0)!=x(first_param(ParamPol:p0)))
  )

{ set of integers, defining a subset of the simple integral roots }
set pseudo_tau (Param p) = [int]: list(pseudo_tau_bitset(p))

{ set of integers, defining a subset of the simple integral roots }
set pseudo_tau_complement (Param p)= [int]: complement(pseudo_tau_bitset(p))

{ push Param p to the most singular place where the irreducible is non-zero,
  i.e. to all of the root walls not in the pseudo_tau_invariant
}
set make_maximally_singular (Param p)= ParamPol: Psi(p,pseudo_tau_complement(p))
translate each term in a list of parameters to all the simple root walls
not in its tau_invariant, and test if it is unitary.
The even special unipotents of G should (all?) show up this way, varying
over all blocks at rho
L214
Commented-out code, lines 220–233 (13 lines)
set test_even_unipotent (Param p)= void:
( let q=make_maximally_singular(p)
  then Q=hermitian_form_irreducible(q)
  in
  prints(""); prints("original parameter: ",p)
; prints("translated parameter: ",q,", ", infinitesimal_character(q))
; prints("translated irreducible is unitary: ",is_unitary(Q))
; if translate_debug then prints(Q.pol_format) fi
)

{ test_even_unipotent of a list of parameters }
set test_even_unipotent ([Param] params)= void:
  for p in params do  test_even_unipotent(p) od

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