Weinberg-Winkel, Neutrino-Misch-Matrix, PMNS-Matrix, Schwache Wechselwirkung, Neutrinos
Formel

Die Fehlerfortpflanzung wurde nach Standard-Formel berechnet:
$\displaystyle \Delta y=\sum _{i}\left|{\frac {\partial y}{\partial x_{i}}}\right|\cdot \Delta x_{i}$
Code

Die meisten Ableitungen wurden nicht explicit, sondern direkt durch Mathematica durchgeführt. Der Code der durchgehenden Resultatsberechnung inkl. Fehlerrechnung ist hier aufgeführt (der Output des Codes mit den berechneten Resultaten ist darunter zu finden):
(* Version 180905A *)
(* Messwerte: *)
(* Alle Werte aus physics.nist.gov, am 11.3.2018 *)
(* Das Fehlerintervall entspricht jeweils der Standardabweichung sigma. Für das in den Texten verwendete Fehlerintervall 3sigma wird dieser Wert jeweils x3 gerechnet.*)
h =6.626070040*^-34; (*Js*)
hDelta = 0.000000081*^-34;(*Js*)
hquer = 1.054571800*^-34;(*Js*)
hquerDelta= 0.000000013*^-34;(*Js*)
e = 1.6021766208*^-19; (*C*)
eDelta = 0.0000000098*^-19; (*C*)
c = 299792458; (*m/s exakt*)
mu0 = 4*Pi*10^-7; (*N/A-2 exakt *)
epsilon0 = 1/(mu0*c^2); (*F/m exakt*)

melectron = 9.10938356*^-31; (*kg*)
melectronDelta = 0.00000011*^-31; (*kg*)
mmu =1.883531594*^-28;(*kg*)
mmuDelta = 0.000000048*^-28;(*kg*)
mtau =3.16747*^-27; (*kg*)
mtauDelta = 0.00029*^-27; (*kg*)

Gvorher = 6.67408*^-11; (*m3 kg-1 s-2*)
GvorherDelta = 0.00031*^-11; (*m3 kg-1 s-2*)


(* Ab hier berechnete Werte *)

(* Gravitationskonstante: *)
Kmikro = e^2/(4*epsilon0);
KmikroDelta = Abs[2*e/(4*epsilon0)]*eDelta;
Mmikro = (hquer*c)/2;
MmikroDelta = Abs[c/2]*hquerDelta;
muStrich =( 8/6*Mmikro-5/6*4*Kmikro)/(2*c^2);
muStrichDelta= (Abs[8/6]*MmikroDelta+
Abs[-5/6*4]*KmikroDelta)/(2*c^2);
Print["mu' = " ,NumberForm[muStrich ,11]," +/- ", NumberForm[3*muStrichDelta,2]]
lambdaStrich=(2*Kmikro/(c^2) - 2*muStrich)/8;
lambdaStrichDelta= (2/(c^2)*KmikroDelta - 2*muStrichDelta)/8;
Print["lambda' = " ,NumberForm[lambdaStrich ,11]," +/- ", NumberForm[3*lambdaStrichDelta,2]]
mu = 1/(4*muStrich);
muDelta = Abs[-1/(4*muStrich^2)]*muStrichDelta;
Print["mu = " ,NumberForm[mu ,11]," +/- ", NumberForm[3*muDelta,2]]
lambda = lambdaStrich/(2*muStrich*(2*muStrich+4*lambdaStrich));
Clear[muStrichX,lambdaStrichX];
lambdaDelta = Abs[D[lambdaStrichX/(2*muStrichX*(2*muStrichX+4*lambdaStrichX)),lambdaStrichX]]*lambdaStrichDelta +
Abs[ D[lambdaStrichX/(2*muStrichX*(2*muStrichX+4*lambdaStrichX)),muStrichX]]*muStrichDelta ;
muStrichX =muStrich;
lambdaStrichX=lambdaStrich;
Print["lambda = " ,NumberForm[lambda ,11]," +/- ", NumberForm[3*lambdaDelta,2]]
G = 2*c^4*muStrich/(8*Pi);
GDelta = Abs[2*c^4/(8*Pi)]*muStrichDelta;
Print["G (vorher, gemessen) = " ,Gvorher," +/- ", 3*GvorherDelta]
Print["G (berechnet) = " ,NumberForm[G ,8]," +/- ", NumberForm[3*GDelta,2]]


