from sympy.physics.quantum import *
from sympy.physics.quantum.cartesian import *
from sympy.physics.quantum.operator import *
from sympy.physics.quantum.state import *
from sympy import *
from sympy.core.relational import *
from sympy.abc import a, b, x, y, z, t, alpha, n, theta, h, f, lamda, i, k, w, u, d, beta, r, psi, o, l, c, gamma

ketU = Ket(u)
ketD = Ket(d)
braU = Bra(u)
braD = Bra(d)

ketUExpanded = Matrix([[1],[0]])
display(ketUExpanded)
braUExpanded = conjugate(ketUExpanded.T)
display(braUExpanded)

$\displaystyle \left[\begin{matrix}1\\0\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}1 & 0\end{matrix}\right]$

ketDExpanded = Matrix([[0],[1]])
display(ketDExpanded)
braDExpanded = conjugate(ketDExpanded.T)
display(braDExpanded)

$\displaystyle \left[\begin{matrix}0\\1\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}0 & 1\end{matrix}\right]$

kettheta = Ket(theta)
display(kettheta)
bratheta = Bra(theta)
display(bratheta)

$\displaystyle {\left|\theta\right\rangle }$

$\displaystyle {\left\langle \theta\right|}$

ketthetaExpanded = alpha * ketUExpanded + beta * ketDExpanded
display(ketthetaExpanded)
brathetaExpanded = conjugate(ketthetaExpanded.T)
display(brathetaExpanded)

$\displaystyle \left[\begin{matrix}\alpha\\\beta\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}\overline{\alpha} & \overline{\beta}\end{matrix}\right]$

valOfKettheta = Eq(kettheta,
               Eq(ketthetaExpanded,
                    ketthetaExpanded[0] * ketU + ketthetaExpanded[1] * ketD,
                  evaluate = False),  
               evaluate = False)
display(valOfKettheta)

$\displaystyle {\left|\theta\right\rangle } = \left[\begin{matrix}\alpha\\\beta\end{matrix}\right] = \alpha {\left|u\right\rangle } + \beta {\left|d\right\rangle }$

P_u, P_d = symbols('P_u P_d')

probU = Eq(P_u, ketthetaExpanded[0] * conjugate(ketthetaExpanded[0]))
display(probU)

$\displaystyle P_{u} = \alpha \overline{\alpha}$

probD = Eq(P_d, ketthetaExpanded[1] * conjugate(ketthetaExpanded[1]))
display(probD)

$\displaystyle P_{d} = \beta \overline{\beta}$

totalProb = Eq(ketthetaExpanded[0] * conjugate(ketthetaExpanded[0]) + ketthetaExpanded[1] * conjugate(ketthetaExpanded[1]), 1)
display(totalProb)

$\displaystyle \alpha \overline{\alpha} + \beta \overline{\beta} = 1$

Mul(0, ketD, evaluate = False)

$\displaystyle 0 {\left|d\right\rangle }$

valOfKettheta = Eq(kettheta,
                    ketthetaExpanded[0] * ketU + ketthetaExpanded[1] * ketD,
                  evaluate = False)
display(valOfKettheta)

$\displaystyle {\left|\theta\right\rangle } = \alpha {\left|u\right\rangle } + \beta {\left|d\right\rangle }$

valOfKetU = Eq(ketU,
                    Add(Mul(ketUExpanded[0], ketU, evaluate = False),  Mul(ketUExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetU)

$\displaystyle {\left|u\right\rangle } = 0 {\left|d\right\rangle } + {\left|u\right\rangle }$

valOfKetD = Eq(ketD,
                    Add(Mul(ketDExpanded[0], ketU, evaluate = False),  Mul(ketDExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetD)

$\displaystyle {\left|d\right\rangle } = {\left|d\right\rangle } + 0 {\left|u\right\rangle }$

ketR = Ket(r)
ketL = Ket(l)
braR = Bra(r)
braL = Bra(l)

ketRExpanded = Matrix([[1/sqrt(2)],[1/sqrt(2)]])
display(ketRExpanded)
braRExpanded = conjugate(ketRExpanded.T)
display(braRExpanded)

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2}\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2}\end{matrix}\right]$

ketLExpanded = Matrix([[1/sqrt(2)],[-1/sqrt(2)]])
display(ketLExpanded)
braLExpanded = conjugate(ketLExpanded.T)
display(braLExpanded)

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2}\\- \frac{\sqrt{2}}{2}\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2}}{2}\end{matrix}\right]$

