% vim: set sts=4 et:

\input{./header}
\input{./shortcuts}

\graphicspath{{images/}{image_install/}}


\newcommand{\sheetnr}{1}
\newcommand{\issued}{16.04.2017}
\newcommand{\dueUni}{26.04.2017}
%\newcommand{\version}{1}   % if you need to release a corrected version, uncomment and increase this counter

\newcommand{\dd}[1][]{\text{d}^{#1}}
\newcommand{\Mod}{{\rm mod\,}}
\DeclareMathOperator{\tr}{Tr}

\showsolutions

\startsheet

\setcounter{exercise}{1}
\exercise[5.0]{Neutrino oscillations}



With neutrino oscillations, the ''familly lepton numbers'' are no longer conserved. This allowes for a process $\mu \to e \gamma$ to happen. 
\begin{enumerate}
\item Draw a Feynman diagram, where the neutrino oscilations are represented by a blob.
\item In this process you must ''borrow'' the necessary to make the virtual $W$. Accordingly to the uncertainty principle, how soon you must ''repay'' the debt? Given the fact that the neutrino oscillations happen over large distance is it likelly to that we can borrow that amount to make the $\mu \to e \gamma$?
\end{enumerate}

\setcounter{exercise}{2}
\exercise[5.0]{Yukawa Lagrangian}

Give physical interpretation of the Yukawa Lagrangian:
\begin{equation}
\mathcal{L} = \left[i \hbar \bar{\psi} \gamma^{\mu} \partial_{\mu} \psi - m_1 \bar{\psi} \psi \right] + \left[ \frac{1}{2} \left(\partial_{\mu} \phi \right)   \left(\partial^{\mu} \phi \right) - \frac{1}{2} \left( \frac{m_2}{\hbar}\right)^2 \phi^2  \right] - \alpha_Y \bar{\psi}\psi \phi
\end{equation}

\begin{itemize}
\item What are the spins and masses of the particles?
\item What are the propagators?
\item Draw a Feyman diagram for their interactions and determine the vertex factor.
\end{itemize}


\setcounter{exercise}{3}
\exercise[5.0]{CKM matrix}

Show at long as the CKM matrix is unitary, the GIM mechanism works for $n \geq 3$ generations. 
\begin{itemize}
\item How many independent parameters are there in $3\times3$ unitary matrix?
\item How many independent parameters are there in $3\times3$ real orthogonal matrix?
\item Can you reduce the CKM matrix to real form?
\end{itemize}

\setcounter{exercise}{4}
\exercise[5.0]{Generalized Klain-Gordon}

The Klain-Gordon lagrangian for a complex field would look like:
\begin{equation}
\mathcal{L}= \frac{\hbar i}{2} \left[ \bar{\psi} \gamma^{\mu} \left(\partial_{\mu} \psi \right) - \left(\partial_{\mu} \psi \right) \gamma^{\mu} \psi \right] -m\bar{\psi} \psi
\end{equation}

Treating both fields as independent deduce the field equations for each and show the fields are consistent.
 
\clearpage
\iffalse
\begin{solution}
\begin{subtasks}

\task The answers are:
\begin{center}
\begin{tabular}{| l | l | l |}
\hline
Decimal:					& Hexadecimal:					&	Binary: 				\\ \hline
$12$							& C												& 1100						\\ \hline
$53$							& 35											& 110101				\\ \hline
$123$						& 7B											& 1111011				\\ \hline
$431$						& 1AF										& 110101111			\\ \hline
\end{tabular}
\end{center}

A simple algorithm to convert an integer $N$ from decimal to hexadecimal is the following:
\begin{enumerate}
\item[1.] set $i=1$.
\item[2.] Compute $h_i = N_{\Mod 16}$, i.e.~the remainder of the integer (Euclidean) division $N\div16$.
\item[3.] Use the hexadecimal “dictionary" to convert $h_i$:

\begin{tabular}{| l | l | l | l | l | l | l | l | l | l | l | l | l | l | l | l | l |}
\hline
$h$:	& 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & 10 & 11 & 12 & 13 & 14 & 15 \\
\hline
hex: & 0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & A & B & C & D & E & F	\\
\hline
\end{tabular}
\item[4.] Replace $N \rightarrow (N - h_i)/16$, set $i=i+1$ and go back to step 2 until $N=0$.
\item[5.] The number in hexadecimal representation is: $h_n h_{n-1} \cdots h_2 h_1$
\end{enumerate}
This algorithm is actually valid for every base change.

Let us apply the algorithm above. 

$N=12$:
\begin{align*}
& i=1; 		&		\\
& h_1 = 12_{\Mod 16} = 12 \rightarrow \boxed{C};		&	\\
& N \rightarrow (N - 12)/16 =0; \\
&{\rm end:~} 12_{10} = \boxed{C_{16}}
\end{align*}
%
$N=53$:
\begin{align*}
& i=1																			&&	i=2	\\
& h_1 = 53_{\Mod 16} = 5 \rightarrow \boxed{5};		&	& h_2 = 3_{\Mod 16} = 3 \rightarrow \boxed{3} \\
& N \rightarrow (N - 5)/16 =3; 													&&	 N \rightarrow (N - 3)/16 =0; \\
&&&{\rm end:~} 53_{10} = \boxed{35_{16}}
\end{align*}
%
$N=123$:
\begin{align*}
& i=1 																				&&	i=2	\\
& h_1 = 123_{\Mod 16} = 11 \rightarrow \boxed{B};		&	& h_2 = 7_{\Mod 16} = 7 \rightarrow \boxed{7} \\
& N \rightarrow (N - 11)/16 =7; 													&&	 N \rightarrow (N - 7)/16 =0; \\
&&&{\rm end:~} 123_{10} = \boxed{7B_{16}}
\end{align*}
%
$N=431$:
\begin{align*}
& i=1 																				&&	i=2	  					&&i=3\\
& h_1 = 431_{\Mod 16} = 15 \rightarrow \boxed{F};		
&& h_2 = 26_{\Mod 16} = 10 \rightarrow \boxed{A} 
&& h_3 = 1_{\Mod 16} = 1 \rightarrow \boxed{1} 
\\
& N \rightarrow (N - 11)/16 =26; 		&&	 N \rightarrow (N - 10)/16 =1;  &&	 N \rightarrow (N - 1)/16 =0; \\
&&&&&{\rm end:~} 431_{10} = \boxed{1AF_{16}}
\end{align*}
%

The former algorithm can be applied also for the conversion in binary. One just need to change $\Mod 16 \rightarrow \Mod 2$ in step 2 and to divide by $2$ (not by $16$) in step 4.

$N=12$:
\begin{align*}
& i=1 		&&		i=2  && i=3 && i=4 \\
& h_1 = 12_{\Mod 2} = \boxed{0} 		&& h_2 = 6_{\Mod 2} = \boxed{0}	
&& h_3 = 3_{\Mod 2} = \boxed{1} && h_4 = 1_{\Mod 2} = \boxed{1} \\
& N \rightarrow (N - 0)/2 =6;  && N \rightarrow (N - 0)/2 =3; 
&& N \rightarrow (N - 1)/2 =1;  && N \rightarrow (N - 1)/2 =0; \\
&&&&&&&{\rm end:~} 12_{10} = \boxed{1100_{2}}
\end{align*}
%
$N=53$:
\begin{align*}
& i=1 		&&		i=2  && i=3 && i=4 \\
& h_1  = 53_{\Mod 2} = \boxed{1} 		&& h_2 = 26_{\Mod 2} = \boxed{0}	
&& h_3 = 13_{\Mod 2} = \boxed{1} && h_4 = 6_{\Mod 2} = \boxed{0} \\
& N \rightarrow  (N - 1)/2 =26;  && N \rightarrow (N - 0)/2 =13; 
&& N \rightarrow (N - 1)/2 =6;  && N \rightarrow (N - 0)/2 =3; \\
%
\\
%
& i=5 		&&		i=6  \\
& h_5  = 3_{\Mod 2} = \boxed{1} 		&& h_6 = 1_{\Mod 2} = \boxed{1}	\\
& N \rightarrow  (N - 1)/2 =1;  && N \rightarrow (N - 1)/2 =0;  \\
&&&{\rm end:~} 53_{10} = \boxed{110101_{2}}
\end{align*}
%
$N=123$:
\begin{align*}
& i=1; 		&&		i=2  && i=3 && i=4 \\
& h_1  = 123_{\Mod 2} = \boxed{1} 		&& h_2 = 61_{\Mod 2} = \boxed{1}	
&& h_3 = 30_{\Mod 2} = \boxed{0} && h_4 = 15_{\Mod 2} = \boxed{1} \\
& N \rightarrow  (N - 1)/2 =61;  && N \rightarrow (N - 1)/2 =30; 
&& N \rightarrow (N)/2 =15;  && N \rightarrow (N - 1)/2 =7; \\
%
\\
%
& i=5 		&&		i=6  && i=7\\
& h_5  = 7_{\Mod 2} = \boxed{1} 		&& h_6 = 3_{\Mod 2} = \boxed{1} && h_7 = 1_{\Mod 2} = \boxed{1}	\\
& N \rightarrow  (N - 1)/2 =3; && N \rightarrow  (N-1)/2 =1;  && N \rightarrow (N - 1)/2 =0;  \\
&&&{\rm end:~} 53_{10} = \boxed{1111011_{2}}
\end{align*}
%
$N=431$:
\begin{align*}
& i=1 		&&		i=2  && i=3 && i=4,5,6,7,8,9 \\
& h_1  = 431_{\Mod 2} = \boxed{1} 		&& h_2 = 215_{\Mod 2} = \boxed{1}	
&& h_3 = 107_{\Mod 2} = \boxed{1} && \dots ({\rm see~}N=53) \\
& N \rightarrow  (N - 1)/2 =215;  && N \rightarrow (N - 1)/2 = 107; 
&& N \rightarrow (N )/2 =53;  && \dots \\
\\
&	{\rm end:~} 431_{10} = \boxed{110101111_{2}}
\end{align*}
%

\task One needs to understand that the decimal representation of an integer is just a short-cut notation. With $124_{10}$ one really means:
\begin{equation*}
124_{10} = 1 \cdot 10^2 + 2 \cdot 10^1 + 4 \cdot 10^0 ~.
\end{equation*}
%
This is valid in \emph{every} basis. Thus is easy to find:
%
\begin{align*}
10011_{2} &= (1 \cdot 2^4 + 0 \cdot 2^3 + 0 \cdot 2^2 + 1 \cdot 2^1 + 1 \cdot 2^0)_{10}
						= (16+2+1)_{10} = 19_{10}
\\
1101_{2} &=(1 \cdot 2^3 + 1 \cdot 2^2 + 0 \cdot 2^1 + 1 \cdot 2^0)_{10}
					= (8+4+1)_{10} = 13_{10}
\\
A2_{16} &=(A \cdot 16^1 + 2 \cdot 16^0)_{10}
					= (10 \cdot 16 + 2)_{10} = 162_{10}
\\
1AD_{16} &=(1 \cdot 16^2 + A \cdot 16^1 + D \cdot 16^0)_{10}
					= (1 \cdot 256 + 10 \cdot 16 + 13)_{10} = 429_{10}
\end{align*}
%


\task Before converting a value into a floating number, one should convert it into a binary expression. We already know how to convert $-431_{10}$. To convert a non-integer number $N$ into binary, one can use an extension of the algorithm used in exercise (1a).
\begin{enumerate}
\item[1.] i=0.
\item[2.] Take $\lfloor N \rfloor$ (i.e.~integer part of $N$) and convert it into a binary expression 
(call it $h_i$).
\item[3.] Substitute $N \rightarrow 2(N - \lfloor N \rfloor)$.
\item[4.] Set $i=i+1$ and go back to step 2 until $N=0$ or you have reached the desired precision.
\item[5.] Your number is $h_0. h_1 h_2 \dots h_n$
\end{enumerate}
%

Let us convert $0.3125$ with the mentioned algorithm:
%
\begin{align*}
& i=0 		&&		i=1  && i=2 \\
& h_0  = \lfloor 0.3125 \rfloor = \boxed{0} 		&& h_1 =  \lfloor 0.625 \rfloor = \boxed{0}
&& h_2 =  \lfloor 1.25 \rfloor = \boxed{1}  \\
& N \rightarrow  2(N - \lfloor N \rfloor) = 0.625;  && N \rightarrow 2(N - \lfloor N) \rfloor) = 1.25; 
&& N \rightarrow 2(N - \lfloor N) \rfloor) = 0.5;    \\
\\
& i=3 		&&		i=4  \\
& h_3  = \lfloor 0.5 \rfloor = \boxed{0} 		&& h_1 =  \lfloor 1 \rfloor = \boxed{1}\\
& N \rightarrow  2(N - \lfloor N \rfloor) = 1;  && N \rightarrow 2(N - \lfloor N) \rfloor = 0; 
  \\