(* Hopf-Parameter: *)
mIso = 2*c^2*muStrich/Pi^2;
mIsoDelta = Abs[2*c^2/Pi^2]*muStrichDelta;
EIso = mIso*c^2;
EIsoDelta = mIsoDelta*c^2;
Print["mIso = " ,NumberForm[mIso ,9]," +/- ", NumberForm[3*mIsoDelta,2]]
Print["EIso = " ,NumberForm[EIso ,9]," +/- ", NumberForm[3*EIsoDelta,2]]
(*Clear[xi1,xi2Strich,eta];
NSolve[melectron-mIso==mIso*Sinh[xi1]*Cosh[eta] && mmu-mIso==mIso*Cos[xi2Strich]*Sinh[eta] && mtau-mIso==mIso*Sin[xi2Strich]*Sinh[eta],{xi1,xi2Strich,eta}];*)

(* xi2Strich: *)
xi2Strich=Abs[ArcTan[(mtau-mIso)/(mmu-mIso)]];
(* Fehlerfortpflanzung: *)
Clear[mmuX,mtauX,mIsoX];
xi2StrichDelta= Abs[D[ArcTan[(mtauX-mIsoX)/(mmuX-mIsoX)],mmuX]]*mmuDelta +
Abs[ D[ArcTan[(mtauX-mIsoX)/(mmuX-mIsoX)],mtauX]]*mtauDelta+
Abs[D[ArcTan[(mtauX-mIsoX)/(mmuX-mIsoX)],mIsoX]]*mIsoDelta;
mmuX=mmu;
mtauX=mtau;
mIsoX=mIso;
(* Resultat: *)
Print["xi2Strich = " ,NumberForm[xi2Strich,5] ," +/- ", NumberForm[3*xi2StrichDelta,2]]
xi2 = ArcTanh[Tan[xi2Strich]];
Clear[xi2StrichX];
xi2Delta =Abs[D[ArcTanh[Tan[xi2StrichX]],xi2StrichX]]*xi2StrichDelta;
xi2StrichX=xi2Strich;
Print["xi2 = " ,NumberForm[xi2,6]," +/- ", NumberForm[3*xi2Delta,2]]

(* eta: *)
eta=Abs[ ArcSinh[(mmu-mIso)/(mIso*Cos[xi2Strich])]];
(* Fehlerfortpflanzung: *)
Clear[mmuX,mtauX,mIsoX,xi2StrichX];
etaDelta= Abs[D[ ArcSinh[(mmuX-mIsoX)/(mIsoX*Cos[xi2StrichX])],mmuX]]*mmuDelta +
Abs[D[ ArcSinh[(mmuX-mIsoX)/(mIsoX*Cos[xi2StrichX])],mIsoX]]*mIsoDelta+
Abs[ D[ ArcSinh[(mmuX-mIsoX)/(mIsoX*Cos[xi2StrichX])],xi2StrichX]]*xi2StrichDelta;
mmuX=mmu;
mtauX=mtau;
mIsoX=mIso;
xi2StrichX=xi2Strich;
(* Resultat: *)
Print["eta = " ,NumberForm[eta,5] ," +/- ", NumberForm[3*etaDelta,2]]

(* xi1: *)
xi1= ArcSinh[(melectron-mIso)/(mIso*Cosh[eta])];
(* Fehlerfortpflanzung: *)
Clear[melectronX,mIsoX,etaX];
xi1Delta= Abs[D[ ArcSinh[(melectronX-mIsoX)/(mIsoX*Cosh[etaX])],melectronX]]*melectronDelta +
Abs[D[ ArcSinh[(melectronX-mIsoX)/(mIsoX*Cosh[etaX])],mIsoX]]*mIsoDelta+
Abs[D[ ArcSinh[(melectronX-mIsoX)/(mIsoX*Cosh[etaX])],etaX]]*etaDelta;
melectronX=melectron;
mIsoX=mIso;
etaX=eta;
(* Resultat: *)
Print["xi1 = " ,NumberForm[xi1 ,6]," +/- ", NumberForm[3*xi1Delta,2]]


