Erwin Renzo Franco Diaz

# Introducción

Además del cálculo, una de las herramientas matemáticas fundamentales para la física es el álgebra lineal, cuyos objetos principales de estudio son los vectores y las matrices. En la sesión de esta semana veremos como trabajar con estas en $\texttt{python}$, tanto de manera simbólica como numérica. Haremos énfasis principalmente en la obtención de los autovalores y autovectores de una matriz, y lo aplicaremos a la resolución de problemas en mecánica cuántica y oscilaciones.

# Matrices simbólicas

La manera más sencilla de definir una matriz es como un arreglo (en general) rectangular de números, por ejemplo

$$
A = \left(
\begin{matrix}
-2 & -4 & 2 \\
-2 & 1 & 2 \\
4 & 2 & 5
\end{matrix}
\right).
$$

Para definir esta matriz de manera simbólica usamos el paquete $\texttt{sympy}$, en particular, el comando $\texttt{Matrix}$


```python
import sympy as sp
sp.init_printing()
```


```python
A = sp.Matrix([[-2, -4, 2], 
               [-2, 1, 2],
               [4, 2, 5]])

A
```


```python
B = sp.Matrix([[1-sp.I, 4, 3],
               [0, -1*sp.I, 2], 
               [1, 2, 5]])

B
```

$\texttt{sp.I} = i$, la unidad imaginaria

## Operaciones básicas

*Nota:* Antes de realizar alguna operación, verificar siempre que las matrices tengan las dimensiones adecuadas. Caso contrario, $\texttt{python}$ dará un error.

Suma 


```python
A + B
```

Resta


```python
A - B
```

Multiplicación por un escalar


```python
0.3*A
```


```python
sp.Rational(1, 2)*A
```

Multiplicación de matrices


```python
A*B
```

Potencia 


```python
#B**2 = B*B
sp.simplify(B**2)
```

Es posible mezclar estas operaciones algebraicas.


```python
sp.simplify(A*B - 0.2*B**2)
```

Transpuesta $A^T$


```python
A.T
```

Adjunta

$$
A^\dagger = \left(A^T\right)^*
$$


```python
from sympy.physics.quantum.dagger import Dagger
Dagger(B)
```

Determinante


```python
sp.simplify(B.det())
```

Inversa $A^{-1}$

$$
A^{-1} A = AA^{-1} = I
$$


```python
A**(-1)
```


```python
sp.simplify(B**(-1))
```

## Algunas matrices especiales

Matrix identidad $I$

$$
IA = AI = A
$$


```python
sp.eye(3)
```

Matriz de ceros


```python
sp.zeros(3)
```

Matriz de unos


```python
sp.ones(3)
```

Matriz diagonal


```python
sp.diag(-3, 1, 6)
```

También es posible incluir variables en una matriz.


```python
x, y = sp.symbols('x, y')

C = sp.Matrix([[-x, -y, x],
               [x**2, 0, sp.exp(-x*y)],
               [y, 2*x + y, 0]])

C
```


```python
A + C
```


```python
C.det()
```


```python
sp.simplify(C**(-1))
```

## Ejercicio 1: Matriz de rotación (1)

1. Definir la matriz de rotación alrededor del eje $z$

$$
R = 
\begin{pmatrix}
\cos \theta & -\sin \theta & 0 \\
\sin \theta & \cos \theta & 0 \\
0 & 0 & 1
\end{pmatrix}
$$

2. Verificar que $\det R = 1$
3. Hallar $R^{-1}$.
4. Hallar $R^T$ y verificar que $R^T R = 1$. Esto significa que $R$ es una matriz ortogonal.


```python
#solucion
```

## Autovalores y autovectores

En general, al multiplicar una matriz $A$ por un vector $\mathbf{v}$, se obtiene un vector completamente nuevo. Sin embargo, existen ciertos vectores especiales que cambian solo por una constante

$$
A \mathbf{v} = \lambda \mathbf{v}
$$

A los vectores $\mathbf{v}$ que cumplen esta relación, se les denomina como los __autovectores__ de $A$, mientras que a los respectivos escalares $\lambda$, como sus __autovalores__.

El cálculo de los autovalores y autovectores de una matriz es muy importante para hallar por ejemplo, las energías de un sistema cuántico o los modos normales de vibración de un sistema de osciladores, como veremos más adelante.

Autovalores


```python
A.eigenvals()
```

La función $\texttt{eigenvals()}$ nos da los autovalores de la matriz, así como el número de veces que cada uno se repite, lo que se conoce como _multiplicidad_.

Es posible convertir un número expresado de manera simbólica a su forma decimal.


```python
B_eigenvals = list(B.eigenvals().keys())

for i in B_eigenvals:
    display(sp.N(i))
```

Autovectores


```python
A.eigenvects()
```

La función $\texttt{eigenvals()}$ nos da los autovectores de la matriz, así como su respectivo autovalor y multiplicidad.

Si queremos seleccionar un autovector en particular


```python
A.eigenvects()[0][2][0]
```

## Ejercicio 2: Matriz de rotación (2)

1. Hallar los autovalores de $R$.
2. Hallar los autovectores de $R$.
3. Dar una interpretación física a estos resultados.


```python
#solucion
```

# Problema 1: Autovalores de energía 

_Referencia:_  Zetilli, Quantum Mechanics, Problema 3.6 (p. 197) 

Los posibles valores de energía de un sistema están dados por la ecuación de Schr&ouml;dinger 

$$
\hat{H}|\psi\rangle= E|\psi\rangle,
$$