valOfKetR = Eq(ketR,
                    Add(Mul(ketRExpanded[0], ketU, evaluate = False),  Mul(ketRExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetR)

$\displaystyle {\left|r\right\rangle } = \frac{\sqrt{2}}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

i = symbols('I')

ketI = Ket(i)
ketO = Ket(o)
braI = Bra(i)
braO = Bra(o)

ketIExpanded = Matrix([[1/sqrt(2)],[I/sqrt(2)]])
display(ketIExpanded)
braIExpanded = conjugate(ketIExpanded.T)
display(braIExpanded)

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2} i}{2}\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2} i}{2}\end{matrix}\right]$

ketOExpanded = Matrix([[1/sqrt(2)],[-I/sqrt(2)]])
display(ketOExpanded)
braOExpanded = conjugate(ketOExpanded.T)
display(braOExpanded)

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2}\\- \frac{\sqrt{2} i}{2}\end{matrix}\right]$

$\displaystyle \left[\begin{matrix}\frac{\sqrt{2}}{2} & \frac{\sqrt{2} i}{2}\end{matrix}\right]$

valOfKetI = Eq(ketI,
                    Add(Mul(ketIExpanded[0], ketU, evaluate = False),  Mul(ketIExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetI)

$\displaystyle {\left|I\right\rangle } = \frac{\sqrt{2} i}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

HPlus = HermitianOperator('H_+')
sigma_z = HermitianOperator('sigma_z')

HPlusExpanded = Matrix([[1, 0],[0, -1]])
display(HPlusExpanded)

$\displaystyle \left[\begin{matrix}1 & 0\\0 & -1\end{matrix}\right]$

hermitianOpForU_D = Eq(Eq(HPlus, HPlusExpanded, evaluate = False), sigma_z, evaluate = False)
display(hermitianOpForU_D)

$\displaystyle H_{+} = \left[\begin{matrix}1 & 0\\0 & -1\end{matrix}\right] = \sigma_{z}$

HCross = HermitianOperator(r'H_\times')
sigma_x = HermitianOperator('sigma_x')

HCrossExpanded = Matrix([[0, 1],[1, 0]])
display(HCrossExpanded)

$\displaystyle \left[\begin{matrix}0 & 1\\1 & 0\end{matrix}\right]$

hermitianOpForR_L = Eq(Eq(HCross, HCrossExpanded, evaluate = False), sigma_x, evaluate = False)
display(hermitianOpForR_L)

$\displaystyle H_\times = \left[\begin{matrix}0 & 1\\1 & 0\end{matrix}\right] = \sigma_{x}$

HCircular = HermitianOperator(r'H_\circlearrowleft')
sigma_y = HermitianOperator('sigma_y')

HCircularExpanded = Matrix([[0, -I],[I, 0]])
display(HCircularExpanded)

$\displaystyle \left[\begin{matrix}0 & - i\\i & 0\end{matrix}\right]$

hermitianOpForI_O = Eq(Eq(HCircular, HCircularExpanded, evaluate = False), sigma_y, evaluate = False)
display(hermitianOpForI_O)

$\displaystyle H_\circlearrowleft = \left[\begin{matrix}0 & - i\\i & 0\end{matrix}\right] = \sigma_{y}$

ketPsi = Ket(psi)
braPsi = Bra(psi)

H = HermitianOperator('H')

prodOfH_ketPsi = Eq(H * ketPsi, lamda * ketPsi)
display(prodOfH_ketPsi)

$\displaystyle H {\left|\psi\right\rangle } = \lambda {\left|\psi\right\rangle }$

innerprodOfR_U = Eq(Eq(Abs(InnerProduct(braR, ketU), evaluate = False)**2,
                      Abs(MatMul(braRExpanded, ketUExpanded), evaluate = False)**2,
                      evaluate = False), 
                   (Abs(braRExpanded * ketUExpanded)**2).simplify(), 
                   evaluate = False)
display(innerprodOfR_U)

$\displaystyle \left|{\left\langle r \right. {\left|u\right\rangle }}\right|^{2} = \left|{\left[\begin{matrix}\frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2}\end{matrix}\right] \left[\begin{matrix}1\\0\end{matrix}\right]}\right|^{2} = \left[\begin{matrix}\frac{1}{2}\end{matrix}\right]$

innerprodOfI_L = Eq(Eq(Abs(InnerProduct(braI, ketL), evaluate = False)**2,
                      Abs(MatMul(braIExpanded, ketLExpanded), evaluate = False)**2,
                      evaluate = False), 
                   (Abs(braIExpanded * ketLExpanded)**2).simplify(), 
                   evaluate = False)
display(innerprodOfI_L)

$\displaystyle \left|{\left\langle I \right. {\left|l\right\rangle }}\right|^{2} = \left|{\left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2} i}{2}\end{matrix}\right] \left[\begin{matrix}\frac{\sqrt{2}}{2}\\- \frac{\sqrt{2}}{2}\end{matrix}\right]}\right|^{2} = \left[\begin{matrix}\frac{1}{2}\end{matrix}\right]$