(* Halbwinkel für komplexe Darstellung: *)
(* xi2Halbe: *)
xi2Halbe =xi2/2;
xi2HalbeDelta=xi2Delta/2;
xi2StrichHalbe = ArcTan[Tanh[xi2Halbe]];
Clear[xi2HalbeX];
xi2StrichHalbeDelta =Abs[D[ArcTan[Tanh[xi2HalbeX]],xi2HalbeX]]*xi2HalbeDelta;
xi2HalbeX=xi2Halbe;
Print["xi2Halbe = " ,NumberForm[xi2Halbe,5]," +/- ", NumberForm[3*xi2HalbeDelta,2]]
Print["xi2StrichHalbe = " ,NumberForm[xi2StrichHalbe,5]," +/- ", NumberForm[3*xi2StrichHalbeDelta,2]]
(* etaHalbe: *)
etaHalbe = eta/2;
etaHalbeDelta=etaDelta/2;
etaStrichHalbe = ArcTan[Tanh[etaHalbe]];
Clear[etaHalbeX];
etaStrichHalbeDelta =Abs[D[ArcTan[Tanh[etaHalbeX]],etaHalbeX]]*etaHalbeDelta;
etaHalbeX=etaHalbe;
Print["etaHalbe = " ,NumberForm[etaHalbe,5]," +/- ", NumberForm[3*etaHalbeDelta,2]]
Print["etaStrichHalbe = " ,NumberForm[etaStrichHalbe,5] ," +/- ", NumberForm[3*etaStrichHalbeDelta,2]]
(* xi1Halbe: *)
xi1Halbe =xi1/2;
xi1HalbeDelta=xi1Delta/2;
xi1StrichHalbe = ArcTan[Tanh[xi1Halbe]];
Clear[xi1HalbeX];
xi1StrichHalbeDelta =Abs[D[ArcTan[Tanh[xi1HalbeX]],xi1HalbeX]]*xi1HalbeDelta;
xi1HalbeX=xi1Halbe;
Print["xi1Halbe = " ,NumberForm[xi1Halbe,5]," +/- ", NumberForm[3*xi1HalbeDelta,2]]
Print["xi1StrichHalbe = " ,NumberForm[xi1StrichHalbe,6]," +/- ", NumberForm[3*xi1StrichHalbeDelta,2]]
E4 = EIso*Cosh[eta]*Cosh[xi1];
Clear[etaX,xi1X];
E4Delta = Abs[Cosh[etaX]*Cosh[xi1X]]*EIsoDelta +
Abs[D[EIso*Cosh[etaX]*Cosh[xi1X],etaX]]*etaDelta +
Abs[D[EIso*Cosh[etaX]*Cosh[xi1X],xi1X]]*xi1Delta;
etaX=eta;
xi1X=xi1;
Print["E4 = " ,NumberForm[E4,5]," +/- ", NumberForm[3*E4Delta,2]]
Print["m4 = " ,NumberForm[E4/c^2,5]," +/- ", NumberForm[3*E4Delta/c^2,2]]
Print[""]
Print[""]


