Script File

`tits_centralizer.at`

Source

atlas-scripts/tits_centralizer.at (718 lines)

Definitions

Loads

Loaded by

none of the other all.at files

Definitions in source order

`to_base`

L7to_base (int n, (int->string) digit) = (int->string)

also defined in basic.at

`permutation_of_root_vectors`

L12permutation_of_root_vectors(WeylElt w) = mat

matrix of permutation action of w on all roots

`all_root_index` 2 overloads

L17all_root_index(RootDatum rd,vec alpha) = int

index of alpha in all roots

L19all_root_index(RootDatum rd) = (vec->int)

recall some notation from the Tits group
i simple index -> sigma_i lift of s_i to Tits group
w\in W -> sigma_w \in Tits group

L22

`simple_reflection_on_root_vector`

L36simple_reflection_on_root_vector(RootDatum rd, int i, int j)

action sigma_i\in Tits group on X_{alpha_j}
i=index of simple root
j=# of root alpha in list of all roots
let k=index of s_i(\alpha_i), then
sigma_i(X_alpha_j)=\pm X_k
the sign is given in Geck's paper; this
uses his construction of the X_alpha, but computing
the sign does not require the StructureConstantTable

`simple_reflection_on_root_vectors` 2 overloads

L51simple_reflection_on_root_vectors(RootDatum rd,int i,ratvec v) = ratvec

v=[x_0,x_1,...x_n] n=#roots -> \sum_i x_iX_{\alpha_i}
action of sigma_i in Tits group on sums of root vectors in these coordinates

L55simple_reflection_on_root_vectors(RootDatum rd,int i,CyclotomicVec v) = CyclotomicVec

`action_on_root_vectors` 4 overloads

L61action_on_root_vectors(RootDatum rd,[int] S,ratvec v) = ratvec

action of sigma_1...sigma_n in these coordinates

L65action_on_root_vectors(RootDatum rd,[int] S,CyclotomicVec v) = CyclotomicVec

action of sigma_1...sigma_n in these coordinates

L68action_on_root_vectors(WeylElt w,ratvec v) = ratvec

L71action_on_root_vectors(WeylElt w,CyclotomicVec v) = CyclotomicVec

`sign`

L75sign(WeylElt w,vec alpha)

sign: sigma_w(X_alpha)=\pm X_{w\alpha}

also defined in basic.at, coherent_irreducible.at

`tits_action`

L81tits_action(WeylElt w,LieAlgebraElement X) = LieAlgebraElement

action of sigma_w on LieAlgebraElement

also in this file at line 86

w acting on coweight

L83

`tits_action`

L86tits_action(WeylElt w,CFLieAlgebraElement X) = CFLieAlgebraElement

action sigma_w on LieAlgebraElement

also in this file at line 81

`torus_action`

L91torus_action(ratvec v,CFLieAlgebraElement X) = CFLieAlgebraElement

action of torus element t=exp(2\pi iv) on CFLieAlgebraelement

`*`

L103*(Tits_elt w,CFLieAlgebraElement X) = CFLieAlgebraElement

action of Tits group element w (including torus part) on
CFLieAlgebraElement X

also defined in basic.at, extParamPol.at, complex.at, modules.at, hodge_tensor.at, stable.at

boolean: sigma_w *weakly* fixes X:
w fixes the support of X

L107

`tits_centralizes_weak` 3 overloads

L111tits_centralizes_weak(WeylElt w,[vec] S) = bool

L114tits_centralizes_weak(WeylElt w,LieAlgebraElement X) = bool

L118tits_centralizes_weak(WeylElt w,CFLieAlgebraElement X) = bool

`tits_centralizer_weak` 11 overloads

L124tits_centralizer_weak([WeylElt] ws,[vec] S) = [WeylElt]

subset weakly fixing S

L128tits_centralizer_weak([WeylElt] S,LieAlgebraElement X) = [WeylElt]

w\in W(sub) weakly centralizing X

