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.
| Versione | Data | Novità |
|---|---|---|
| V3.0 | novembre 2026 | Correzioni per Cn, B2, E7 ed E8, dimensioni a 64 bit, input robusto |
| V2.0 | aprile 1995 | Tutte le algebre semplici, generazione di tabelle (wsequence), tableau di Young estesi |
| V1 | dicembre 1993 | Prima versione, solo An, Bn e Dn; pubblicata su Comput. Phys. Comm. 81 (1994) |
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\):
| Termine | Significato | In WBase |
|---|---|---|
| Rango \(l\) | Numero di generatori \(H_i\) che commutano | wsize |
| 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 positive | Le 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, simmetrizzata | metr |
| Peso | \(l\)-upla di interi che identifica uno stato dentro un'irrep | wvect |
| Peso massimo \(\Lambda\) | \(l\)-upla di interi non negativi (etichette di Dynkin) che identifica un'irrep in modo univoco | i numeri che si digitano in input |
| Sistema dei pesi | Tutti 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 suUn 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:
| Livello | Peso | Molteplicità |
|---|---|---|
| 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 suCome 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:
- Si parte da \(u = \Lambda\).
- Per ogni componente \(i\) con \(u_i > 0\), si sottrae \(\alpha_i\) una, due, …, \(u_i\) volte, ottenendo i pesi \(u - k\alpha_i\).
- 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
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 suLe 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\):
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:
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=:
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.
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:
wsystcostruisce il sistema dei pesi di \(R_1\) e quello di \(R_2\), con le molteplicità.bprodforma l'insieme di tutte le somme \(w_1 + w_2\), contando le molteplicità (\(\dim R_1 \times \dim R_2\) elementi).- Finché l'insieme non è vuoto:
whighersceglie il peso di altezza massima: è il peso massimo di una componente;wsystcostruisce il sistema dei pesi di quella componente;bremovelo 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:
| Livello | Stato | Quark | Peso |
|---|---|---|---|
| 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
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:
| Livello | Mesone | Quark | Peso | Molteplicità |
|---|---|---|---|---|
| 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
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 suLe 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:
| Tipo | Definizione | Uso |
|---|---|---|
wvect | typedef char *wvect; | Un peso: un array di \(l\) byte allocato con walloc e liberato con wfree |
wplace | struct { 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 |
wblock | struct 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
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.
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.
| Procedure | Cosa 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.
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
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:
| Prodotto | Decomposizione |
|---|---|
| 26 ⊗ 26 | 324 ⊕ 273 ⊕ 52 ⊕ 26 ⊕ 1 |
| 26 ⊗ 52 | 1053 ⊕ 273 ⊕ 26 |
| 52 ⊗ 52 | 1053′ ⊕ 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 suErrori corretti
Rispetto al materiale originale del 1995, questo documento corregge 9 punti. Ogni correzione è verificata eseguendo WBase V3.0 o confrontando con il codice.
| Argomento | Nell'originale | Corretto |
|---|---|---|
| Irrep 15 di SU(3) | Ultimo peso: (−2 1) | (−2 −1) |
| Decupletto barionico | Peso 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 |
wstartup | wstartup(type, rank) | wstartup(type, rank, debug) |
wcleanup | Va chiamata dopo ogni wstartup | Termina anche il programma (exit) |
wsequence | Esempio con int dim | long long dim (nella V2.0 era long) |
wsequence | Mostra le irrep «fino a» maxdim | Strettamente minori di maxdim |
| Sessione F4 dei prodotti | Sembra fatta con la modalità veloce L | L'output coincide con la modalità esatta U |
Pubblicazioni su WBase
WBase è descritto in tre pubblicazioni di A. Candiello, dal 1994 al 1995:
- A. Candiello, WBase: a C package to reduce tensor products of Lie algebra representations. Description and new developments, in New Computing Techniques in Physics Research IV, atti del 4° International Workshop on Software Engineering, Artificial Intelligence and Expert Systems for High Energy and Nuclear Physics, a cura di B. Denby e D. Perret-Gallix, World Scientific, 1995: descrive la V2.0.
- A. Candiello, Reply on the comment on «WBase: a C package to reduce tensor products of Lie algebra representations», Comput. Phys. Comm. 83 (1994) 334: risposta al commento di B.G. Wybourne.
- A. Candiello, WBase: a C package to reduce tensor products of Lie algebra representations, Comput. Phys. Comm. 81 (1994) 248–260: articolo sulla V1, preprint DFPD/93/TH/76 (PDF).
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.