# Calculate representations of $SU(N)$ generators

I would like to calculate explicit representations of certain $SU(N)$ generators. I have written some code, but either it is extremely slow, or something just doesn't work. Either way, I would be very happy for some input!

Back to topic: The generators are hermitian, traceless $d\times d$ matrices $t^a$ ($a=1,\ldots,N^2-1$), $$t^a = (t^a)^\dagger = ((t^a)^T)^*,\qquad \text{Tr}[t^a]=0$$ where $d$ depends on the representation. They should also fulfill their algebra relation $$[t^a,t^b]:=t^a t^b - t^b t^a = \text{i} \sum\limits_{c=1}^{N^2-1}f^{abc} t^c$$ where $f^{abc}$ are known constants ("structure constants"). My code looks like this:

(* Specify SU(n) *)
n = 2;
(* rep(resentation) will determine dim(ension) *)
rep = "fund";
(* range for index a *)
dimSU = n^2 - 1;
(* Define structure constants *)
f[a_, b_, c_] := Switch[n, 2, LeviCivitaTensor[3][[a]][[b]][[c]]]
(* Define dim depending on rep *)
dim := Switch[rep, "trivial", 1, "fund", 2, "adj", 3, 1, 1, 2, 2, 3, 3]
(* Define matrices t^a with indices {ij} *)
t[a_, i_, j_] := Table[
tt[a, i, j]    (* They are the variables I want to work with *)
, {ii, 1, dim}
, {jj, 1, dim}
, {aa, 1, dimSU}][[a]][[i]][[j]]
(* Print t as a list *)
tMatrix[a_] := Table[t[a, i, j], {i, 1, dim}, {j, 1, dim}]
(* Print t as a matrix *)
tMatrixForm[a_] :=
Table[t[a, i, j], {i, 1, dim}, {j, 1, dim}] // MatrixForm


Now I implement the equations that they have to fulfill:

requireTraceless =
Table[Sum[tt[a, i, i], {i, 1, dim}] == 0, {a, 1, dimSU}];
requireHermitean = Table[
tt[a, i, j] == Conjugate[tt[a, j, i]]
, {i, 1, j}
, {j, 1, dim}
, {a, 1, dimSU}];
requireLie = Table[
Sum[t[a, i, j] t[Mod[a, dimSU] + 1, j, k], {j, 1, dim}] -
Sum[t[Mod[a, dimSU] + 1, i, j] t[a, j, k], {j, 1, dim}] ==
I f[a, Mod[a, dimSU] + 1, Mod[a + 1, dimSU] + 1] t[
Mod[a + 1, dimSU] + 1, i, k]
, {i, 1, dim}
, {k, 1, dim}
, {a, 1, dimSU}];


Finally I collect my equations and variables.

varList =
Table[tt[a, i, j], {i, 1, dim}, {j, 1, dim}, {a, 1,
dimSU}] // Flatten;
eqList = {requireTraceless, requireHermitean, requireLie} // Flatten;


And try to solve.

Solve[eqList, varList]


For $SU(2)$ with dim=2, this should yield the Pauli matrices.

I have found a related question, although it only covers the case $N=2$. Also, I would like to learn how/why my code is so slow.

• The repeated Table[] calls certainly do not help. Why not put it as a single Table[], e.g. Table[tt[a, i, j], {a, 1, dimSU}, {j, 1, dim}, {i, 1, dim}] instead of Table[Table[Table[tt[a, i, j], {i, 1, dim}], {j, 1, dim}], {a, 1, dimSU}]? – J. M.'s ennui Nov 1 '17 at 8:57
• Considering the link to the spin operators: Do not mix up $SU(N)$ with the spin group $\operatorname{Spin}(N)$. Are you really looking for certain generators of the Lie algebra of $SU(N)$ or for generators of representations of the spin group? – Henrik Schumacher Nov 1 '17 at 9:12
• @J.M. I did not know about that! Thanks! – ersbygre1 Nov 1 '17 at 9:43
• @HenrikSchumacher it's about generators of SU(N), thanks for the clarification! – ersbygre1 Nov 1 '17 at 9:44
• That's really many equations, many due to the requirement of being (skew-)Hermitian. (The generators of $SU(N)$ should be skew-Hermitian. I know, physicists like to multiply everything by $\operatorname{i}$.) You can get rid of these equations by realizing that you only have to set up variables for the upper triangular part of the generators and "reflect" them to the lower triangular part with ConjugateTranspose. – Henrik Schumacher Nov 1 '17 at 9:56

Actually, the idea of the structure constants is not to prescribe them and then to find a suitable basis. It is vice versa: Usually, one prescribes a basis satisfying some niceness requirements and computes the structure constants from them. Oftentimes, these requirements are sparsity and orthonormality with respect to some inner product.

Sparse matrices are best set up with SparseArray. Here, I construct a sparse basis of $SU(3)$ which is orthonormal with respect to the Frobenius inner product. Of course, the method works for all dimension.

n = 3;
a = 1/Sqrt[2] Flatten[Table[SparseArray[{{i, j} -> I, {j, i} -> I}, {n, n}], {i, 1, n}, {j, i + 1, n}], 1];
b = 1/Sqrt[2] Flatten[Table[SparseArray[{{i, j} -> -1, {j, i} -> 1}, {n, n}], {i, 1, n}, {j, i + 1, n}], 1];
c = DiagonalMatrix@*SparseArray /@ Orthogonalize[Table[SparseArray[{{i} -> I, {i + 1} -> -I}, {n}], {i, 1, n - 1}]];
basis = Join[a, b, c];
MatrixForm /@ basis


Up to ordering, scaling, and a multiplication with the imaginary unit, these are the Gell-Mann matrices.

Testing if we really have elements of $\mathfrak{su}(3)$:

Max[Abs[Tr /@ basis]]
Max[Abs[basis + ConjugateTranspose /@ basis]]

(* 0 *)
(* 0 *)


Testing the orthonormality:

innerprod = {x, y} \[Function] Tr[x.ConjugateTranspose[y]];
Outer[innerprod, basis, basis, 1] == IdentityMatrix[n (n - 1) + (n - 1)]
(* True *)


Orthogonality is a nice feature since the structure constants can now be computed with

SparseArray@ Outer[{x, y, z} \[Function] innerprod[x.y - y.x, z], basis, basis, basis, 1]

• Creating a basis with SparseArray and Orthogonalize is really elegant, thank you for showing how it works! However, how would I proceed in order to find a 4x4 dimensional representation that also fulfill $su(3)$ relations like the Gell-Mann matrices? That was what I originally intended to do using n to specify the algebra $su(n)$ and dim which would specify the dimension of the representation. – ersbygre1 Nov 2 '17 at 1:52
• Maybe this is of interest for you: math.stackexchange.com/questions/984558/… – Henrik Schumacher Nov 2 '17 at 18:27
• Had to think about it but yeah, this was very interesting, thank you very much! – ersbygre1 Nov 5 '17 at 10:13
• You're welcome! – Henrik Schumacher Nov 5 '17 at 12:39