(* Weinberg-Winkel: *)
x0=Cos[etaStrichHalbe]*Sin[xi1StrichHalbe];
x1=Sin[etaStrichHalbe]*Cos[xi2StrichHalbe];
x2=Sin[etaStrichHalbe]*Sin[xi2StrichHalbe];
x3=Cos[etaStrichHalbe]*Cos[xi1StrichHalbe];
x0^2+x1^2+x2^2+x3^2;
vi={0,0,0,1};
vf={x0,x1,x2,x3};
(* eigentliche Rechnung via Skalarprodukt: *)
thetaW=ArcCos[vi.vf/((vi.vi)^0.5 *(vf.vf)^0.5)];
(* Kurzform, da vi = {0,0,0,1}: *)
thetaW=ArcCos[x3];
(* Fehlerfortpflanzung: *)
Clear[etaStrichHalbeX, xi1StrichHalbeX];
x3Delta=Abs[D[Cos[etaStrichHalbeX]*Cos[xi1StrichHalbeX],etaStrichHalbeX]]*etaStrichHalbeDelta+
Abs[D[Cos[etaStrichHalbeX]*Cos[xi1StrichHalbeX],xi1StrichHalbeX]]*xi1StrichHalbeDelta;
etaStrichHalbeX=etaStrichHalbe;
xi1StrichHalbeX=xi1StrichHalbe;
(*Print["x3 = " ,NumberForm[x3,6]," +/- ", NumberForm[3*x3Delta,2]]*)
Clear[x3X];
thetaWDelta=Abs[D[ArcCos[x3X],x3X]]*x3Delta;
x3X=x3;
(* Resultat: *)
Print["thetaW (grad) = " ,NumberForm[thetaW/Pi*180,6]," +/- ", NumberForm[3*thetaWDelta/Pi*180,2]]
Print["Sin(thetaW)^2 = " ,NumberForm[Sin[thetaW]^2,6]," +/- ", NumberForm[3*(2*Sin[thetaW]*Cos[thetaW])*thetaWDelta,2]]
Print[""]
Print[""]
(* Dasselbe mit komplexen Koordinaten zur Kontrolle: *)
z1=x1+I*x2;
z1c=x1-I*x2;
z2=x3+I*x0;
z2c=x3-I*x0;
wi={0,1}; 
wic={0,1};
wf={z1, z2};
wfc={z1c, z2c};
ArcCos[Re[wi.wfc/(wi.wic*wf.wfc)]]/Pi*180 ;(* en.wikipedia.org/wiki/Dot_product *)



(* Hopf-Map: *)
(* 1. Allgemeine Rechnung: *)
Clear[a1,a2,b];
x0=Cos[b/2]*Sin[a1/2];
x1=Sin[b/2]*Cos[a2/2];
x2=Sin[b/2]*Sin[a2/2];
x3=Cos[b/2]*Cos[a1/2];
Simplify[x0^2+x1^2+x2^2+x3^2];
z1=x1+I*x2; (* entspricht w bei Niles Johnson *)
z1c=x1-I*x2;
z2=x3+I*x0; (* entspricht z bei Niles Johnson *)
z2c=x3-I*x0;
xy=FullSimplify[2*z1c*z2];
x=FullSimplify[z1c*z2+z1*z2c]; (*x, Realteil von 2z1*z2c (siehe Wolfram)*)
y=FullSimplify[z1c*z2-z1*z2c]; (* i*y, Imaginärteil*)
z=FullSimplify[z2*z2c-z1*z1c]; (*z*)
(* Resultat: *)
Print["Hopf-Abbildung allgemein:"]
Print[" v = ",MatrixForm[{"Re" StandardForm[xy],"Im" StandardForm[xy],z}]]
(*gespiegelt durch Vertauschung von x0 und x3 *)
x0=I*Cos[b/2]*Sin[a1/2];
x1=Sin[b/2]*Cos[a2/2];
x2=Sin[b/2]*Sin[a2/2];
x3=I*Cos[b/2]*Cos[a1/2];
(* Achtung: Anpassung Komplex Konjugiertes: *) 
Simplify[x0*(-x0)+x1^2+x2^2+x3*(-x3)];
z1=x1+I*x2;
z1c=x1-I*x2;
z2=x3-I*x0;
z2c=-x3-I*x0;
xyGespiegelt=FullSimplify[2*z1c*z2];
xGespiegelt=FullSimplify[z1c*z2+z1*z2c]; (*x, Realteil von 2z1*z2c (siehe Wolfram)*)
yGespiegelt=FullSimplify[z1c*z2-z1*z2c]; (* i*y, Imaginärteil*)
zGespiegelt=FullSimplify[z2*z2c-z1*z1c]; (*z*)
(* Resultat: *)
Print["Hopf-Abbildung mit x0- und x3-Achsen vertauscht (Spiegelung an 45°-Achse):"]
Print["v_gespiegelt = ",MatrixForm[{"Re" StandardForm[xyGespiegelt] ,"Im" StandardForm[xyGespiegelt],zGespiegelt}]]
Print[""]
Print[""]