L133tits_centralizer_weak(LieAlgebraElement X)

w\in W weakly centralizing X

L136tits_centralizer_weak([WeylElt] S,CFLieAlgebraElement X) = [WeylElt]

w\in W(sub) weakly centralizing X

L140tits_centralizer_weak(CFLieAlgebraElement X)

w\in W weakly centralizing X

L143tits_centralizer_weak(LieAlgebraElement H,LieAlgebraElement X)

w\in W satisfying wH=H and weakly centralizing X

L149tits_centralizer_weak(CFLieAlgebraElement H,CFLieAlgebraElement X)

w\in W satisfying wH=H and weakly centralizing X

L155tits_centralizer_weak(CFLieAlgebraElement H,[vec] S)

w\in W satisfying wH=H and weakly centralizing X (CF case)

L161tits_centralizer_weak(RootDatum rd,ratvec H,[vec] S)

w\in W satisfying wH=H and weakly centralizing X

L169tits_centralizer_weak(StructureConstantTable t,ComplexNilpotent O)

assume the structure constant table is given
apply the previous to O.H

L173tits_centralizer_weak(ComplexNilpotent O)

same as previous, except construct the structure constant table

`spanning_subset`

L181spanning_subset(mat M) = (mat,[int],[int])

given a matrix M, whose columns span a Q-vector space,
choose a subset of the columns with the same span
return new matrix with these columns, list of indices
giving columns, and list of indices in complement

`map_root_of_unity` 2 overloads

L198map_root_of_unity(CyclotomicFieldElement z) = CyclotomicFieldElement

if F.order is odd replace F with E with E.order=2*F.order,
and replace zeta_n^k with zeta_{2n}^{2k}
this is needed in solve_for_torus_element

L217map_root_of_unity(CyclotomicVec v) = CyclotomicVec

apply previous to every entry of v

`promote` 2 overloads

L221promote(CyclotomicVec v) = CyclotomicVec

L226promote(CFLieAlgebraElement X) = CFLieAlgebraElement

`is_solvable_for_torus_element`

L239is_solvable_for_torus_element(mat M,CyclotomicVec v) = bool

want to solve ^M*w=v over CF(n)
v=[z_1,...,z_m] each z_i is an n^th root of unity in CF(n)
first compute spanning_subset(M)= (M_basis,indices_basis,indices_other)
is unique solution to M_basis*w=v_basis
 (v_basis is subset of coordinates of v)
then system is solvable iff:
for each j\in indices_other,
 v_j=\sum a_i v_i (v_i in M_basis)
 then condition is: z_j= \prod_i z_i^{a_i}

`solve_for_torus_element`

L287solve_for_torus_element(mat M, CyclotomicVec v) = (bool,ratvec)

find a torus element such that alpha_i(t)=zeta_i
where each zeta_i is an n^th root of 1
if n is odd the zeta_i can have -1 in them
(coming from signs in Tits action)
so have order 2n not n;
so first pass to CF(2n) in this case
ignore indices for which v[i]=0
include RootDatum to look up roots
v has length #roots of rd

write t=exp(2\pi iX)
alpha(t)=exp(2\pi i<alpha,X>)
zeta_i=exp(2\pi i(a/n))
so need to solve
exp(2\pi i<alpha,X>)=exp(2\pi ia/n)
i.e.
<alpha,X>=(a/n)mod(Z)

assumption: there is a subset of the columns of M
which span the same lattice (/Z) as M
this is true/Q, I think it is true here
because the columns are roots

algorithm:
first check is_solvable_for_torus_element
if this passes
spanning_subset(M)=(M_basis,indices_basis,indices_other)
M -> M_basis
v -> v_basis (only keep coordinates in indices_basis)
then M_basis is square and non-singular
solve M_basis*w'=v' (unique rational solution)
then remaining coordinates from indices_other,
given as explained in is_solvable_for_torus_element

`solve_for_torus_element_old`

L299solve_for_torus_element_old(mat M, CyclotomicVec v)

