Antonio
Candiello

Progetti · WBase e le rappresentazioni delle algebre di Lie

WBase: come funziona e perché

  • wbase
  • irrep
  • rappresentazioni irriducibili
  • Dynkin
  • algebre di Lie
  • base di Cartan-Weyl

WBase è un pacchetto C di meno di 1000 righe che calcola le rappresentazioni irriducibili (irrep) delle algebre di Lie semplici e decompone i loro prodotti tensoriali. Dato il peso massimo di un'irrep, ne calcola dimensione, indice, sistema dei pesi con le molteplicità e tableau di Young; dati due pesi massimi, trova le irrep contenute nel prodotto.

Il documento segue l'ordine in cui serve per capire WBase: prima la teoria, poi gli algoritmi, poi il codice. Gli esempi numerici sono rieseguiti con la V3.0, e dove il materiale originale del 1995 conteneva errori i valori sono corretti (elenco).

Cos'è WBase

Il programma usa l'approccio di Dynkin, valido per tutte le algebre semplici, eccezionali comprese: An, Bn, Cn, Dn, E6, E7, E8, F4 e G2. È nato per la fisica delle particelle e per la supergravità, dove servono prodotti di irrep più grandi di quelli riportati nelle tabelle classiche, come quella di Slansky.

VersioneDataNovità
V3.0novembre 2026Correzioni per Cn, B2, E7 ed E8, dimensioni a 64 bit, input robusto
V2.0aprile 1995Tutte le algebre semplici, generazione di tabelle (wsequence), tableau di Young estesi
V1dicembre 1993Prima versione, solo An, Bn e Dn; pubblicata su Comput. Phys. Comm. 81 (1994)
Torna su

L'approccio di Dynkin

Nell'approccio di Dynkin un'algebra di Lie semplice è descritta interamente dalla sua matrice di Cartan, una matrice \(l \times l\) dove \(l\) è il rango. WBase non contiene tabelle di algebre: costruisce tutto al volo a partire da questa matrice.

Nella base di Cartan–Weyl i generatori si dividono in \(l\) generatori \(H_i\) che commutano fra loro e nei restanti generatori \(E_\alpha\):

\[ [H_i, H_j] = 0, \qquad [H_i, E_\alpha] = \alpha_i \, E_\alpha, \qquad i = 1, \ldots, l \]
TermineSignificatoIn WBase
Rango \(l\)Numero di generatori \(H_i\) che commutanowsize
Radici \(\alpha\)Gli autovalori (\(l\)-vettori) dei generatori \(E_\alpha\)—
Radici semplici \(\alpha_1 \ldots \alpha_l\)\(l\) radici da cui tutte le altre si ottengono per combinazione lineare a coefficienti interi tutti \(\ge 0\) o tutti \(\le 0\)righe di cart
Radici positiveLe radici con coefficienti tutti \(\ge 0\); sono \((\dim G - l)/2\)pos, generate da wptree
Matrice di Cartan \(A\)\(A_{ij} = 2(\alpha_i, \alpha_j)/(\alpha_j, \alpha_j)\); la riga \(i\) sono le etichette di Dynkin di \(\alpha_i\)cart, scritta da Afill…Gfill
Metrica \(G\)\(G_{ij} = (\omega_i, \omega_j)\), prodotto scalare fra pesi fondamentali; è l'inversa della matrice di Cartan, simmetrizzatametr
Peso\(l\)-upla di interi che identifica uno stato dentro un'irrepwvect
Peso massimo \(\Lambda\)\(l\)-upla di interi non negativi (etichette di Dynkin) che identifica un'irrep in modo univocoi numeri che si digitano in input
Sistema dei pesiTutti i pesi di un'irrep, ciascuno con la sua molteplicitàlista di wblock

Il prodotto scalare fra due pesi \(x\) e \(y\), scritti nella base di Dynkin, è \((x, y) = \sum_{ij} x_i G_{ij} y_j\). Il vettore speciale \(\delta = (1, 1, \ldots, 1)\), cioè la semisomma delle radici positive, compare in tutte le formule.