(* 2. Hopf-Abbildung mit konkreten Werten: *)
Clear[x,y,z];
(* Winkel: *)
etaStrichHopf = ArcTan[Tanh[eta]];
xiStrichHopf = ArcTan[Tanh[(xi1-xi2)/2]];
(* Fehlerfortpflanzung: *)
Clear[etaX,xi1X,xi2X];
etaStrichHopfDelta = Abs[D[ArcTan[Tanh[etaX]], etaX]]*etaDelta;
xiStrichHopfDelta = Abs[D[ArcTan[Tanh[(xi1X-xi2X)/2]], xi1X]]*xi1Delta+
Abs[D[ArcTan[Tanh[(xi1X-xi2X)/2]], xi2X]]*xi2Delta;
etaX=eta;
xi1X=xi1;
xi2X=xi2;
Print["etaStrichHopf = " ,NumberForm[etaStrichHopf,6]," +/- ", NumberForm[3*etaStrichHopfDelta,2]]
Print["xiStrichHopf = " ,NumberForm[xiStrichHopf,5]," +/- ", NumberForm[3*xiStrichHopfDelta,2]]
(* Koordinaten: *)
x = Sin[etaStrichHopf]*Cos[xiStrichHopf];
y = Sin[etaStrichHopf]*Sin[xiStrichHopf];
z = Cos[etaStrichHopf];
vHopf={x,y,z};
(* Fehlerfortpflanzung: *)
Clear[etaStrichHopfX,xiStrichHopfX];
xDelta = Abs[D[Sin[etaStrichHopfX]*Cos[xiStrichHopfX], etaStrichHopfX]]*etaStrichHopfDelta+
Abs[D[Sin[etaStrichHopfX]*Cos[xiStrichHopfX], xiStrichHopfX]]*xiStrichHopfDelta;
yDelta = Abs[D[Sin[etaStrichHopfX]*Sin[xiStrichHopfX], etaStrichHopfX]]*etaStrichHopfDelta+
Abs[D[Sin[etaStrichHopfX]*Sin[xiStrichHopfX], xiStrichHopfX]]*xiStrichHopfDelta;
zDelta = Abs[D[Cos[etaStrichHopfX], etaStrichHopfX]]*etaStrichHopfDelta;
etaStrichHopfX=etaStrichHopf;
xiStrichHopfX=xiStrichHopf;
(* Resultat: *)
Print["x = " ,NumberForm[x,6]," +/- ", NumberForm[3*xDelta,2]]
Print["y = " ,NumberForm[y,6]," +/- ", NumberForm[3*yDelta,2]]
Print["z = " ,NumberForm[z,6]," +/- ", NumberForm[3*zDelta,2]]