&&&	{\rm end:~} 0.3125_{10} = \boxed{0.0101_{2}}
\end{align*}
%
Thus $0.3125_{10} = 0.0101_{2} = (1.01 \cdot 2^{-2})_2$. Thus:
%
\begin{itemize}
\item[-] The sign is $+ \rightarrow 0$
\item[-] The exponent is $-2$. Exponent+bias: $-2+15=13=01101_2$.
\item[-] The mantissa is $1.010$. The first digit ($1.$) is not stored, and we store $0100000000$.
\end{itemize}
%
Thus we have:
%
\begin{equation*}
0.3125_{10} \rightarrow 	\underbrace{0}_{\rm sign}
														\underbrace{01101}_{\rm exp+bias}
														\underbrace{0100000000}_{\rm mantissa}
							\rightarrow	\underbrace{00110101}_{\rm byte~1} 
													~ \underbrace{00000000}_{\rm byte~2}
							\rightarrow	\underbrace{35~~00}_{\rm hexadecimal}
\end{equation*}
%

For $-431_{10}$ the exercise is similar. We have already computed $431_{10}=110101111 = 1.10101111 \cdot 2^{8}$. Thus:
%
\begin{itemize}
\item[-] The sign is $- \rightarrow 1$
\item[-] The exponent is $8$. Exponent+bias: $8+15=23=10111_2$.
\item[-] The mantissa is $1.10101111$. The first digit ($1.$) is not stored, and we store $1010111100$.
\end{itemize}
%
Thus we have:
%
\begin{equation*}
-431_{10} \rightarrow 	\underbrace{1}_{\rm sign}
														\underbrace{10111}_{\rm exp+bias}
														\underbrace{1010111100}_{\rm mantissa}
							\rightarrow	\underbrace{11011110}_{\rm byte~1} 
													~ \underbrace{10111100}_{\rm byte~2}
							\rightarrow	\underbrace{\rm DE~~BC}_{\rm hexadecimal}
