atlas Library · Script File

`affine.at`

<outer.at

Source

atlas-scripts/affine.at (367 lines)

Definitions

Loads

Loaded by

all_finite_order.at good_W_representatives.at twisted_root_datum.at

Definitions in source order

`cutoff`

L10cutoff = 10000

terminate calculation after cutoff steps

`affine_verbose`

L12affine_verbose = false

`highest_short_roots`

L16highest_short_roots(RootDatum rd) = [vec]

highest short roots, obtained as dual to highest root of the dual

`highest_short_root`

L19highest_short_root(RootDatum rd) = vec

from basic.at:
reflect: left action of root on X^* (add multiple of root)
coreflect: right action of root on X_* (add multiple of coroot)

L23

Affine root datum: (vec alpha^v,RootDatum rd,vec alpha)
 alpha should be a positive root, and alpha^v the
 corresponding coroot
 this acts on either X^* or X_* (\otimes Q)
 in this file:
  wt will always be an element of X^*\otimes Q
  cwt will always be an element of X_*\otimes Q

 Action on X_*: affine reflection is

 cwt -> s_alpha(cwt)+\alpha^v
	=cwt-<cwt,alpha>alpha^v + alpha^v
	=cwt-(<cwt,alpha>-1)alpha^v

 Action on X^*: affine reflection is

 wt ->  s_alpha(wt)+\alpha
	=wt-<wt,alpha^v>alpha + alpha
	=wt-(<gamma,alpha^v>-1)alpha

L28

`AffineDatum` type

L49

set_type AffineDatum = ([vec]  affine_coroots,RootDatum rd,[vec] affine_roots)

Fields: affine_coroots, rd, affine_roots

`rank`

L50rank(AffineDatum ad) = int

also defined in basic.at, combinatorics.at, sommers.at, character_tables.at

`ss_rank`

L51ss_rank(AffineDatum ad) = int

also defined in misc.at

`is_simple`

L52is_simple(AffineDatum ad) = bool

also defined in basic.at

`is_one_factor` 2 overloads

L53is_one_factor(RootDatum rd) = bool

L54is_one_factor(AffineDatum ad) = bool

`number_factors`

L56number_factors(AffineDatum ad) = int

`affine_root_sum`

L57affine_root_sum(AffineDatum ad)

`affine_coroot_sum`

L58affine_coroot_sum(AffineDatum ad)

an affine root datum ad is obtained by "folding" from a pair
(root datum,distinguished automorphism)=(rd,delta)

each delta orbit of simple factors of rd contributes a single
simple factor of ad

1) delta trivial on a simple factor rd_i ->
 -> (rd_i, highest long root)
    folding_order =1
2) order delta=2 or 3 on a simple factor rd_i ->
 -> (folded(rd_i), highest short root)
     folding_order =2 or 3
3) delta permutes r simple factors rd_f
   delta^r is an automorphism of the first one, of order 1,2,3
   apply 1 or 2 to (rd_i,delta^r)
   folding_order = 1,2 or 3 accordingly

L60

basic affine datum uses highest root, folding_order=1
other affine data come from an automorphism of
a simple root system rd_0 of order 2 or 3,
in which case the underlying root datum rd is the
"folded" one, and the affine root is the highest short
 root. In this case the order of the fold is
 ||highest root rd||/||highest short root of rd||
Conclusion: the order of the fold is always:
||highest root of rd||/||affine_root of rd||

L77

`folding_order`

L88folding_order(AffineDatum ad) = int

`folding_orders`

L94folding_orders(AffineDatum ad) = [int]

apply folding_order to each simple factor

`AffineWeylElt` type

L106

set_type AffineWeylElt = (AffineDatum ad, [int] w)

Fields: ad, w

the affine reflections are labeled -1,-2,...

`inverse`

L108inverse(AffineWeylElt omega) = AffineWeylElt

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

`affine_datum` 2 overloads

L111affine_datum(RootDatum rd,vec alpha) = AffineDatum

make affine datum from a root, simple case

L116affine_datum(RootDatum rd) = AffineDatum

default affine datum, simple case: use the highest root

also defined in twisted_root_datum.at

default affine datum general case:

L120

bad definition, see twisted_root_datum.at

L121

Commented-out code, lines 122–125 (3 lines)

set affine_datum(RootDatum rd)=AffineDatum:
let hr=highest_roots(rd) in
AffineDatum:(for alpha in hr do coroot(rd,alpha) od,rd,hr)

`reflect` 6 overloads

L131reflect((AffineDatum ad, vec beta), ratvec wt) = ratvec

ordinary reflections
beta is a root, acting on from left on X^* or from right on X_*

Note: need the extra parentheses here to avoid ambiguity

L133reflect((AffineDatum ad, int i), ratvec wt) = ratvec

L135reflect(AffineDatum ad) = ((vec,ratvec)->ratvec)