prodOfH_ketPsi = Eq(H * ketPsi, lamda * ketPsi)
display(prodOfH_ketPsi)

$\displaystyle H {\left|\psi\right\rangle } = \lambda {\left|\psi\right\rangle }$

valOfKetPsi = Eq(ketPsi, alpha * ketU + beta * ketD)
display(valOfKetPsi)

$\displaystyle {\left|\psi\right\rangle } = \alpha {\left|u\right\rangle } + \beta {\left|d\right\rangle }$

probU = Eq(P_u, cos(theta)**2, evaluate = False)
display(probU)

$\displaystyle P_{u} = \cos^{2}{\left(\theta \right)}$

P_uAmp = symbols('P_uAmp')

probAmpU = Eq(P_uAmp, cos(theta), evaluate = False)
display(probAmpU)

$\displaystyle P_{uAmp} = \cos{\left(\theta \right)}$

probU = Eq(P_u, cos(theta/2)**2, evaluate = False)
display(probU)

$\displaystyle P_{u} = \cos^{2}{\left(\frac{\theta}{2} \right)}$

probAmpU = Eq(P_uAmp, cos(theta/2), evaluate = False)
display(probAmpU)

$\displaystyle P_{uAmp} = \cos{\left(\frac{\theta}{2} \right)}$

valOfKetTheta = Eq(kettheta, cos(theta/2) * ketU + sin(theta/2) * ketD)
display(valOfKetTheta)

$\displaystyle {\left|\theta\right\rangle } = \sin{\left(\frac{\theta}{2} \right)} {\left|d\right\rangle } + \cos{\left(\frac{\theta}{2} \right)} {\left|u\right\rangle }$

