Mathematical Methods: Group Theory:
The “Standard Basis” of SO(3) and 
Explicit Angular Momentum Coupling (1/2)⊗1 = (1/2)⊕(3/2)

Grießhammer September 2013. Read side-by-side with  Sect. 5.f) of “Groups” chapter of lecture manu-script.

The Angular Momentum Eigenstates {σ[i]} of SU(2), i.e. 2-dim (fundamental) representation of angular momentum algebra L[SU(2)]

The basis is given by the Pauli matrices, normalised:

σ[1]=PauliMatrix[1]/2;
σ[2]=PauliMatrix[2]/2;
σ[3]=PauliMatrix[3]/2;

σ[3] is already diagonal, so this is the proper basis with eigenvalues ±1/2, and the eigenvectors are (1,0) and (0,1).

MatrixForm[σ[3]]

The eigenvalue of the representation: Casimir operator J^2 has eigenvalue j(j+1)=3/4 for j=1/2:

[Technical Note: “MatrixForm” gives the nice matrix-like printout, but one needs to define “σsquare” before turning the output into MatrixForm, or the result cannot be handled well. Stupid mathematica “feature”.]

MatrixForm[σsquare=σ[1].σ[1]+σ[2].σ[2]+σ[3].σ[3]]

The Angular Momentum Eigenstates {Li} of SO(3), i.e. 3-dim (adjoint) representation of angular momentum algebra L[SU(2)]

The basis of generators of rotations

The original basis of the generators of rotations about each coordinate axis in 3 dimensions, i.e. of L[SO(3)], is labelled using a small letter “l”:

lx=(({{0, 0, 0}, {0, 0, -I}, {0, I, 0}}));ly=(({{0, 0, I}, {0, 0, 0}, {-I, 0, 0}}));lz=(({{0, -I, 0}, {I, 0, 0}, {0, 0, 0}}));

They obey the commutation relations: [Technical Note: “==” tests a logical statement: a correct answer is “True”.]

lx.ly-ly.lx==I lz
lz.lx-lx.lz==I ly
ly.lz-lz.ly==I lx

Their sum-squared is L^2 = j (j+1) for j=1:

MatrixForm[lx.lx+ly.ly+lz.lz]

Transformation to a basis of eigenstates of one rotation operator

QM classifies states as eigenstates to the generator of rotations about the z axis, Jz:
	Jz |m> = m |m>
where m is the associated quantum number.

Construct now matrix which diagonalises lz and orders its eigenvalues by size into m={+1,0,-1} basis.
Notice that the eigenvectors of lz must have unit length!

MatrixForm[diagonaliselz={{-(1/(Sqrt[2])),(I/(Sqrt[2])),0},{0,0,1},{(1/(Sqrt[2])),(I/(Sqrt[2])),0}}]

The inverse of diagonaliselz is its Hermitean conjugate, i.e. diagonaliselz is unitary:

Inverse[diagonaliselz]== Transpose[Conjugate[diagonaliselz]]

and indeed diagonalises lz (hence the name):

MatrixForm[L3=diagonaliselz.lz.Inverse[diagonaliselz]]

The eigenvalues are ±1,0, as expected, and the eigenvectors are of course (1,0,0), (0,1,0) and (0,0,1).

Call the generators in the new basis {L1,L2,L3} (Capital-L for eigenbasis to L3).

MatrixForm[L1=diagonaliselz.lx.Inverse[diagonaliselz]]

MatrixForm[L2=diagonaliselz.ly.Inverse[diagonaliselz]]

The eigenvalue of the representation: Casimir operator J^2 has eigenvalue j(j+1)=2 for j=1:

and is of course unchanged by diagonalising (it’s an irreducible representation!):

MatrixForm[Lsquare=L1.L1+L2.L2+L3.L3]

The Tensor/Kronecker Product: (1/2)⊗1 = (1/2)⊕(3/2)

What is a Tensor Product?: Example 2x2 matrix ⊗ 3x3 matrix

A 2x2 and a 3x3 matrix:

{MatrixForm[twobytwo=Table[(Subscript[a, i.j]),{i,1,2},{j,1,2}]],
MatrixForm[threebythree=Table[(Subscript[B, i.j]),{i,1,3},{j,1,3}]]}