(* Hopf-Abbildung mit Spiegelung: *)
Clear[xGespiegelt,yGespiegelt,zGespiegelt];
(* Winkel: *)
etaStrichHopfGespiegelt = ArcTan[Tanh[eta]];
xiStrichHopfGespiegelt = ArcTan[Tanh[(xi1+xi2)/2]];
(* Fehlerfortpflanzung: *)
Clear[etaX,xi1X,xi2X];
etaStrichHopfGespiegeltDelta = Abs[D[ArcTan[Tanh[etaX]], etaX]]*etaDelta;
xiStrichHopfGespiegeltDelta = Abs[D[ArcTan[Tanh[(xi1X+xi2X)/2]], xi1X]]*xi1Delta+
Abs[D[ArcTan[Tanh[(xi1X+xi2X)/2]], xi2X]]*xi2Delta;
etaX=eta;
xi1X=xi1;
xi2X=xi2;
Print["etaStrichHopfGespiegelt = " ,NumberForm[etaStrichHopfGespiegelt,6]," +/- ", NumberForm[3*etaStrichHopfGespiegeltDelta,2]]
Print["xiStrichHopfGespiegelt = " ,NumberForm[xiStrichHopfGespiegelt,5]," +/- ", NumberForm[3*xiStrichHopfGespiegeltDelta,2]]
(* Koordinaten: *)
xGespiegelt = Sin[etaStrichHopfGespiegelt]*Sin[xiStrichHopfGespiegelt];
yGespiegelt = Sin[etaStrichHopfGespiegelt]*Cos[xiStrichHopfGespiegelt];
zGespiegelt = Cos[etaStrichHopfGespiegelt];
vHopfGespiegelt={xGespiegelt,yGespiegelt,zGespiegelt};
(* Fehlerfortpflanzung: *)
Clear[etaStrichHopfGespiegeltX,xiStrichHopfGespiegeltX];
xGespiegeltDelta = Abs[D[-Sin[etaStrichHopfGespiegeltX]*Sin[xiStrichHopfGespiegeltX], etaStrichHopfGespiegeltX]]*etaStrichHopfGespiegeltDelta+
Abs[D[-Sin[etaStrichHopfGespiegeltX]*Sin[xiStrichHopfGespiegeltX], xiStrichHopfGespiegeltX]]*xiStrichHopfGespiegeltDelta;
yGespiegeltDelta = Abs[D[Sin[etaStrichHopfGespiegeltX]*Cos[xiStrichHopfGespiegeltX], etaStrichHopfGespiegeltX]]*etaStrichHopfGespiegeltDelta+
Abs[D[Sin[etaStrichHopfGespiegeltX]*Cos[xiStrichHopfGespiegeltX], xiStrichHopfGespiegeltX]]*xiStrichHopfGespiegeltDelta;
zGespiegeltDelta = Abs[D[Cos[etaStrichHopfGespiegeltX], etaStrichHopfGespiegeltX]]*etaStrichHopfGespiegeltDelta;
etaStrichHopfGespiegeltX=etaStrichHopfGespiegelt;
xiStrichHopfGespiegeltX=xiStrichHopfGespiegelt;
(* Resultat: *)
Print["x_gespiegelt = " ,NumberForm[xGespiegelt,6]," +/- ", NumberForm[3*xGespiegeltDelta,2]]
Print["y_gespiegelt = " ,NumberForm[yGespiegelt,6]," +/- ", NumberForm[3*yGespiegeltDelta,2]]
Print["z_gespiegelt = " ,NumberForm[zGespiegelt,6]," +/- ", NumberForm[3*zGespiegeltDelta,2]]