L137reflect(AffineDatum ad) = ((int,ratvec)->ratvec)

L140reflect(ratvec cwt,(AffineDatum ad, vec beta)) = ratvec

action from right implies coreflection, even though calling it |reflect|

L142reflect(ratvec cwt,(AffineDatum ad, int i)) = ratvec

also defined in basic.at

`coreflect` 4 overloads

L146coreflect(ratvec cwt, (AffineDatum ad, vec beta)) = ratvec

or you can call it |coreflect|, but always write acting value on the right

L148coreflect(ratvec cwt, (AffineDatum ad, int i)) = ratvec

L150coreflect(AffineDatum ad) = ((ratvec,vec)->ratvec)

L152coreflect(AffineDatum ad) = ((ratvec,int)->ratvec)

also defined in basic.at

affine reflections

L155

`affine_reflect` 2 overloads

L158affine_reflect (AffineDatum ad,int i,ratvec wt) = ratvec

affine reflection on X^*: i is the number of the simple factor

L161affine_reflect(AffineDatum ad) = ((int,ratvec)->ratvec)

`affine_coreflect` 2 overloads

L165affine_coreflect (ratvec cwt,AffineDatum ad,int i) = ratvec

affine (co)reflection on X_*

L168affine_coreflect (AffineDatum ad) = ((ratvec,int)->ratvec)

`labels`

L177labels(AffineDatum ad)

labels: defined for an affine datum,
multiplicity of each simple root in affine root(s)
more than one affine root: all multiplicities are 0 except 1
compute this by taking the <sum of affine roots,fundamental_coweight[i]>

`co_labels`

L178co_labels(AffineDatum ad)

`affine_labels`

L179affine_labels(AffineDatum ad) = vec

`co_affine_labels`

L180co_affine_labels(AffineDatum ad) = vec

for plain RootDatum, use |simple_root_labels| (or coroot) from basic.at

L182

`reflect_or_affine_reflect`

L188reflect_or_affine_reflect ((AffineDatum ad,int i), ratvec wt) = ratvec

ordinary or affine reflection acting on X^*, indexed by integers
0<= i <ss_rank(rd): ordinary reflection
ss_rank(rd) <= i < ss_rank(rd)+r: affine reflections

`coreflect_or_affine_coreflect`

L201coreflect_or_affine_coreflect (ratvec cwt,(AffineDatum ad,int i)) = ratvec

ordinary or affine coreflection acting on X_*

`coreflect_or_coaffine_reflect`

L207coreflect_or_coaffine_reflect (AffineDatum ad) = ((ratvec,int)->ratvec)

`affine_coordinates` 7 overloads

L221affine_coordinates (AffineDatum ad, ratvec wt) = (ratvec,ratvec)

wt\in X^*\otimes Q
affine coordinates: a pair (v,w) of ratvecs
v=[a_0,...,a_{n-1}]
n=semisimple rank, a_i=inner product with simple coroot
w=[b_0,...,b_{r-1}]
r=#simple factors
b_i=<affine_coroots[i],lambda>-1/folding_orders[i]
\sum_{i=0}^{n-1} a_i +\sum_{j=0}^{r-1}b_j=r
fundamental alcove: [a_0,...,a_{n-1}],[b_0,...,b_{r-1}]
0\le a_i,b_j\le 1  all i,j

L228affine_coordinates(RootDatum rd, ratvec wt) = (ratvec,ratvec)

default affine coordinates

L231affine_coordinates(AffineDatum ad, vec wt) = (vec,vec)

in case of vec argument, return vec result

L234affine_coordinates(RootDatum rd, vec wt) = (vec,vec)

L237affine_coordinates(ratvec cwt,AffineDatum ad) = (ratvec,ratvec)

affine coordinates: X_*\otimes Q case

L243affine_coordinates(vec cwt,AffineDatum ad) = (vec,vec)

L247affine_coordinates(vec cwt,RootDatum rd) = (vec,vec)

`confirm` 2 overloads

L253confirm(AffineDatum ad,ratvec coordinates) = void

test:
affine_coordinates(ad,wt)*co_affine_labels(ad)=1
affine_coordinates(cwt,ad)*affine_labels(ad)=1

L256confirm(ratvec coordinates,AffineDatum ad) = void

`in_fundamental_alcove` 2 overloads

L259in_fundamental_alcove(AffineDatum ad,ratvec wt) = bool

L262in_fundamental_alcove(ratvec cwt,AffineDatum ad) = bool

`affine_non_dominant_index`

L271affine_non_dominant_index (AffineDatum ad, ratvec wt) = int

wt\in X^* \otimes Q

v=[a_1,...,a_n] n=ss_rank
w=[b_1,...,b_r] r=#simple_factors
v##w=[a_1,...,a_n,b_1,...,b_r]
     [0, ,...,n-1,n,..., ,n+r-1]  (indices from 0 to n+r-1)