\end{equation*}
%


\task We have already found the hexadecimal bytes representation for our floating numbers: $0.3125_{10}=35~00$ and $-431_{10}={\rm DE~BC}$.
In big endian, these bytes would be sequentially stored in the memory “from left to right", while in little endian the sequential storage would go in the other direction. Explicitly:
%
\begin{align*}
0.3125_{10}  \rightarrow ~& {\rm big~endian:~}
					\underbrace{\boxed{35}}_{\rm slot~i}~\underbrace{\boxed{00}}_{\rm slot~i+1}
&
-431_{10}  \rightarrow ~& {\rm big~endian:~}
					\underbrace{\boxed{\rm DE}}_{\rm slot~i}~\underbrace{\boxed{\rm BC}}_{\rm slot~i+1}
\\
					\rightarrow ~& {\rm little~endian:~}
					\underbrace{\boxed{00}}_{\rm slot~i}~\underbrace{\boxed{35}}_{\rm slot~i+1}
&
					\rightarrow ~& {\rm little~endian:~}
					\underbrace{\boxed{\rm BC}}_{\rm slot~i}~\underbrace{\boxed{\rm DE}}_{\rm slot~i+1}
\end{align*}
%


\task  
The number $2050$ expressed in binary is $100000000010$.

In {\it binary16} its representation is:
%
\begin{equation}
	\underbrace{0}_{\rm sign}
	\underbrace{11010}_{\rm exp+bias}
	\underbrace{0000000001}_{\rm mantissa}
	~~\Rightarrow~~
	+ \;
	2^{26 - 15} \times
	1.0000000001
	=
	1.0000000001 \times 2^{11}