Jacobson Morozov triples L317

`JM_triple` 2 overloads

L324

JM_triple(StructureConstantTable t,vec H,[vec] S_roots,CyclotomicField F) = (bool,(CFLieAlgebraElement,CFLieAlgebraElement,CFLieAlgebraElement))

complete Jacobson Morozov triple: working over F=CF(m):
given H, find X,Y so that [H,X]=2X, [H,Y]=-2Y, [X,Y]=H
S is a set of roots (subset of \g_2(H))
coefficients of X are m^th powers of 1

L348JM_triple(StructureConstantTable t,ComplexNilpotent O,CyclotomicField F)

`JM_triple_one`

L351JM_triple_one(StructureConstantTable t,vec H,[vec] S_roots,[int] coeff,CyclotomicField F)

`JM_triples`

L381JM_triples(StructureConstantTable t,vec H,[vec] S_roots,CyclotomicField F,int number, int start)

same as previous but return a set of triples
stop is the number of tries

(bool,(CFLieAlgebraElement,CFLieAlgebraElement,CFLieAlgebraElement)):

Commented-out code, lines 405–413 (7 lines)

set JM_triple(StructureConstantTable t,vec H,CyclotomicField F)=
let S=for X in two_eigenspace(t,H) do embed(X,F) od in
JM_triple(t,H,S,F)

set JM_triples(StructureConstantTable t,vec H,CyclotomicField F,int number,int start)=
let S=for X in two_eigenspace(t,H) do embed(X,F) od in
JM_triples(t,H,S,F,number,start)

`solve_for_tits_element`

L418solve_for_tits_element(WeylElt w,CFLieAlgebraElement X)

find a single Tits element g=t*sigma_w so that g.X=X

`make_coords`

L444make_coords(int N, int modulus, int size)

`inverse_make_coords`

L449inverse_make_coords([int] v,int modulus)

`JM_triple_strong` 3 overloads

L453

JM_triple_strong(StructureConstantTable t,vec H,[vec] S_roots,CyclotomicField F,WeylElt w,[int] start_vec, int tries) = (bool,CFLieAlgebraElement,CFLieAlgebraElement,Tits_elt)

-------------------------------------------------------------------

L481JM_triple_strong(StructureConstantTable t,ComplexNilpotent O,CyclotomicField F,WeylElt w,int tries)

L489

JM_triple_strong(StructureConstantTable t,vec H,[vec] S_roots,CyclotomicField F,[WeylElt] ws,[int] start_vec, int tries) = (bool,CFLieAlgebraElement,CFLieAlgebraElement,[Tits_elt])

same but with a set of Weyl group elements

`new_order`

L575new_order(Tits_elt g) = int

{-------------------------------------------------------------------}
{also try to lift w}
set JM_triples_strong_old(StructureConstantTable t,vec H,[vec] S,CyclotomicField F,WeylElt w,[int] start_vec, int tries)={(bool,(CFLieAlgebraElement,CFLieAlgebraElement,CFLieAlgebraElement)):}
let zeta=F.primitive_root then
S_coords=for alpha in S do embed(coordinates(t.root_datum,alpha),F) then
N=#S {length of vectors} then
start=inverse_make_coords(start_vec,F.order) in
or i:tries  do let
A=make_coords(start-i,F.order,N) then
()=prints(new_line,"i:",i, " ",A) in
 let v=null(N,F) then
 ()= for i:#S do v+:=zeta^A[i]*S_coords[i]   od
then
 adx=ad(X) then
 sol=full_solve(ad(X),coordinates(H(t,H,F))) in
 let ()= if (can(sol)) then prints("solved for X") else prints("failed to solve for X") fi in
 if can(sol) then
  let  (success,v)=solve_for_tits_element(w,X) in
   if success then prints("SUCCESS i:", i, " ","coeff: ", A);[v] else prints("w-condition failed");[] fi fi od