Tensor/Kronecker product of the two: Look carefully at the structure! 
[Technical Note: I made the matrix a bit more readably by providing more space between entries.]

MatrixForm[KroneckerProduct[twobytwo,threebythree],TableSpacing->{2,3}]

Now Tensor/Kronecker Product:(1/2)⊗1

Recall that we define the total angular momentum operator as 
	J = L + σ = L ⊗ 1 + 1 ⊗ σ
where I made explicit the unit matrices in each space on which the operators L and σ act. 
Call resulting operators t(xyz):

One[2]=IdentityMatrix[2];
One[3]=IdentityMatrix[3];

MatrixForm[t1=(KroneckerProduct[σ[1],One[3]]+KroneckerProduct[One[2],L1])]
MatrixForm[t2=(KroneckerProduct[σ[2],One[3]]+KroneckerProduct[One[2],L2])]
MatrixForm[t3=(KroneckerProduct[σ[3],One[3]]+KroneckerProduct[One[2],L3])]

So the above are the representations of the 3 angular momentum operators {J[a]} in that new space of 6x6 matrices: dim(rep[L[SU(2)]])=6.

These 6x6 matrices act on a 6dim vector which is the product of the vectors of the 2 and 3 dim representations, classified by their respective values for J^2 and m:
	σ[3]/2 (|j1,m1> ⊗ |j2,m2>) 	= 	m1 (|j1,m1> ⊗ |j2,m2>) 
	L3 (|j1,m1> ⊗ |j2,m2>) 	= 	m2 (|j1,m1> ⊗ |j2,m2>) 
	σsquare (|j1,m1> ⊗ |j2,m2>) 	=	j1(j1+1) (|j1,m1> ⊗ |j2,m2>) 	with	j1=1/2 
	Lsquare (|j1,m1> ⊗ |j2,m2>) 	=	j2(j2+1) (|j1,m1> ⊗ |j2,m2>) 	with 	j2=1

MatrixForm[
j1j2basis=
{"|j1=1/2,m1=1/2> |j2=1,m2=1>",
"|j1=1/2,m1=1/2> |j2=1,m2=0>",
"|j1=1/2,m1=1/2> |j2=1,m2=-1>",
"|j1=1/2,m1=-1/2> |j2=1,m2=1>",
"|j1=1/2,m1=-1/2> |j2=1,m2=0>",
"|j1=1/2,m1=-1/2> |j2=1,m2=-1>"}]

HOWEVER: It’s much more natural to recall that 
	|j1=1/2,m1=1/2> 	= |p>, 
	|j1=1/2,m1=-1/2> 	= |n>, 
	|j2=1,m2=±1,0> 	= |(π^(±,0))>,
i.e.

MatrixForm[
j1j2basisNπ=
{"(|p(SuperPlus[π])>=|↑⇑>)","(|p(π^0)>=|↑·>)","(|p(SuperMinus[π])>=|↑⇓>)","(|n(SuperPlus[π])>=|↓⇑>)","(|n(π^0)>=|↓·>)","(|n(SuperMinus[π])>=|↓⇓>)"}]

Product states are NOT eigenvectors of angular-momentum-square operator

t3 is already diagonal in that basis, and t(xy) are of course not. But is tsquare also diagonal?

MatrixForm[tsquare=t1.t1+t2.t2+t3.t3]

Therefore, tsquare is an operator which commutes with all t(xyz) but is NOT proportional to the unit matrix. 
By Schur’s Third Lemma, the representation in terms of 6x6 matrices  is therefore NOT irreducible, 
but reducible into irreducible pieces: It is block-diagonal in a suitable basis.

So choose basis in which Tsquare is diagonal and show that (1/2)⊗1 = (1/2)⊕(3/2)

Diagonalising tsquare can be done by hand (only 4x4-submatix is not diagonal), but it’s quicker with mathematica.
[Technical Note: Pick the diagonalisation matrix such that eigenvalues of new J^2 ordered from smallest to largest.
“Normalize[]” makes sure the eigenvectors are all normalised to unity, i.e. the basis-change leaves lengths and angles unaffected.]

Eigensystem[tsquare]
MatrixForm[diagonalisetsquare=Table[Normalize[%[[2,7-i]]],{i,1,6}]]