(* Transformationsmatrix zwischen vHopf und vHopfGespiegelt, unter Berücksichtigung der Phasenverschiebung: *)
(* Phase: *)
phaseHopf=2*Pi+ArcTan[Tanh[(xi1-xi2)/2-(1)*(xi1+xi2)/2]];
Clear[xi1X, xi2X];
(* Fehlerfortpflanzung: *)
phaseHopfDelta=Abs[D[ArcTan[Tanh[(xi1X-xi2X)/2-(1)*(xi1X+xi2X)/2]],xi1X]]*xi1Delta+
Abs[D[ArcTan[Tanh[(xi1X-xi2X)/2-(1)*(xi1X+xi2X)/2]],xi2X]]*xi2Delta;
xi1X=xi1;
xi2X=xi2;
(* Projektion von vHopf: *)
Rphase={{1,0,0},{0,1,0},{0,0,Cos[phaseHopf]}};
vHopf={x,y,z};
vHopfGespiegelt={xGespiegelt,yGespiegelt,zGespiegelt};
vHopfPhase=Rphase.vHopf;
(* Fehlerfortpflanzung: *)
zPhaseDelta=Abs[-Sin[phaseHopf]*zGespiegelt]*phaseHopfDelta+Abs[Cos[phaseHopf]]*zGespiegeltDelta;
(* Resultat: *)
vHopfPhaseNorm = vHopfPhase/(vHopfPhase.vHopfPhase)^0.5;
xPhaseDeltaNorm=Abs[xDelta]/(vHopfPhase.vHopfPhase)^0.5;
yPhaseDeltaNorm=Abs[yDelta]/(vHopfPhase.vHopfPhase)^0.5;
zPhaseDeltaNorm=Abs[zPhaseDelta]/(vHopfPhase.vHopfPhase)^0.5;
(* Ermittlung der Drehmatrix R zwischen projiziertem vHopf und vHopfgespiegelt: *)
(* Drehwinkel phi: *)
phi=ArcCos[vHopfGespiegelt.vHopfPhaseNorm/((vHopfGespiegelt.vHopfGespiegelt)^0.5*(vHopfPhaseNorm.vHopfPhaseNorm)^0.5)]
Clear[phiX];
(* Fehlerfortpflanzung: *)
phiDeltaX=Abs[vHopfGespiegelt[[1]]]*xPhaseDeltaNorm+Abs[vHopfPhaseNorm[[1]]]*xGespiegeltDelta+
Abs[vHopfGespiegelt[[2]]]*yPhaseDeltaNorm+Abs[vHopfPhaseNorm[[2]]]*yGespiegeltDelta+
Abs[ vHopfGespiegelt[[3]]]*zPhaseDeltaNorm+Abs[vHopfPhaseNorm[[3]]]*zGespiegeltDelta;
phiDelta=Abs[D[ArcCos[phiX/((vHopfGespiegelt.vHopfGespiegelt)^0.5*(vHopfPhaseNorm.vHopfPhaseNorm)^0.5)],phiX]]*phiDeltaX;
phiX=phi;
(* Resultat: *)
Print["Drehwinkel phi = " ,NumberForm[phi,6]," +/- ", NumberForm[3*phiDelta,2]]
Print["Drehwinkel phi = " ,NumberForm[phi*180/Pi,5]," +/- ", NumberForm[3*phiDelta*180/Pi,2],"°"]
(* Drehachse r: *)
r=Cross[vHopfGespiegelt,vHopfPhaseNorm];
(* Fehlerfortpflanzung: *)
rxDelta=Abs[Abs[vHopfGespiegelt[[2]]]*zPhaseDeltaNorm+Abs[vHopfPhaseNorm[[3]]]*yGespiegeltDelta+
Abs[-vHopfGespiegelt[[3]]]*yPhaseDeltaNorm+Abs[-vHopfPhaseNorm[[2]]]*zGespiegeltDelta]/(r.r)^0.5;
ryDelta=Abs[Abs[vHopfGespiegelt[[3]]]*xPhaseDeltaNorm+Abs[vHopfPhaseNorm[[1]]]*zGespiegeltDelta+
Abs[-vHopfGespiegelt[[1]]]*zPhaseDeltaNorm+Abs[-vHopfPhaseNorm[[3]]]*xGespiegeltDelta]/(r.r)^0.5;
rzDelta=Abs[Abs[vHopfGespiegelt[[1]]]*yPhaseDeltaNorm+Abs[vHopfPhaseNorm[[2]]]*xGespiegeltDelta+
Abs[-vHopfGespiegelt[[2]]]*xPhaseDeltaNorm+Abs[-vHopfPhaseNorm[[1]]]*yGespiegeltDelta]/(r.r)^0.5;
(* Resultat: *)
r=r/(r.r)^0.5;
rx=r[[1]];
ry=r[[2]];
rz=r[[3]];
(* Drehmatrix R: *)
R={{Cos[phi]+rx^2*(1-Cos[phi]),rx*ry*(1-Cos[phi])-rz*Sin[phi],rx*rz*(1-Cos[phi])+ry*Sin[phi ]},
{ry*rx*(1-Cos[phi])+rz*Sin[phi],Cos[phi]+ry^2*(1-Cos[phi]),ry*rz*(1-Cos[phi])-rx*Sin[phi ]},
{rz*rx*(1-Cos[phi])-ry*Sin[phi],rz*ry*(1-Cos[phi])+rx*Sin[phi],Cos[phi]+rz^2*(1-Cos[phi])}};
Clear[rxX,ryX,rzX,phiX];
(* Fehlerfortpflanzung (nur für später weiterverwendete Elemente): *)
R13Delta=Abs[D[rxX*rzX*(1-Cos[phiX])+ryX*Sin[phiX],rxX]]*rxDelta+
Abs[D[rxX*rzX*(1-Cos[phiX])+ryX*Sin[phiX],ryX]]*ryDelta+
Abs[D[rxX*rzX*(1-Cos[phiX])+ryX*Sin[phiX],rzX]]*rzDelta+
Abs[D[rxX*rzX*(1-Cos[phiX])+ryX*Sin[phiX],phiX]]*phiDelta;
R12Delta=Abs[D[rxX*ryX*(1-Cos[phiX])-rzX*Sin[phiX],rxX]]*rxDelta+
Abs[D[rxX*ryX*(1-Cos[phiX])-rzX*Sin[phiX],ryX]]*ryDelta+
Abs[D[rxX*ryX*(1-Cos[phiX])-rzX*Sin[phiX],rzX]]*rzDelta+
Abs[D[rxX*ryX*(1-Cos[phiX])-rzX*Sin[phiX],phiX]]*phiDelta;
R23Delta=Abs[D[ryX*rzX*(1-Cos[phiX])-rxX*Sin[phiX],rxX]]*rxDelta+
Abs[D[ryX*rzX*(1-Cos[phiX])-rxX*Sin[phiX],ryX]]*ryDelta+
Abs[D[ryX*rzX*(1-Cos[phiX])-rxX*Sin[phiX],rzX]]*rzDelta+
Abs[D[ryX*rzX*(1-Cos[phiX])-rxX*Sin[phiX],phiX]]*phiDelta;
rxX=rx;
ryX=ry;
rzX=rz;
phiX=phi;