donde $\hat{H}$ es el hamiltoniano del sistema. Es decir, las posibles energías del sistema vienen a ser los autovalores del Hamiltoniano.

Para este problema, consideremos el hamiltoniano

$$
\hat{H} = E_0 
\begin{pmatrix}
0 & i & 0 \\
-i & 0 & 0 \\
0 & 0 & -1
\end{pmatrix}
$$

1. Definir el hamiltoniano $\hat{H}$.
2. Verificar que el hamiltoniano es hermítico
$$
\hat{H} = \hat{H}^\dagger
$$
3. Hallar los posibles valores de energía del sistema.
4. Hallar los autovectores de $\hat{H}$ y verificar para uno de estos que se cumple la ecuación de Schr&ouml;dinger.

Consideremos ahora que nuestro sistema se encuentra inicialmente en un estado

$$
|\psi_0 \rangle = \frac{1}{\sqrt{5}}
\begin{pmatrix}
1 - i \\
1 - i \\
1
\end{pmatrix}
$$

donde cada componente del vector indica la amplitud de probabilidad de medir cada valor de energía.

El valor esperado de la energía para un sistema dado está definido como

$$
\langle E \rangle = \langle \psi_0|\hat{H}|\psi_0 \rangle 
$$

donde el bra $\langle \psi_0|$ es la adjunta del ket $|\psi_0 \rangle$.

5. Verificar que el estado $|\psi_0\rangle $ esta normalizado
$$
\langle \psi_0|\psi_0 \rangle  = 1
$$
6. Hallar el valor esperado de la energía para el sistema. _Nota:_ esto se puede calcular como una multiplicación de matrices.

# Matrices númericas

Para definir una matriz de manera numérica usamos el paquete $\texttt{numpy}$. En este paquete, las matrices (así como cualquier otro arreglo de números) se definen usando el comando $\texttt{array}$.


```python
import numpy as np
```


```python
A_num = np.array([[-2, -4, 2], 
                  [-2, 1, 2],
                  [4, 2, 5]])

A_num
```




    array([[-2, -4,  2],
           [-2,  1,  2],
           [ 4,  2,  5]])




```python
B_num = np.array([[1, 4, 3],
                  [0, -1, 2], 
                  [1, 2, 5]])

B_num
```




    array([[ 1,  4,  3],
           [ 0, -1,  2],
           [ 1,  2,  5]])



Todas las operaciones algebraicas que se realizaron en $\texttt{sympy}$, también se pueden realizar en $\texttt{numpy}$.


```python
A_num + B_num
```




    array([[-1,  0,  5],
           [-2,  0,  4],
           [ 5,  4, 10]])



Hay q tener cuidado con la multiplicación. Si multiplicamos las matrices de la misma manera que en $\texttt{sympy}$, esta será elemento por elemento.


```python
A_num*B_num
```




    array([[ -2., -16.,   6.],
           [ -0.,  -1.,   4.],
           [  4.,   4.,  25.]])



Multiplicación de matrices


```python
np.dot(A_num, B_num)
```




    array([[ 0,  0, -4],
           [ 0, -5,  6],
           [ 9, 24, 41]])



Para realizar las operaciones propias de las matrices como obtener la matriz adjunta o inversa, se tiene que usar el paquete $\textt{linalg}$ que está dentro de $\texttt{numpy}$. 


```python
np.linalg.det(A_num)
```


```python
np.linalg.inv(A_num)
```




    array([[-1.11111111e-02, -2.66666667e-01,  1.11111111e-01],
           [-2.00000000e-01,  2.00000000e-01, -9.25185854e-18],
           [ 8.88888889e-02,  1.33333333e-01,  1.11111111e-01]])



Autovalores y autovectores


```python
np.linalg.eig(A_num)
```




    (array([-5.,  3.,  6.]), array([[ 0.81649658,  0.53452248,  0.05842062],
            [ 0.40824829, -0.80178373,  0.35052374],
            [-0.40824829, -0.26726124,  0.93472998]]))



Los autovectores hallados están normalizados, es decir, su módulo es igual a 1.

# Problema 2: Autovalores de energía


_Referencia:_ Zetilli, Quantum Mechanics, Problema 3.11 (p. 204) 

Al igual que en el problema 1, consideremos un sistema cuyo estado inicial y hamiltoniano son respectivamente

$$
|\psi_0 \rangle = \frac{1}{5}
\begin{pmatrix}
3 \\
0 \\
4
\end{pmatrix} 
\quad
\hat{H} = 
\begin{pmatrix}
3 & 0 & 0 \\
0 & 0 & 5 \\
0 & 5 & 0
\end{pmatrix}
$$

Repetir los cálculos del problema 1, pero trabajandolo ahora de manera numérica. 


```python
#solucion
```

f132830365cb5a891adfa2cf1246f180be686b0b
ipynb
Jupyter Notebook
week-5/matrices.ipynb
PCPUNMSM/Summer-School-2020
49fdf5b40a1f71e5da57836a98eb996d2beb17a1
MIT
2020-02-22T18:30:12.000Z
2021-11-14T19:24:23.000Z
week-5/matrices.ipynb
PCPUNMSM/Summer-School-2020
49fdf5b40a1f71e5da57836a98eb996d2beb17a1
MIT
week-5/matrices.ipynb
PCPUNMSM/Summer-School-2020
49fdf5b40a1f71e5da57836a98eb996d2beb17a1
MIT
2020-01-31T22:14:00.000Z
2020-02-08T16:37:08.000Z
Qwen/Qwen-72B
1. YES
2. YES