set jump=137
{also try to lift [w]}
{
set JM_triples_strong(StructureConstantTable t,vec H,[vec] S_roots,CyclotomicField F,[WeylElt] ws,[int] start_vec, int tries)={(bool,(CFLieAlgebraElement,CFLieAlgebraElement,CFLieAlgebraElement)):}
let zeta=F.primitive_root then
S=for alpha in S_roots do lie_algebra_element_root_vectors(t,embed(coordinates(t.root_datum,alpha),F)) od then
N=#S {length of vectors} then
start=inverse_make_coords(start_vec,F.order) in
for i:tries do let
A=make_coords(start-jump*i,F.order,N) then
()=prints(new_line,"i:",i, " ",A) then
X_vec=null(t,F).root_part then
 ()= for i:#S do X_vec+:=zeta^A[i]*S[i].root_part   od then
 X=lie_algebra_element_root_vectors(t,X_vec)
then
 adx=ad(X) then
 sol=full_solve(ad(X),coordinates(H(t,H,F))) in
  let ()= if (can(sol)) then prints("solved for X") else prints("failed to solve for X") fi in
 if can(sol) then
  let ()=prints("found Y") then
  results=[] then
  all_success=true in
  for w in ws do
   let (success,v,M)=solve_for_tits_element(w,X) in
   if success then prints("solved for w:",w); results#:=(w,v) else all_success:=false fi
  od;
  if all_success then prints("SUCCESS", "i:", i, "coeffs:", A);results else prints("w-condition failed");[] fi fi od
}

`basis_dual_lattice` 2 overloads

L578basis_dual_lattice(ratmat M) = ratmat

L579basis_dual_lattice(mat M) = ratmat

Commented-out code, lines 580–601 (21 lines)

{find Tits elements taking (H,X) to (H,X)
 run over w in W so that wH=H and sigma_w(X) weakly equals X
 if w=1, find all torus elements t so that Ad(t)X=X
 otherwise find a single torus element t so t\xsigma_w(X)=X
}
set tits_centralizer_generators(LieAlgebraElement H,LieAlgebraElement X)=
let S=tits_centralizer_weak(H,X) then
rv=[Tits_elt]:[] in
for w in S do
let ()=prints("doing w:",w) in
 if w.matrix=id_mat(w.root_datum.rank) then
  let M=image_lattice(X.support) then
  DM=basis_dual_lattice(M) in
  for v in to_rowrowrat(DM) do  rv#:=(X.root_datum,ratvec:v,id_mat(X.root_datum.rank)) od
 else
 let (success,g)=solve_for_tits_element(w,X) in
 if success then  rv#:=g fi fi od;
rv


subgroup of Tits group generated by S

`find`

L603find([Tits_elt] S,Tits_elt g)

also defined in basic.at

`tits_subgroup`

L605tits_subgroup([Tits_elt] S) = [Tits_elt]

Commented-out code, lines 621–718 (97 lines)

{subgroup of Tits group centralizing (H,X)}
set tits_centralizer(LieAlgebraElement H,LieAlgebraElement X)=
tits_subgroup(tits_centralizer_generators(H,X))

{subgroup of Tits group centralizing (H,X)}
set tits_centralizer(StructureConstantTable t,ComplexNilpotent O)=
let (,(H,X,))=JM_triple_signs(t,O) in
tits_centralizer(H,X)