Torna su

Un esempio: l'irrep 15 di SU(3)

L'irrep 15 di SU(3) (algebra A2) ha peso massimo \(\Lambda = (1\ 2)\) e un sistema di 12 pesi distinti su 7 livelli. Tre pesi hanno molteplicità 2, quindi 12 + 3 = 15 stati.

Il livello di un peso è il numero di radici semplici sottratte da \(\Lambda\) per arrivarci; l'altezza dell'irrep è il livello più basso, qui 6. Questa è la tabella prodotta da WBase con il comando T:

LivelloPesoMolteplicità
0(1 2)1
1(−1 3)1
1(2 0)1
2(0 1)2
2(3 −2)1
3(−2 2)1
3(1 −1)2
4(2 −3)1
4(−1 0)2
5(0 −2)1
5(−3 1)1
6(−2 −1)1

Il sistema è simmetrico: il peso più basso (−2 −1) è l'opposto del peso massimo della coniugata \(\overline{15} = (2\ 1)\). Il materiale originale del 1995 riportava come ultimo peso (−2 1), che è un refuso.

Torna su

Come si costruisce il sistema dei pesi

Il sistema dei pesi si ottiene dal peso massimo sottraendo ripetutamente le radici semplici, cioè le righe della matrice di Cartan. In A2 le radici semplici sono \(\alpha_1 = (2\ {-1})\) e \(\alpha_2 = ({-1}\ 2)\). La funzione ricorsiva wtree applica questa regola:

  1. Si parte da \(u = \Lambda\).
  2. Per ogni componente \(i\) con \(u_i > 0\), si sottrae \(\alpha_i\) una, due, …, \(u_i\) volte, ottenendo i pesi \(u - k\alpha_i\).
  3. Ogni peso nuovo viene salvato al livello del padre più \(k\) e la procedura riparte da lì; un peso già presente non viene rielaborato.

La regola si ferma da sola: le componenti negative non generano sottrazioni, quindi la ricorsione termina sul peso più basso. I pesi vengono tenuti ordinati per livello, perché la formula di Freudenthal ha bisogno di calcolare prima i livelli alti.

Ogni passo verso il basso sottrae una radice semplice

Irrep 15 di SU(3), peso massimo (1 2): 12 pesi su 7 livelli, 3 con molteplicità 2

livello 0 livello 1 livello 2 livello 3 livello 4 livello 5 livello 6 (1 2) (−1 3) (2 0) (0 1) ×2 (3 −2) (−2 2) (1 −1) ×2 (2 −3) (−1 0) ×2 (0 −2) (−3 1) (−2 −1) sottrae α₁ = (2 −1) sottrae α₂ = (−1 2) molteplicità 2
Albero dei pesi generato con WBase V3.0 (comando T).

Nel diagramma ogni freccia verso sinistra (continua) sottrae \(\alpha_1\) e ogni freccia verso destra (tratteggiata) sottrae \(\alpha_2\). L'albero dice quali pesi esistono, non quante volte compaiono: (0 −2) ha due frecce entranti come (−1 0), ma molteplicità 1 invece di 2. Per le molteplicità serve la formula di Freudenthal.

Torna su

Le formule

WBase usa tre formule classiche, tutte scritte con il prodotto scalare della metrica \(G\), più la formula dell'altezza. Ogni formula corrisponde a una funzione del codice.

Dimensione: formula di Weyl

Funzione weyl. Il prodotto corre sulle radici positive \(\alpha\):

\[ \dim(\Lambda) = \prod_{\alpha > 0} \frac{(\Lambda + \delta, \alpha)}{(\delta, \alpha)} \]

Non serve costruire il sistema dei pesi: bastano il peso massimo e le radici positive. Per questo la dimensione di un'irrep enorme di E8 si calcola istantaneamente.

Molteplicità di un peso: formula ricorsiva di Freudenthal

Funzioni freud e bfreud. Si parte da \(\deg(\Lambda) = 1\) e si scende livello per livello:

\[ \deg(w) = \frac{2 \sum_{\alpha > 0} \sum_{k > 0} \deg(w + k\alpha)\,(w + k\alpha, \alpha)}{\lVert \Lambda + \delta \rVert^2 - \lVert w + \delta \rVert^2} \]

I pesi \(w + k\alpha\) stanno più in alto di \(w\), quindi le loro molteplicità sono già note quando si arriva a \(w\). È la parte più lenta del programma: ogni \(\deg(w + k\alpha)\) richiede una ricerca nella lista dei pesi.

Indice di Dynkin del 2° ordine

Funzione casimir, stampato come C=:

\[ C(\Lambda) = \frac{\dim(\Lambda)}{\dim(G)} \, (\Lambda, \Lambda + 2\delta) \]

Con questa normalizzazione la fondamentale di SU(N) ha C = 1 e l'aggiunta di SU(3) ha C = 6. Il materiale originale del 1995 scrive solo \(\dim(\Lambda)/\dim(G)\), dimenticando il fattore \((\Lambda, \Lambda + 2\delta)\): il codice invece lo ha sempre usato.

Altezza

Funzione wheight, stampata come H=: \(H = \sum_i \mathrm{whigh}_i \Lambda_i\), dove i coefficienti whigh sono fissati per ogni algebra. H è il livello del peso più basso, cioè il numero di livelli del sistema dei pesi meno 1.

Torna su

Prodotti tensoriali

Per decomporre \(R_1 \otimes R_2\) WBase somma ogni peso di \(R_1\) con ogni peso di \(R_2\) e poi estrae le irrep una alla volta, partendo dalla più alta. È la funzione wpdisp, in questi passi:

  1. wsyst costruisce il sistema dei pesi di \(R_1\) e quello di \(R_2\), con le molteplicità.
  2. bprod forma l'insieme di tutte le somme \(w_1 + w_2\), contando le molteplicità (\(\dim R_1 \times \dim R_2\) elementi).
  3. Finché l'insieme non è vuoto:
    1. whigher sceglie il peso di altezza massima: è il peso massimo di una componente;
    2. wsyst costruisce il sistema dei pesi di quella componente;
    3. bremove lo sottrae dall'insieme, molteplicità comprese.

La modalità veloce (comandi F e L) salta il passo 3. Elenca solo i pesi dominanti distinti del prodotto, quindi non dà le molteplicità e può includere pesi che non sono pesi massimi di nessuna componente.

Un esempio fisico: il decupletto barionico

Tre quark formano un barione secondo il prodotto \(3 \otimes 3 \otimes 3 = 10 \oplus 8 \oplus 8 \oplus 1\) di SU(3) di sapore. WBase lo calcola in due passi: \(3 \otimes 3 = 6 \oplus \overline{3}\), poi \(6 \otimes 3 = 10 \oplus 8\) e \(\overline{3} \otimes 3 = 8 \oplus 1\).

Il decupletto dei barioni di spin 3/2 è l'irrep 10 = (0 3), in cui i tre quark sono simmetrizzati. Con la convenzione usata da WBase, u = (0 1), d = (−1 0) e s = (1 −1), il peso di ogni stato è la somma dei pesi dei suoi quark:

LivelloStatoQuarkPeso
0Δuuu(0 3)
1Σ*uus(1 1)
2Δduu(−1 2)
2Ξ*uss(2 −1)
3Σ*dus(0 0)
3Ωsss(3 −3)
4Δddu(−2 1)
4Ξ*dss(1 −2)
5Σ*dds(−1 −1)
6Δddd(−3 0)

Il decupletto barionico è un triangolo di 10 pesi semplici

Pesi dell'irrep 10 = (0 3) nel piano (I₃, Y): quattro righe di ipercarica, da Δ in alto a Ω in basso

Δ, Y = 1 Σ*, Y = 0 Ξ*, Y = −1 Ω, Y = −2 I₃ (isospin) Y (ipercarica) Δ++ (0 3) Δ+ (−1 2) Δ0 (−2 1) Δ− (−3 0) Σ*+ (1 1) Σ*0 (0 0) Σ*− (−1 −1) Ξ*0 (2 −1) Ξ*− (1 −2) Ω− (3 −3) Tutti i 10 pesi hanno molteplicità 1: a differenza dell'ottetto, il decupletto non ha punti doppi.
Sistema dei pesi calcolato con WBase V3.0 (comando T, A2, peso massimo 0 3).

