Representaciones de SU(3)

(*Defino los 8 generadores canonicos de SU(3) *)
e={{1,0,0},{0,1,0},{0,0,1}}; (*Identidad de 3x3*)
f1= {{0,1,0},{1,0,0},{0,0,0}};
f2 = {{0,-I,0},{I,0,0},{0,0,0}};
f3 = {{1,0,0},{0,-1,0},{0,0,0}};
f4 = {{0,0,1},{0,0,0},{1,0,0}};
f5 = {{0,0,-I},{0,0,0},{I,0,0}};
f6 = {{0,0,0},{0,0,1},{0,1,0}};
f7 = {{0,0,0},{0,0,-I},{0,I,0}};
f8 = {{(1/(Sqrt[3])),0,0},{0,(1/(Sqrt[3])),0},{0,0,((-2)/(Sqrt[3]))}};

(*Creo un vector de matrices con los 8 generadores. Esto permite accederlos mas facilmente mediante el subindice (fk = f[[k]]) *)
f={f1,f2,f3,f4,f5,f6,f7,f8};

(*Los ecribo en pantalle en forma matricial solo para verlos*)
Do[Print["f",i,"=",f[[i]]//MatrixForm,"      f",i+4,"=",f[[i+4]]//MatrixForm],{i,4}]

(*Calculo el operador de Casimir C1 y lo llamo F *)
F=ConstantArray[0,{3,3}]; (*Matriz cero de 3x3 *)
Do[F=F+f[[i]].f[[i]],{i,8}];
Print["F = ",MatrixForm[F]] (*se escribe en pantalla*)

(*Ahora calculo la representacion producto SU(3)xSU(3) (llamo l[[k]] a los 8 generadores y L al operador de Casimir) *)
l=Array[0,8];
Do[l[[i]]=KroneckerProduct[f[[i]],e]+KroneckerProduct[e,f[[i]]];,{i,8}];
L=ConstantArray[0,{9,9}];
Do[L=L+l[[i]].l[[i]],{i,8}];
MatrixForm[L]
(*Como L no es diagonal la reprecentacion es reducible! *)

(*Para encontrar el cambio de base que la lleva a la representacion ireducible 
busco la matrix U que diagonaliza al operador de Casimir L*)
Print["Autovalores: ",Eigenvalues[L]]
U=Eigenvectors[L];
Do[U[[i]]=U[[i]]/Norm[U[[i]]],{i,9}];
Print["U = ",U]
(*U da los coeficientes de Clebsch-Gordan para este caso!*)

(*Diagonalizo L y llevo los generadores a la forma diagonal por bloques *)
T=Inverse[U];
Print["L = ", MatrixForm[U.L.T]]
Do[Print["l",i,"=",MatrixForm[U.l[[i]].T], "   l" ,i+4,"=",MatrixForm[U.l[[i+4]].T]],{i,4}];
(*Como se esperaba de la lista de autovalores se obtiene que la representacion producto se 
decompone en dos representaciones (bloques). Uno de 6x6 y otro de 3x3. Ambos son representaciones de SU(3) *)

(* Ahora miro con mas detalle la representaion (bloque) de 3x3 que se obtuvo.
Llamo g[[k]] a los 8 generadores de esta representacion de 3x3 y los comparo con los generadores f[[k]]. *)
g=Array[0,8];
Do[g[[i]]=Take[U.l[[i]].T,{7,9},{7,9}],{i,8}];

Do[Print["g",i," = ",MatrixForm[g[[i]]],"   f",i," = ",MatrixForm[f[[i]]]],{i,8}]
(*Como ven algunos de los generadores cambian de signo. Son en efecto dos representaciones diferentes
que no estan conectadas por cambios de base. A la representacion f se la llama 3 y a la g (OverBar[3]) .*)

(*Defino los operadores T3,U3 y V3 para las dos representaciones (f y g) *)
Tg3 = 1/2g[[3]];
Ug3=1/4(-g[[3]]+(Sqrt[3])g[[8]]);
Vg3 = 1/4(g[[3]]+(Sqrt[3])g[[8]]);
Tf3 = 1/2f[[3]];
Uf3=1/4(-f[[3]]+(Sqrt[3])f[[8]]);
Vf3 = 1/4(f[[3]]+(Sqrt[3])f[[8]]);

Print["Tg3 = ",MatrixForm[Tg3],"   Tf3 = ",MatrixForm[Tf3]]
Print["Ug3 = ",MatrixForm[Ug3],"   Uf3 = ",MatrixForm[Uf3]]
Print["Vg3 = ",MatrixForm[Vg3],"   Vf3 = ",MatrixForm[Vf3]]

u={1,0,0};
d={0,1,0};
s={0,0,1};

(OverBar[u])={1,0,0};
(OverBar[d])={0,1,0};
(OverBar[s])={0,0,1};
(*Calculo los numeros cuanticos de los tres estados *)
Print["u:" ,{u.Tf3.u,u.Uf3.u,u.Vf3.u}]
Print["d:" ,{d.Tf3.d,d.Uf3.d,d.Vf3.d}]
Print["s:" ,{s.Tf3.s,s.Uf3.s,s.Vf3.s}]
Print["(OverBar[u]):" ,{(OverBar[u]).Tg3.(OverBar[u]),(OverBar[u]).Ug3.(OverBar[u]),(OverBar[u]).Vg3.(OverBar[u])}]
Print["(OverBar[d]):" ,{(OverBar[d]).Tg3.(OverBar[d]),(OverBar[d]).Ug3.(OverBar[d]),(OverBar[d]).Vg3.(OverBar[d])}]
Print["(OverBar[s]):" ,{(OverBar[s]).Tg3.(OverBar[s]),(OverBar[s]).Ug3.(OverBar[s]),(OverBar[s]).Vg3.(OverBar[s])}]

(*Ahora voy a calcular 3x(OverBar[3]). Voy a llamar r[[k]] a los generadores de esta representacion producto (que vamos a ver es diferente de la que se obtiene al hacer 3x3) *)
r=Array[0,8];
Do[r[[i]]=KroneckerProduct[f[[i]],e]+KroneckerProduct[e,g[[i]]];,{i,8}];
(*Llamo R al operador de casimir C1 en esta representacion producto*)
R=ConstantArray[0,{9,9}];
Do[R=R+r[[i]].r[[i]],{i,8}];
MatrixForm[R]

(*De nuevo se obtiene algo que no es diagonal y, por lo tanto, reducible *)
(*-> Busco el cambio de base que hace diagonal a R..*)
Eigenvalues[R]
U2=Eigenvectors[R];
Do[U2[[i]]=U2[[i]]/Norm[U2[[i]]],{i,9}];
U2
T2=Inverse[U2];
U2.R.T2//MatrixForm
(*Ahora se obtiene otra descomposicion: 3x(OverBar[3]) -> 8+1 (El octete y el singlete de mesones!) *)