valOfKetU = Eq(ketU,
                    Add(Mul(ketUExpanded[0], ketU, evaluate = False),  Mul(ketUExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetU)

$\displaystyle {\left|u\right\rangle } = 0 {\left|d\right\rangle } + {\left|u\right\rangle }$

valOfKetD = Eq(ketD,
                    Add(Mul(ketDExpanded[0], ketU, evaluate = False),  Mul(ketDExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetD)

$\displaystyle {\left|d\right\rangle } = {\left|d\right\rangle } + 0 {\left|u\right\rangle }$

valOfKetR = Eq(ketR,
                    Add(Mul(ketRExpanded[0], ketU, evaluate = False),  Mul(ketRExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetR)

$\displaystyle {\left|r\right\rangle } = \frac{\sqrt{2}}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

valOfKetL = Eq(ketL,
                    Add(Mul(ketLExpanded[0], ketU, evaluate = False),  Mul(ketLExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetL)

$\displaystyle {\left|l\right\rangle } = - \frac{\sqrt{2}}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

valOfKetI = Eq(ketI,
                    Add(Mul(ketIExpanded[0], ketU, evaluate = False),  Mul(ketIExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetI)

$\displaystyle {\left|I\right\rangle } = \frac{\sqrt{2} i}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

valOfKetO = Eq(ketO,
                    Add(Mul(ketOExpanded[0], ketU, evaluate = False),  Mul(ketOExpanded[1], ketD, evaluate = False), evaluate = False),
                  evaluate = False)
display(valOfKetO)

$\displaystyle {\left|o\right\rangle } = - \frac{\sqrt{2} i}{2} {\left|d\right\rangle } + \frac{\sqrt{2}}{2} {\left|u\right\rangle }$

addOfR_L = Eq((ketR + ketL)/sqrt(2), ketU)
display(addOfR_L)

$\displaystyle \frac{\sqrt{2} \left({\left|l\right\rangle } + {\left|r\right\rangle }\right)}{2} = {\left|u\right\rangle }$

sigma_zExpanded = Matrix([[a, b],[c, d]])
display(sigma_zExpanded)

$\displaystyle \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

valOfSigma_z = Eq(sigma_z, sigma_zExpanded, evaluate = False)
display(valOfSigma_z)

$\displaystyle \sigma_{z} = \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

prodOfSigma_z_ketU = Eq(Eq(sigma_z * ketU,
                           MatMul(sigma_zExpanded,
                                  ketUExpanded),
                           evaluate = False),
                        1 * ketUExpanded, 
                        evaluate = False)
display(prodOfSigma_z_ketU)

$\displaystyle \sigma_{z} {\left|u\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}1\\0\end{matrix}\right] = \left[\begin{matrix}1\\0\end{matrix}\right]$

prodOfSigma_z_ketD = Eq(Eq(sigma_z * ketD,
                           MatMul(sigma_zExpanded,
                                  ketDExpanded),
                           evaluate = False),
                        -1 * ketDExpanded, 
                        evaluate = False)
display(prodOfSigma_z_ketD)

$\displaystyle \sigma_{z} {\left|d\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}0\\1\end{matrix}\right] = \left[\begin{matrix}0\\-1\end{matrix}\right]$

t1 = Eq(MatMul(sigma_zExpanded, ketUExpanded), 1 * ketUExpanded, evaluate = False)
t2 = Eq(MatMul(sigma_zExpanded, ketDExpanded), -1 * ketDExpanded, evaluate = False)
solveForValues = solve((t1, t2), a, b, c, d)
display(solveForValues)

{a: 1, b: 0, c: 0, d: -1}

sigma_zExpanded = sigma_zExpanded.subs(a, solveForValues[a])\
                                 .subs(b, solveForValues[b])\
                                 .subs(c, solveForValues[c])\
                                 .subs(d, solveForValues[d])
display(sigma_zExpanded)

$\displaystyle \left[\begin{matrix}1 & 0\\0 & -1\end{matrix}\right]$

sigma_xExpanded = Matrix([[a, b],[c, d]])
display(sigma_xExpanded)

$\displaystyle \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

valOfSigma_x = Eq(sigma_x, sigma_xExpanded, evaluate = False)
display(valOfSigma_x)

$\displaystyle \sigma_{x} = \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

prodOfSigma_x_ketR = Eq(Eq(sigma_x * ketR,
                           MatMul(sigma_xExpanded,
                                  ketRExpanded),
                           evaluate = False),
                        1 * ketRExpanded, 
                        evaluate = False)
display(prodOfSigma_x_ketR)

$\displaystyle \sigma_{x} {\left|r\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2}\end{matrix}\right] = \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2}\end{matrix}\right]$

prodOfSigma_x_ketL = Eq(Eq(sigma_x * ketL,
                           MatMul(sigma_xExpanded,
                                  ketLExpanded),
                           evaluate = False),
                        -1 * ketLExpanded, 
                        evaluate = False)
display(prodOfSigma_x_ketL)

$\displaystyle \sigma_{x} {\left|l\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}\frac{\sqrt{2}}{2}\\- \frac{\sqrt{2}}{2}\end{matrix}\right] = \left[\begin{matrix}- \frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2}\end{matrix}\right]$

t1 = Eq(MatMul(sigma_xExpanded, ketRExpanded), 1 * ketRExpanded, evaluate = False)
t2 = Eq(MatMul(sigma_xExpanded, ketLExpanded), -1 * ketLExpanded, evaluate = False)
solveForValues = solve((t1, t2), a, b, c, d)
display(solveForValues)

{a: 0, b: 1, c: 1, d: 0}

sigma_xExpanded = sigma_xExpanded.subs(a, solveForValues[a])\
                                 .subs(b, solveForValues[b])\
                                 .subs(c, solveForValues[c])\
                                 .subs(d, solveForValues[d])
display(sigma_xExpanded)

$\displaystyle \left[\begin{matrix}0 & 1\\1 & 0\end{matrix}\right]$

sigma_yExpanded = Matrix([[a, b],[c, d]])
display(sigma_yExpanded)

$\displaystyle \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

valOfSigma_y = Eq(sigma_y, sigma_yExpanded, evaluate = False)
display(valOfSigma_y)

$\displaystyle \sigma_{y} = \left[\begin{matrix}a & b\\c & d\end{matrix}\right]$

prodOfSigma_y_ketI = Eq(Eq(sigma_y * ketI,
                           MatMul(sigma_yExpanded,
                                  ketIExpanded),
                           evaluate = False),
                        1 * ketIExpanded, 
                        evaluate = False)
display(prodOfSigma_y_ketI)

$\displaystyle \sigma_{y} {\left|I\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2} i}{2}\end{matrix}\right] = \left[\begin{matrix}\frac{\sqrt{2}}{2}\\\frac{\sqrt{2} i}{2}\end{matrix}\right]$

prodOfSigma_y_ketO = Eq(Eq(sigma_y * ketO,
                           MatMul(sigma_yExpanded,
                                  ketOExpanded),
                           evaluate = False),
                        -1 * ketOExpanded, 
                        evaluate = False)
display(prodOfSigma_y_ketO)

$\displaystyle \sigma_{y} {\left|o\right\rangle } = \left[\begin{matrix}a & b\\c & d\end{matrix}\right] \left[\begin{matrix}\frac{\sqrt{2}}{2}\\- \frac{\sqrt{2} i}{2}\end{matrix}\right] = \left[\begin{matrix}- \frac{\sqrt{2}}{2}\\\frac{\sqrt{2} i}{2}\end{matrix}\right]$

t1 = Eq(MatMul(sigma_yExpanded, ketIExpanded), 1 * ketIExpanded, evaluate = False)
t2 = Eq(MatMul(sigma_yExpanded, ketOExpanded), -1 * ketOExpanded, evaluate = False)
solveForValues = solve((t1, t2), a, b, c, d)
display(solveForValues)

{a: 0, b: -I, c: I, d: 0}

sigma_yExpanded = sigma_yExpanded.subs(a, solveForValues[a])\
                                 .subs(b, solveForValues[b])\
                                 .subs(c, solveForValues[c])\
                                 .subs(d, solveForValues[d])
display(sigma_yExpanded)

$\displaystyle \left[\begin{matrix}0 & - i\\i & 0\end{matrix}\right]$

n_x, n_y, n_z = symbols('n_x n_y n_z', integer = True)
display(n_x, n_y, n_z)

$\displaystyle n_{x}$

$\displaystyle n_{y}$

$\displaystyle n_{z}$

vecLength = Eq(n_x**2 + n_y**2 + n_z**2, 1)
display(vecLength)

$\displaystyle n_{x}^{2} + n_{y}^{2} + n_{z}^{2} = 1$

sigma_n = HermitianOperator('sigma_n')

sigma_nExpanded = Matrix(Add(MatMul(n_x,
                         sigma_xExpanded,
                         evaluate = False),
                  MatMul(n_y,
                         sigma_yExpanded,
                         evaluate = False),
                  MatMul(n_z,
                         sigma_zExpanded,
                         evaluate = False),
                  evaluate = False))
display(sigma_nExpanded)

$\displaystyle \left[\begin{matrix}n_{z} & n_{x} - i n_{y}\\n_{x} + i n_{y} & - n_{z}\end{matrix}\right]$

linearEq = Eq(n_x*sigma_x + n_y*sigma_y + n_z*sigma_z, sigma_n)
display(linearEq)

$\displaystyle n_{x} \sigma_{x} + n_{y} \sigma_{y} + n_{z} \sigma_{z} = \sigma_{n}$

valOfSigma_n = Eq(sigma_n,
              Add(MatMul(n_x,
                         sigma_xExpanded,
                         evaluate = False),
                  MatMul(n_y,
                         sigma_yExpanded,
                         evaluate = False),
                  MatMul(n_z,
                         sigma_zExpanded,
                         evaluate = False),
                  evaluate = False),
              evaluate = False)
display(valOfSigma_n)

$\displaystyle \sigma_{n} = \left[\begin{matrix}n_{z} & n_{x} - i n_{y}\\n_{x} + i n_{y} & - n_{z}\end{matrix}\right]$

ketPsiExpanded = Matrix([[alpha],[beta]], evaluate = False)
display(ketPsiExpanded)

$\displaystyle \left[\begin{matrix}\alpha\\\beta\end{matrix}\right]$

prodOfSigma_n_KetPsiExpanded =  Eq(MatMul(Dummy('sigma_n'),
                                       ketPsiExpanded,
                                       evaluate = False),
                                   MatMul(lamda,
                                       ketPsiExpanded,
                                       evaluate = False),
                                   evaluate = False)
display(prodOfSigma_n_KetPsiExpanded)

$\displaystyle \sigma_{n} \left[\begin{matrix}\alpha\\\beta\end{matrix}\right] = \lambda \left[\begin{matrix}\alpha\\\beta\end{matrix}\right]$

valOfLambda = Eq(lamda, 1)
display(valOfLambda)

$\displaystyle \lambda = 1$

ketPsiExpanded = Matrix([[1],[gamma]])

prodOfSigma_nExpanded_KetPsiExpanded =  Eq((sigma_nExpanded *
                                                  ketPsiExpanded),
                                           MatMul(1,
                                                  ketPsiExpanded,
                                                  evaluate = False),
                                           evaluate = False)
display(prodOfSigma_nExpanded_KetPsiExpanded)

$\displaystyle \left[\begin{matrix}\gamma \left(n_{x} - i n_{y}\right) + n_{z}\\- \gamma n_{z} + n_{x} + i n_{y}\end{matrix}\right] = 1 \left[\begin{matrix}1\\\gamma\end{matrix}\right]$

solveForGamma = solve(Eq(prodOfSigma_nExpanded_KetPsiExpanded.lhs[0],
         prodOfSigma_nExpanded_KetPsiExpanded.rhs.simplify()[0, 0]),
      gamma)[0]
display(solveForGamma)

$\displaystyle \frac{1 - n_{z}}{n_{x} - i n_{y}}$

display(ketPsiExpanded.subs(gamma, solveForGamma))

$\displaystyle \left[\begin{matrix}1\\\frac{1 - n_{z}}{n_{x} - i n_{y}}\end{matrix}\right]$

braPsiExpanded = conjugate(ketPsiExpanded.T)

valOfKetPsi = Eq(ketPsi, ketPsiExpanded, evaluate = False)
display(valOfKetPsi)

$\displaystyle {\left|\psi\right\rangle } = \left[\begin{matrix}1\\\gamma\end{matrix}\right]$

InnerproductOfPsi_Psi = Eq(InnerProduct(braPsi, ketPsi), 1)
display(InnerproductOfPsi_Psi)

$\displaystyle \left\langle \psi \right. {\left|\psi\right\rangle } = 1$

InnerproductOfPsiExpanded_PsiExpanded = Eq(MatMul(braPsiExpanded, ketPsiExpanded), 1, evaluate = False)
display(InnerproductOfPsiExpanded_PsiExpanded)

$\displaystyle \left[\begin{matrix}1 & \overline{\gamma}\end{matrix}\right] \left[\begin{matrix}1\\\gamma\end{matrix}\right] = 1$

valOfKetPsi = Eq(ketPsi, MatMul(alpha, ketPsiExpanded), evaluate = False)
display(valOfKetPsi)

$\displaystyle {\left|\psi\right\rangle } = \alpha \left[\begin{matrix}1\\\gamma\end{matrix}\right]$

InnerproductOfPsi_Psi = Eq(InnerProduct(braPsi, ketPsi), 1)
display(InnerproductOfPsi_Psi)

$\displaystyle \left\langle \psi \right. {\left|\psi\right\rangle } = 1$

InnerproductOfPsiExpanded_PsiExpanded = Eq(Mul(alpha**2,
                                               MatMul(braPsiExpanded,
                                                      ketPsiExpanded,
                                                      evaluate = False),
                                               evaluate = False),
                                           1,
                                           evaluate = False)
display(InnerproductOfPsiExpanded_PsiExpanded)

$\displaystyle \alpha^{2} \left[\begin{matrix}\gamma \overline{\gamma} + 1\end{matrix}\right] = 1$

InnerproductOfPsiExpanded_PsiExpanded = Eq(Mul(alpha**2,
                                               MatMul(braPsiExpanded,
                                                      ketPsiExpanded,
                                                      evaluate = False).subs(gamma, 
                                                                             solveForGamma),
                                               evaluate = False).subs((n_x - I*n_y)*(n_x + I*n_y),
                                                                      ((n_x - I*n_y)*(n_x + I*n_y)).expand()),
                                           1,
                                           evaluate = False)
display(InnerproductOfPsiExpanded_PsiExpanded)

$\displaystyle \alpha^{2} \left[\begin{matrix}\frac{\left(1 - n_{z}\right)^{2}}{n_{x}^{2} + n_{y}^{2}} + 1\end{matrix}\right] = 1$

InnerproductOfPsiExpanded_PsiExpanded = Eq(Mul(alpha**2,
                                               MatMul(braPsiExpanded,
                                                      ketPsiExpanded,
                                                      evaluate = False).subs(gamma, 
                                                                             solveForGamma),
                                               evaluate = False).subs((n_x - I*n_y)*(n_x + I*n_y),
                                                                      1 - n_z**2),
                                           1,
                                           evaluate = False)
display(InnerproductOfPsiExpanded_PsiExpanded)

$\displaystyle \alpha^{2} \left[\begin{matrix}\frac{\left(1 - n_{z}\right)^{2}}{1 - n_{z}^{2}} + 1\end{matrix}\right] = 1$

InnerproductOfPsiExpanded_PsiExpanded = Eq(Mul(alpha**2,
                                               MatMul(braPsiExpanded,
                                                      ketPsiExpanded,
                                                      evaluate = False).subs(gamma, 
                                                                             solveForGamma),
                                               evaluate = False).subs((n_x - I*n_y)*(n_x + I*n_y),
                                                                      1 - n_z**2).simplify(),
                                           1,
                                           evaluate = False)
display(InnerproductOfPsiExpanded_PsiExpanded)

$\displaystyle \alpha^{2} \left[\begin{matrix}\frac{2}{n_{z} + 1}\end{matrix}\right] = 1$

solveOfAlpha = Eq(alpha, sqrt((1 + n_z)/2))
display(solveOfAlpha)

$\displaystyle \alpha = \sqrt{\frac{n_{z}}{2} + \frac{1}{2}}$

valOfKetPsi = Eq(ketPsi, MatMul(solveOfAlpha.rhs, ketPsiExpanded.subs(gamma, solveForGamma)), evaluate = False)
display(valOfKetPsi)

$\displaystyle {\left|\psi\right\rangle } = \sqrt{\frac{n_{z}}{2} + \frac{1}{2}} \left[\begin{matrix}1\\\frac{1 - n_{z}}{n_{x} - i n_{y}}\end{matrix}\right]$