also in this file at line 276

`is_affine_dominant`

L273is_affine_dominant(AffineDatum ad,ratvec wt) = bool

also in this file at line 278

`affine_non_dominant_index`

L276affine_non_dominant_index (ratvec cwt,AffineDatum ad) = int

cwt case

also in this file at line 271

`is_affine_dominant`

L278is_affine_dominant(ratvec cwt,AffineDatum ad) = bool

also in this file at line 273

`affine_make_dominant`

L281affine_make_dominant (AffineDatum ad, ratvec wt) = (ratvec,AffineWeylElt)

wt\in X^* \otimes Q

`affine_co_make_dominant` 2 overloads

L301affine_co_make_dominant (AffineDatum ad,ratvec cwt) = (ratvec,AffineWeylElt)

wt\in X_* \otimes Q

L319affine_co_make_dominant (AffineDatum ad) = (ratvec->ratvec,AffineWeylElt)

Commented-out code, lines 322–347 (23 lines)

set *(AffineWeylElt omega,ratvec v)=ratvec:
for i in reverse(omega.w) do
v:=reflect_or_affine_reflect(omega.ad,i,v) od;v

set *(ratvec v,AffineWeylElt omega)=ratvec:
for i in reverse(omega.w) do
v:=reflect_or_affine_reflect(omega.ad,i,v) od;v

{to be consistent with other naming conventions in basic.at}

{v \in X^* \otimes Q, returns (w,omega) such that omega*w=v}
set affine_from_dominant(AffineDatum ad, ratvec wt)=(ratvec,AffineWeylElt):
affine_make_dominant(ad,wt)

set affine_dominant(AffineDatum ad, ratvec wt)=ratvec:
let (v,)=affine_from_dominant(ad,wt) in v

{v \in X_* \otimes Q, returns (w,omega) such that omega*w=v}
set affine_from_dominant(ratvec cwt,AffineDatum ad)=(ratvec,AffineWeylElt):
affine_make_dominant(ad,cwt)

set affine_dominant(ratvec cwt,RootDatum rd)=ratvec:
let (v,)=affine_from_dominant(cwt,affine_datum(rd)) in v

`co_usual_coordinates`

L350co_usual_coordinates(RootDatum rd, ratvec v)

v\in X^*_Q, in co_affine coordinates

`is_affine_conjugate` 2 overloads

L354is_affine_conjugate(AffineDatum ad,ratvec wt_1,ratvec wt_2) = bool

L358is_affine_conjugate(ratvec cwt_1,ratvec cwt_2,AffineDatum ad) = bool

`action_fundamental_group`

L363action_fundamental_group (ratvec cwt,AffineDatum ad)

action of fundamental group on fundamental alcove

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

affine.at

Definitions in source order

cutoff

affine_verbose

highest_short_roots

highest_short_root

AffineDatum type

rank

ss_rank

is_simple

is_one_factor 2 overloads

number_factors

affine_root_sum

affine_coroot_sum

folding_order

folding_orders

AffineWeylElt type

inverse

affine_datum 2 overloads

reflect 6 overloads

coreflect 4 overloads

affine_reflect 2 overloads

affine_coreflect 2 overloads

labels

co_labels

affine_labels

co_affine_labels

reflect_or_affine_reflect

coreflect_or_affine_coreflect

coreflect_or_coaffine_reflect

affine_coordinates 7 overloads

confirm 2 overloads

in_fundamental_alcove 2 overloads

affine_non_dominant_index

is_affine_dominant

affine_non_dominant_index

is_affine_dominant

affine_make_dominant

affine_co_make_dominant 2 overloads

co_usual_coordinates

is_affine_conjugate 2 overloads

action_fundamental_group

`affine.at`

`cutoff`

`affine_verbose`

`highest_short_roots`

`highest_short_root`

`AffineDatum` type

`rank`

`ss_rank`

`is_simple`

`is_one_factor` 2 overloads

`number_factors`

`affine_root_sum`

`affine_coroot_sum`

`folding_order`

`folding_orders`

`AffineWeylElt` type

`inverse`

`affine_datum` 2 overloads

`reflect` 6 overloads

`coreflect` 4 overloads

`affine_reflect` 2 overloads

`affine_coreflect` 2 overloads

`labels`

`co_labels`

`affine_labels`

`co_affine_labels`

`reflect_or_affine_reflect`

`coreflect_or_affine_coreflect`

`coreflect_or_coaffine_reflect`

`affine_coordinates` 7 overloads

`confirm` 2 overloads

`in_fundamental_alcove` 2 overloads

`affine_non_dominant_index`

`is_affine_dominant`

`affine_non_dominant_index`

`is_affine_dominant`

`affine_make_dominant`

`affine_co_make_dominant` 2 overloads

`co_usual_coordinates`

`is_affine_conjugate` 2 overloads

`action_fundamental_group`