So now Tsquare is diagonal in the new basis:

MatrixForm[Tsquare=Simplify[diagonalisetsquare.tsquare.Inverse[diagonalisetsquare]]]

So we see there are actually only 2 different eigenvalues: 3/4 (from j=1/2) and 15/4 (from j=3/2). 
We construct the operators T(xyz) in the new basis:

MatrixForm[T1=Simplify[diagonalisetsquare.t1.Inverse[diagonalisetsquare]]]

MatrixForm[T2=Simplify[diagonalisetsquare.t2.Inverse[diagonalisetsquare]]]

MatrixForm[T3=Simplify[diagonalisetsquare.t3.Inverse[diagonalisetsquare]]]

So the new T3 is still diagonal, as is now the new Tsquared. 
Furthermore, T1 and T2 are block-diagonal, split into an upper 2x2-block and a lower 4x4 block.
The 2x2 block is exactly again the σ[i]/2, so this is a j=1/2 representation (as the eigenvalues of Tsquare confirm).
The 4x4 block has j(j+1)=15/4, i.e. j=3/2, and that is confirmed by a look at the eigenvalues to T3; They range in unit steps from m=+3/2 to m=-3/2.

Recall also that Tsquare is now proportional to the unit matrix of each block. So each block is an IRREDUCIBLE representation of L[SU(2)]!

Clebsch-Gordan Coefficients: Matrix Elements of the Diagonaliser

In teh new basis, both Tsquare and T3 are diagonal. Label the states by the eigenvalues to these operators:
	Tsquare |J,M> = J(J+1) |J,M>
	           T3|J,M> = M |J,M>

These matrices T(xyz), Tsquare thus act on eigenvectors ordered as

JMbasis=
{"|J=1/2,M=1/2>",
"|J=1/2,M=-1/2>",
"|J=3/2,M=3/2>",
"|J=3/2,M=1/2>",
"|J=3/2,M=-1/2>",
"|J=3/2,M=-3/2>"}

To get from the j1j2 basis to the JM basis, we applied diagonalisetsquare:
 [Technical Note: space between entries again increased.]

MatrixForm[JMbasis,TableSpacing->{6.5}]->MatrixForm[diagonalisetsquare.j1j2basis,TableSpacing->{2}]->MatrixForm[diagonalisetsquare.j1j2basisNπ,TableSpacing->{2}]

From that, we can easily read up the Clebsch-Gordan coefficients:
	< J,M | j1,m1;j2,m2> = diagonalisetsquare((entry))

And the inverse basis transformation is:

MatrixForm[j1j2basis,TableSpacing->{6.5}]->MatrixForm[j1j2basisNπ,TableSpacing->{6.5}]->MatrixForm[Inverse[diagonalisetsquare].JMbasis,TableSpacing->{2}]

Appendix: Ladder Operators (not for Math Methods)

Ladder (raising and lowering) operators of L-Basis

MatrixForm[Lplus=(L1+I L2)]
MatrixForm[Lminus=(L1-I L2)]

They obey the commutation relations

Lplus.Lminus-Lminus.Lplus== 2L3
L3.Lplus-Lplus.L3==Lplus
L3.Lminus-Lminus.L3==-Lminus

and generate states: 
from the lowest-weight eigenstate {0,0,1} (eigenvalue -1), by applying raising operator:

MatrixForm[{0,0,1}]
MatrixForm[Lplus.%]
MatrixForm[Lplus.%]
MatrixForm[Lplus.%]

from the highest-weight eigenstate {1, 0, 0} (eigenvalue + 1), by applying lowering operator :

MatrixForm[{1,0,0}]
MatrixForm[Lminus.%]
MatrixForm[Lminus.%]
MatrixForm[Lminus.%]

Ladder operators in T(xyz)-basis

MatrixForm[Simplify[diagonalisetsquare.(t1+I t2).Inverse[diagonalisetsquare]]]
MatrixForm[Simplify[diagonalisetsquare.(t1-I t2).Inverse[diagonalisetsquare]]]

These act, not surprisingly, also only on the invariant 2x2 and 4x4 subspaces -- and we recover the ladder operators of the 2x2 and 4x4 reps.