Tutti i 10 pesi hanno molteplicità 1. Il materiale originale dava a dds il peso (1 −2), già assegnato a dss: il valore corretto è (−1 −1).

Un secondo esempio: l'ottetto dei mesoni

Un mesone è formato da un quark e un antiquark, secondo il prodotto \(3 \otimes \overline{3} = 8 \oplus 1\). Con il comando P WBase lo calcola come (0 1) ⊗ (1 0) = (1 1) ⊕ (0 0): l'ottetto più un singoletto.

L'ottetto dei mesoni pseudoscalari (spin 0) è l'irrep 8 = (1 1), la stessa che fa da rappresentazione aggiunta di SU(3). Gli antiquark hanno i pesi opposti a quelli dei quark, \(\bar{u} = (0\ {-1})\), \(\bar{d} = (1\ 0)\) e \(\bar{s} = ({-1}\ 1)\), e il peso di ogni mesone è la somma dei pesi del quark e dell'antiquark:

LivelloMesoneQuarkPesoMolteplicità
0\(\pi^+\)\(u\bar{d}\)(1 1)1
1\(K^+\)\(u\bar{s}\)(−1 2)1
1\(\bar{K}^0\)\(s\bar{d}\)(2 −1)1
2\(\pi^0\), \(\eta_8\)\(u\bar{u}\), \(d\bar{d}\), \(s\bar{s}\)(0 0)2
3\(K^0\)\(d\bar{s}\)(−2 1)1
3\(K^-\)\(s\bar{u}\)(1 −2)1
4\(\pi^-\)\(d\bar{u}\)(−1 −1)1

L'ottetto dei mesoni è un esagono con il centro doppio

Pesi dell'irrep 8 = (1 1) nel piano (I₃, Y); sotto ogni mesone il peso in etichette di Dynkin

I₃ (isospin) Y (ipercarica) π+ (1 1) K+ (−1 2) K0 (−2 1) π− (−1 −1) K− (1 −2) K0 (2 −1) π0, η8 (0 0) ×2 Il doppio cerchio indica molteplicità 2; il singoletto η₁, pure di peso (0 0), non fa parte dell'ottetto.
Sistema dei pesi calcolato con WBase V3.0 (comando T, A2, peso massimo 1 1).

A differenza del decupletto, qui il peso zero ha molteplicità 2. Le tre coppie \(u\bar{u}\), \(d\bar{d}\) e \(s\bar{s}\) hanno tutte peso (0 0): due loro combinazioni stanno nell'ottetto (\(\pi^0\) e \(\eta_8\)), la terza, simmetrica, è il singoletto \(\eta_1\). Così si ritrovano i 9 = 8 + 1 stati del prodotto. I mesoni osservati \(\eta\) e \(\eta'\) sono miscele di \(\eta_8\) e \(\eta_1\).

Torna su

Le strutture dati

WBase alloca tutta la memoria a run-time, perché la dimensione di un sistema dei pesi non è nota in anticipo: può andare da pochi byte a centinaia di megabyte. Ci sono tre tipi di dati, definiti in wbase.h:

TipoDefinizioneUso
wvecttypedef char *wvect;Un peso: un array di \(l\) byte allocato con walloc e liberato con wfree
wplacestruct { tdeg deg; tlevel level; char vect[1]; }Un peso dentro un sistema, con molteplicità (unsigned short) e livello (short). vect[1] è lo «struct hack» del C pre-1999: in realtà il vettore ha \(l\) byte
wblockstruct tblock { struct tblock *next; char body[1]; }Un blocco di 1000 posti (bsize); i blocchi formano una lista concatenata

Un sistema dei pesi è una catena di blocchi di posti a dimensione fissa