\end{equation}
%
From this representation is already clear that the {\it binary16} precision doesn't allow to store numbers like $2049$ or $2051$ at all, since this would require a 12 digit precision.

Thus, both in INPUT A and in INPUT B, the code is requiring the machine a precision it cannot reach. As it should be clear from how the number $2050$ is stored, the machine has reached it maximal precision and it cannot store the number $2051$ whatsoever. This means that at each step in which the number $2051$ is met, the machine truncate it consistently with its maximum working precision, returning $2050$.

INPUT C is well written and works fine. Differently from INPUT B, this time the machine works \emph{at first} with numbers of order 1, which are manipulated without difficulties. For example, the {\it binary16} representation of $5$ would be:
%
\begin{equation}
	\underbrace{0}_{\rm sign}
	\underbrace{10001}_{\rm exp+bias}
	\underbrace{0100000000}_{\rm mantissa -1}
	~~\Rightarrow~~
	+ \;
	2^{17 - 15} \times
	1.0100000000
	=
	1.01 \times 2^2 = 101_2
\end{equation}
%
where indeed $101_2=5_{10}$. After having dealt with all order-1 numbers, it finally sums them to 2050, getting 2060 which is a perfectly storable number.

In conclusion, one should be aware of the bad consequences of requiring the machine to work with more significant digits than its maximum.

\end{subtasks}
\end{solution}



\fi


\end{document}