set find([vec] S,vec alpha)=first(for i:#S do alpha=S[i] od)

{orbits of w acting on subset of S, assumed to
be stabilized by w (or else an error)}
set orbits([vec] S,WeylElt w)=[[vec]]:
let rv=[] then
done=[vec]:[] in
while(#done<#S) do
 let j=first(for alpha in S do find(done,alpha)=-1 od) then
 alpha=S[j] then
 new_orbit=[alpha] then
 orbit_done=false in
 while (orbit_done=false) do
  let beta=w*(new_orbit~[0]) in
  if beta=alpha then
   rv#:=new_orbit;done##:=new_orbit;orbit_done:=true
    else
   new_orbit#:=beta
  fi
 od
od;
rv

set choices([vec] S,WeylElt w)=[[vec]]:orbits(S,w)

set choices(vec H,WeylElt w)=[[vec]]:
let S=two_eigenspace(w.root_datum,H) in orbits(S,w)
{
set make_vectors_from_choices(WeylElt w, [[vec]] choices)=
let all=##c then
rd=w.root_datum then
N=#rd.roots then
rv=[vec]:[] in
for orbit in choices do
 let alpha_0=orbit[0] then
 v=null(N) in
 for alpha in orbit do
  let sign=sign(w,alpha_0) in
  v+:=sign*coordinates(rd,alpha) od;
 rv#:=v
od;
rv

set combine_vectors_from_choices([vec] vectors)=
if #vectors=0
 then []
else
 let N=#vectors[0] {size of vectors} then
 n=#vectors {number of vectors} then
 shift=for i:n do 1 od then
 coeffs=for v in box(2,n) do 2*v-shift od in
 for c in coeffs do
   let w=null(N) in
   for i:#c do
   w+:=c[i]*vectors[i] od;w
 od
fi

set make_choices(vec H,WeylElt w)=
let c=choices(H,w) then
m=make_vectors_from_choices(w,c) in
combine_vectors_from_choices(m)

set list([vec] S,WeylElt w)=void:
for alpha in S do prints(alpha," ", index(alpha,rd), " ", w*alpha, "  ",index(w*alpha,rd)," ", sign(w,alpha), " ", sign(w,w*alpha)) od

set list(LieAlgebraElement X,WeylElt w)=void:list(X.support,w)



set good_roots([vec] S,WeylElt w)=
let orbits=orbits(S,w) then
rv=[] in
for orbit in orbits do
 if #orbits=1
  then rv#:=[orbit]
 else
  let base_sign=sign(w,orbit[0]) in
  if  all(for i:#orbit do base_sign=sign(w,orbit[i]) od) then rv#:=[orbit] fi
 fi
od;##(##rv)


set good_roots(vec H,WeylElt w)=
let two_roots=two_eigenspace(w.root_datum,H) in good_roots(two_roots,w)


}

Generated from atlas-scripts at commit 7e1b958 (2026-09-17).

tits_centralizer.at

Definitions in source order

to_base

permutation_of_root_vectors

all_root_index 2 overloads

simple_reflection_on_root_vector

simple_reflection_on_root_vectors 2 overloads

action_on_root_vectors 4 overloads

sign

tits_action

tits_action

torus_action

*

tits_centralizes_weak 3 overloads

tits_centralizer_weak 11 overloads

spanning_subset

map_root_of_unity 2 overloads

promote 2 overloads

is_solvable_for_torus_element

solve_for_torus_element

solve_for_torus_element_old

Jacobson Morozov triples L317

JM_triple 2 overloads

JM_triple_one

JM_triples

solve_for_tits_element

make_coords

inverse_make_coords

JM_triple_strong 3 overloads

new_order

basis_dual_lattice 2 overloads

find

tits_subgroup

`tits_centralizer.at`

`to_base`

`permutation_of_root_vectors`

`all_root_index` 2 overloads

`simple_reflection_on_root_vector`

`simple_reflection_on_root_vectors` 2 overloads

`action_on_root_vectors` 4 overloads

`sign`

`tits_action`

`tits_action`

`torus_action`

`*`

`tits_centralizes_weak` 3 overloads

`tits_centralizer_weak` 11 overloads

`spanning_subset`

`map_root_of_unity` 2 overloads

`promote` 2 overloads

`is_solvable_for_torus_element`

`solve_for_torus_element`

`solve_for_torus_element_old`

`JM_triple` 2 overloads

`JM_triple_one`

`JM_triples`

`solve_for_tits_element`

`make_coords`

`inverse_make_coords`

`JM_triple_strong` 3 overloads

`new_order`

`basis_dual_lattice` 2 overloads

`find`

`tits_subgroup`