♦ Hinweis zu Hausübung VII, Aufgabe H::2: Gammaitis

Solche algebraischen Identitäten kann man zwar mit Programmen wie Maple nicht einfach beweisen, aber natürlich leicht überprüfen. Dies sei hier am Beispiel der Dirac -Matrizen vorgeführt.

> with(linalg):

> unprotect(gamma);

ACHTUNG: Maple kann keine hochgestellten Indizes. Im allgemeinen sind alle Indizes hier als obere Indizes zu verstehen!

Die Pauli-Matrizen zusammen mit der 2x2 Identität:

> sigma[0] := matrix(2,2,[ 1, 0, 0, 1]);
sigma[1] := matrix(2,2,[ 0, 1, 1, 0]);
sigma[2] := matrix(2,2,[ 0,-I, I, 0]);
sigma[3] := matrix(2,2,[ 1, 0, 0,-1]);

Die 4x4 Identität und die Minkowski-Metrik in unserer Konvention:

> eins := matrix(4,4,[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1]);

> eta := matrix(4,4,[1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,-1]);

Die Dirac-Matrizen in der hier zu untersuchenden Darstellung:

> gamma[0] := matrix(4,4,[ 0, 0, 1, 0,
0, 0, 0, 1,
1, 0, 0, 0,
0, 1, 0, 0]);
gamma[1] := matrix(4,4,[ 0, 0, 0, 1,
0, 0, 1, 0,
0,-1, 0, 0,
-1, 0, 0, 0]);
gamma[2] := matrix(4,4,[ 0, 0, 0,-I,
0, 0, I, 0,
0, I, 0, 0,
-I, 0, 0, 0]);
gamma[3] := matrix(4,4,[ 0, 0, 1, 0,
0, 0, 0,-1,
-1, 0, 0, 0,
0, 1, 0, 0]);

Ausrechnen von :

> gamma[5] := evalm(I*gamma[0]&*gamma[1]&*gamma[2]&*gamma[3]);

Ausrechnen von . Durch Vergleich mit sieht man, daß dies in der Tat genau ist:

> gamma[0,`+`] := evalm(gamma[0]&*gamma[0]&*gamma[0]);
gamma[1,`+`] := evalm(gamma[0]&*gamma[1]&*gamma[0]);
gamma[2,`+`] := evalm(gamma[0]&*gamma[2]&*gamma[0]);
gamma[3,`+`] := evalm(gamma[0]&*gamma[3]&*gamma[0]);

Test, ob auch wirklich ist:

> evalm(gamma[0]&*gamma[0,`+`]);
evalm(gamma[1]&*gamma[1,`+`]);
evalm(gamma[2]&*gamma[2,`+`]);
evalm(gamma[3]&*gamma[3,`+`]);

Die Matrix gamma^5 erfüllt offenbar :

> evalm(gamma[5]&*gamma[5]);

Die Operatoren und sind Projektoren, erfüllen also :

> PI[`+`] := evalm(1/2*(eins+gamma[5]));
evalm(PI[`+`]^2);
PI[`-`] := evalm(1/2*(eins-gamma[5]));
evalm(PI[`-`]^2);

Definition von Kommutator und Antikommutator:

> Com := (A,B) -> evalm(A&*B - B&*A);

> ACom:= (A,B) -> evalm(A&*B + B&*A);

Wenn man will, kann man testen, ob die oben definierten -Matrizen auch wirklich erfüllen:

> ACom(gamma[0],gamma[0]);
ACom(gamma[0],gamma[2]);
ACom(gamma[1],gamma[1]);
ACom(gamma[1],gamma[2]);

Definition der Matrix :

> Sigma := (m,n) -> Com(-1/4*gamma[m],gamma[n]);

Ein Beispiel, das Element , das selbst wieder eine 4x4 Matrix ist:

> Sigma[1,2]=Sigma(1,2);

Zu überprüfen ist die Behauptung, daß ist. In der Definition der nächsten Funktion muss aber beachtet werden, das Maple Matrix-Indizes immer von eins zählt, weshalb die Indizes der Minkowski-Metrix um eins verschoben auftreten.

> check1 := (k,l,m) -> Com(Sigma(k,l),gamma[m])=
evalm(eta[k+1,m+1]*gamma[l] - eta[l+1,m+1]*gamma[k]);

Hier ein paar Beispiele. Es kann passieren, daß Maple null statt einer Null-Matrix zurückliefert, was kein Grund zur Beunruhigung ist:

> check1(1,1,1);
check1(1,2,1);
check1(1,2,2);
check1(1,2,3);

Nun soll noch berechnet werden:

> check2 := (k,l,m,n) -> Com(Sigma(m,n),Sigma(k,l))=
evalm(eta[m+1,k+1]*Sigma(n,l)
- eta[m+1,l+1]*Sigma(n,k)
- eta[n+1,k+1]*Sigma(m,l)
+ eta[n+1,l+1]*Sigma(m,k));

Ein Beispiel:

> check2(0,1,0,2);

Man kann auch überprüfen, daß die -Matrizen die Form für j,k=1,2,3 bzw. haben:

> Sigma(2,3), evalm(I/2*sigma[1]);

> Sigma(0,3), evalm(I/2*sigma[3]);

>