Un posto (wplace), per un'algebra di rango l degmolteplicità, 2 byte levellivello, 2 byte vect[0] … vect[l−1]etichette di Dynkin del peso, 1 byte ciascuna riempimentofino a un multiplo di 4 5 + l byte (4 per deg e level, 1 di allineamento, l per il peso), arrotondati a un multiplo di 4: 8 byte in A2, 16 in E8 La lista di blocchi (wblock), 1000 posti per blocco next posto 0: peso massimo posto 1 … posto 999 next posto 1000 posto 1001 … posto 1999 next = NULL posto 2000 … ultimo peso deg = 0: fine lista posti liberi pstart / pnext scorrono i posti attraversando i blocchi e si fermano al primo deg = 0; wsave aggiunge un blocco con balloc quando l'ultimo è pieno, bsfree libera tutta la catena.
Strutture dati di wbase.h: wvect, wplace, wblock.

I blocchi sono «informi»: body è solo una sequenza di byte, a cui la macro place(i, b) dà la forma di un wplace. Usare char per le etichette risparmia memoria ma le limita all'intervallo da −128 a 127.

Torna su

Le procedure e gli iteratori

L'utente di WBase lavora con poche procedure di alto livello e tre iteratori, senza mai toccare i blocchi di memoria. Le firme qui sotto sono quelle del codice V3.0.

ProcedureCosa fanno
wstartup(type, rank, debug)
wcleanup(msg)
Creano e distruggono le tabelle dell'algebra (Cartan, metrica, radici positive). wcleanup(NULL) chiude senza messaggio e termina il programma
wread(hw)
wfdisp(hw)
wydisp(hw)
Leggono un peso massimo da stdin; stampano D, C, H; stampano il tableau di Young (serie classiche)
wsave(w, base, level)
wremove(w, base)
Con level ≥ 0 inseriscono w ordinato per livello; con level = −1 lo accodano o ne incrementano la molteplicità. wremove decrementa la molteplicità e toglie il peso quando arriva a 0
wsyst(hw)
bdisp(base)
bsfree(base)
Costruiscono il sistema dei pesi con le molteplicità; lo stampano; liberano la lista di blocchi
wpdisp(hw1, hw2, mod)Decompone hw1 ⊗ hw2; mod combina i flag WFULL (esatto), WTREE (albero dei pesi), WYOUNG (tableau)

Scorrere un sistema dei pesi

pstart/pnext nascondono il passaggio da un blocco all'altro:

wplace *p; pcurr pc;
for (p = pstart(base, &pc); p != NULL; p = pnext(&pc))
    wdisp(p->vect);   /* anche p->deg e p->level */

Estrarre le irrep di un prodotto

wpstart/wpnext restituiscono a ogni passo il sistema dei pesi completo di una componente:

wblock *b1 = wsyst(hw1), *b2 = wsyst(hw2), *buf, *b;
buf = bprod(b1, b2);
bsfree(b1); bsfree(b2);
for (b = wpstart(buf); b != NULL; b = wpnext(b, buf))
    bdisp(b);

Generare una tabella di irrep

wsequence restituisce a ogni chiamata la prossima irrep in ordine di dimensione, fino a quelle con dimensione strettamente minore di maxdim, e alla fine libera da sola la propria lista:

wblock *b = NULL; long long dim;
wvect hw = walloc();
while ((b = wsequence(hw, b, maxdim, &dim)) != NULL)
    wfdisp(hw);
wfree(hw);

Due wsequence annidati producono una tabella di prodotti: è quello che fanno i comandi U, V e L. Per avere risultati esatti bisogna passare WFULL a wpdisp; con mod = 0 la decomposizione è quella veloce e approssimata.

Torna su

Due sessioni con F4

Due sessioni con l'algebra eccezionale F4 mostrano WBase al lavoro. La V3.0 riproduce esattamente i numeri delle sessioni originali del 1995. Si avvia wbase.exe, si scrive F4 come algebra, poi un comando.

Sequenza di irrep (comando S, maxdim 2000)

WBase elenca in ordine di dimensione tutte le irrep con dimensione minore di 2000:

Sotto dimensione 2000 F4 ha 8 irrep, due delle quali di dimensione 1053

In ordine di dimensione; in scuro le due irrep diverse con la stessa dimensione

peso massimo dimensione (0 0 0 0) (0 0 0 0): dimensione 1, indice 0, altezza 0 1 (0 0 0 1) (0 0 0 1): dimensione 26, indice 6, altezza 16 26 (1 0 0 0) (1 0 0 0): dimensione 52, indice 18, altezza 22 52 (0 0 1 0) (0 0 1 0): dimensione 273, indice 126, altezza 30 273 (0 0 0 2) (0 0 0 2): dimensione 324, indice 162, altezza 32 324 (1 0 0 1) (1 0 0 1): dimensione 1053, indice 648, altezza 38 1.053 C = 648, H = 38 (2 0 0 0) (2 0 0 0): dimensione 1053, indice 810, altezza 44 1.053 C = 810, H = 44 (0 1 0 0) (0 1 0 0): dimensione 1274, indice 882, altezza 42 1.274
WBase V3.0, F4, comando S con maxdim 2000; identico alla sessione originale del 1995.

Le due irrep di dimensione 1053 si distinguono per l'indice C (648 e 810) e per l'altezza H (38 e 44): la sola dimensione non basta a identificare un'irrep.

Sequenza di prodotti (comando U, maxdim 100)

Con maxdim 100 le irrep coinvolte sono la 26 e la 52, e WBase decompone tutti i loro prodotti:

ProdottoDecomposizione
26 ⊗ 26324 ⊕ 273 ⊕ 52 ⊕ 26 ⊕ 1
26 ⊗ 521053 ⊕ 273 ⊕ 26
52 ⊗ 521053′ ⊕ 1274 ⊕ 324 ⊕ 52 ⊕ 1

In ogni riga la somma delle dimensioni è il prodotto delle dimensioni, per esempio 26 × 52 = 1352 = 1053 + 273 + 26. Qui 1053 è (1 0 0 1) e 1053′ è (2 0 0 0).

Torna su

Errori corretti

Rispetto al materiale originale del 1995, questo documento corregge 9 punti. Ogni correzione è verificata eseguendo WBase V3.0 o confrontando con il codice.

ArgomentoNell'originaleCorretto
Irrep 15 di SU(3)Ultimo peso: (−2 1)(−2 −1)
Decupletto barionicoPeso di dds: (1 −2), uguale a quello di dss(−1 −1)
Indice di Dynkin\(\mathrm{cas}(\Lambda) = \dim(\Lambda)/\dim(\mathrm{adj})\)\(C(\Lambda) = \dim(\Lambda)\,(\Lambda, \Lambda + 2\delta)/\dim(G)\)
Peso massimo\(l\)-upla di interi «positivi»Interi non negativi: lo zero è ammesso, (0 0) è il singoletto
wstartupwstartup(type, rank)wstartup(type, rank, debug)
wcleanupVa chiamata dopo ogni wstartupTermina anche il programma (exit)
wsequenceEsempio con int dimlong long dim (nella V2.0 era long)
wsequenceMostra le irrep «fino a» maxdimStrettamente minori di maxdim
Sessione F4 dei prodottiSembra fatta con la modalità veloce LL'output coincide con la modalità esatta U
Torna su

Pubblicazioni su WBase

WBase è descritto in tre pubblicazioni di A. Candiello, dal 1994 al 1995:

Riferimenti teorici citati negli articoli:

  • R. Slansky, Group theory for unified model building, Phys. Rep. 79 (1981) 1: la fonte delle formule e delle convenzioni.
  • R.N. Cahn, Semi-Simple Lie Algebras and Their Representations, Benjamin/Cummings, 1984.
  • W. McKay, J. Patera, Tables of Dimensions, Indices and Branching Rules for Representations of Simple Algebras, Dekker, 1981.
  • G.R.E. Black, R.C. King, B.G. Wybourne, J. Phys. A16 (1983) 1555: le tecniche a S-function, l'alternativa ai metodi di Dynkin.
Torna su