(* Zusammenbringen von Drehung und Phasenverschiebung in Matrix U: *)
U=R.Rphase;
(* Fehlerfortpflanzung: *)
U13Delta=Abs[Cos[phaseHopf]]*R13Delta+Abs[-Sin[phaseHopf]*R[[1,3]]]*phaseHopfDelta;
U12Delta=R12Delta;
U23Delta=Abs[Cos[phaseHopf]]*R23Delta+Abs[-Sin[phaseHopf]*R[[2,3]]]*phaseHopfDelta;
(* Kontrollen: *)
MatrixForm[vHopfGespiegelt]
vHopfTest=Transpose[R].Rphase.vHopf;
MatrixForm[vHopfTest/(vHopfTest.vHopfTest)^0.5]
MatrixForm[R]
Det[R]
MatrixForm[U]
Abs[Det[U]]
(* Resultat: *)
theta13=ArcSin[U[[1,3]]];
Clear[U13X];
theta13Delta=Abs[D[ArcSin[U13X],U13X]]*U13Delta;
U13X=U[[1,3]];
Print["Theta13 = " ,NumberForm[theta13*180/Pi,4]," +/- ", NumberForm[3*theta13Delta*180/Pi,2],"°"]

theta12=ArcSin[U[[1,2]]/Cos[theta13]];
Clear[U12X,theta13X];
theta12Delta=Abs[D[ArcSin[U12X/Cos[theta13X]],U12X]]*U12Delta+
Abs[D[ArcSin[U12X/Cos[theta13X]],theta13X]]*theta13Delta;
U12X=U[[1,2]];
theta13X=theta13;
Print["Theta12 = " ,NumberForm[theta12*180/Pi,5]," +/- ", NumberForm[3*theta12Delta*180/Pi,2],"°"]

theta23=ArcSin[U[[2,3]]/Cos[theta13]];
Clear[U23X,theta13X];
theta23Delta=Abs[D[ArcSin[U23X/Cos[theta13X]],U23X]]*U23Delta+
Abs[D[ArcSin[U23X/Cos[theta13X]],theta13X]]*theta13Delta;
U23X=U[[2,3]];
theta13X=theta13;
Print["Theta23 = " ,NumberForm[theta23*180/Pi,5]," +/- ", NumberForm[3*theta23Delta*180/Pi,2],"°"]

Print["Phase = " ,NumberForm[(phaseHopf-2*Pi)*180/Pi,7]," +/- ", NumberForm[3*phaseHopfDelta*180/Pi,2],"°"]
Print["Phase+2Pi = " ,NumberForm[phaseHopf*180/Pi,7]," +/- ", NumberForm[3*phaseHopfDelta*180/Pi,2],"°"]

Print["R13 = " ,NumberForm[R[[1,3]],5]," +/- ", NumberForm[3*R13Delta,2]]
Print["R12 = " ,NumberForm[R[[1,2]],5]," +/- ", NumberForm[3*R12Delta,2]]
Print["R23 = " ,NumberForm[R[[2,3]],5]," +/- ", NumberForm[3*R23Delta,2]]
Print["U13 = " ,NumberForm[U[[1,3]],5]," +/- ", NumberForm[3*U13Delta,2]]
Print["U12 = " ,NumberForm[U[[1,2]],5]," +/- ", NumberForm[3*U12Delta,2]]
Print["U23 = " ,NumberForm[U[[2,3]],5]," +/- ", NumberForm[3*U23Delta,2]]