VECTORES, MATRICES Y SISTEMAS LINEALES - GUÍA COMPLETA

4. VECTORES Y ÁLGEBRA VECTORIAL

4.1 Fundamentos Vectoriales

Definición: Un vector es una cantidad con magnitud y dirección. - En ℝ²: \(\vec{v} = \langle v_1, v_2 \rangle\) - En ℝ³: \(\vec{v} = \langle v_1, v_2, v_3 \rangle\)

Representación gráfica: - 2D: Flecha desde origen \((0,0)\) hasta \((v_1, v_2)\) - 3D: Flecha desde \(P_1(x_1,y_1,z_1)\) hasta \(P_2(x_2,y_2,z_2)\)

\[ \boxed{\vec{P_1P_2} = \langle x_2-x_1, y_2-y_1, z_2-z_1 \rangle} \]

Magnitud (norma):

\[ \|\vec{v}\| = \sqrt{v_1^2 + v_2^2} \quad \text{(2D)} \quad \|\vec{v}\| = \sqrt{v_1^2 + v_2^2 + v_3^2} \quad \text{(3D)} \]

Vector unitario: \(\hat{u} = \frac{\vec{v}}{\|\vec{v}\|}\) donde \(\|\hat{u}\| = 1\)

# Gráfica 4.1: Vectores en 2D con diferentes casos
import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 8))
# Caso 1: Vectores estándar
v1 = np.array([3, 2])
v2 = np.array([-2, 4])
v3 = np.array([1, -3])

ax.quiver(0, 0, v1[0], v1[1], angles='xy', scale_units='xy', scale=1, color='r', label='$\vec{v_1}$ = ⟨3,2⟩')
ax.quiver(0, 0, v2[0], v2[1], angles='xy', scale_units='xy', scale=1, color='g', label='$\vec{v_2}$ = ⟨-2,4⟩')
ax.quiver(0, 0, v3[0], v3[1], angles='xy', scale_units='xy', scale=1, color='b', label='$\vec{v_3}$ = ⟨1,-3⟩')

# Caso 2: Vectores unitarios
u1 = v1/np.linalg.norm(v1)
u2 = v2/np.linalg.norm(v2)
ax.quiver(5, 0, u1[0], u1[1], angles='xy', scale_units='xy', scale=1, color='r', linestyle='--', width=0.005)
ax.quiver(5, 0, u2[0], u2[1], angles='xy', scale_units='xy', scale=1, color='g', linestyle='--', width=0.005)

ax.set_xlim(-5, 7)
ax.set_ylim(-5, 5)
ax.axhline(y=0, color='k', linewidth=0.5)
ax.axvline(x=0, color='k', linewidth=0.5)
ax.grid(True, linestyle='--', linewidth=0.5)
ax.set_aspect('equal')
ax.legend()
ax.set_title('Gráfica 4.1: Vectores en ℝ² - Múltiples casos')
plt.show()

4.2 Operaciones Vectoriales Fundamentales

Suma y resta:

\[ \vec{u} \pm \vec{v} = \langle u_1 \pm v_1, u_2 \pm v_2 \rangle \quad \text{(2D)} \]

Multiplicación por escalar:

\[ k\vec{v} = \langle kv_1, kv_2 \rangle \]

Métodos gráficos para suma: 1. Ley del paralelogramo: Completar paralelogramo con vectores 2. Método del polígono: Unir cola con cabeza

# Gráfica 4.2: Suma vectorial - múltiples métodos
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Método 1: Ley del paralelogramo
u = np.array([3, 1])
v = np.array([1, 3])
suma = u + v

axes[0].quiver(0, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color='r', label='$\vec{u}$')
axes[0].quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color='g', label='$\vec{v}$')
axes[0].quiver(0, 0, suma[0], suma[1], angles='xy', scale_units='xy', scale=1, color='b', label='$\vec{u}+\vec{v}$')

# Dibujar paralelogramo
axes[0].plot([u[0], suma[0]], [u[1], suma[1]], 'k--', alpha=0.5)
axes[0].plot([v[0], suma[0]], [v[1], suma[1]], 'k--', alpha=0.5)

axes[0].set_xlim(-1, 5)
axes[0].set_ylim(-1, 5)
axes[0].set_aspect('equal')
axes[0].legend()
axes[0].set_title('Ley del paralelogramo')

# Método 2: Polígono con 3 vectores
a = np.array([1, 2])
b = np.array([3, 1])
c = np.array([-1, 3])
suma_total = a + b + c

axes[1].quiver(0, 0, a[0], a[1], angles='xy', scale_units='xy', scale=1, color='r', label='$\vec{a}$')
axes[1].quiver(a[0], a[1], b[0], b[1], angles='xy', scale_units='xy', scale=1, color='g', label='$\vec{b}$')
axes[1].quiver(a[0]+b[0], a[1]+b[1], c[0], c[1], angles='xy', scale_units='xy', scale=1, color='b', label='$\vec{c}$')
axes[1].quiver(0, 0, suma_total[0], suma_total[1], angles='xy', scale_units='xy', scale=1, color='k', label='Suma total')

axes[1].set_xlim(-2, 6)
axes[1].set_ylim(-1, 7)
axes[1].set_aspect('equal')
axes[1].legend()
axes[1].set_title('Método del polígono (3 vectores)')

# Método 3: Resta y multiplicación
axes[2].quiver(0, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color='r', label='$\vec{u}$')
axes[2].quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color='g', label='$\vec{v}$')
axes[2].quiver(0, 0, u[0]-v[0], u[1]-v[1], angles='xy', scale_units='xy', scale=1, color='b', label='$\vec{u}-\vec{v}$')
axes[2].quiver(3, 0, 2*u[0], 2*u[1], angles='xy', scale_units='xy', scale=1, color='orange', label='$2\vec{u}$')
axes[2].quiver(3, 0, -0.5*v[0], -0.5*v[1], angles='xy', scale_units='xy', scale=1, color='purple', label='$-0.5\vec{v}$')

axes[2].set_xlim(-2, 6)
axes[2].set_ylim(-3, 5)
axes[2].set_aspect('equal')
axes[2].legend()
axes[2].set_title('Resta y multiplicación escalar')

plt.suptitle('Gráfica 4.2: Operaciones vectoriales - Múltiples métodos')
plt.tight_layout()
plt.show()

4.3 Productos Vectoriales

Producto punto (escalar):

\[ \vec{u} \cdot \vec{v} = u_1v_1 + u_2v_2 + u_3v_3 = \|\vec{u}\|\|\vec{v}\|\cos\theta \]

Interpretación geométrica: - Proyección de \(\vec{u}\) sobre \(\vec{v}\): \(\text{proy}_{\vec{v}}\vec{u} = \frac{\vec{u}\cdot\vec{v}}{\|\vec{v}\|^2}\vec{v}\) - Ángulo entre vectores: \(\theta = \arccos\left(\frac{\vec{u}\cdot\vec{v}}{\|\vec{u}\|\|\vec{v}\|}\right)\)

Producto cruz (solo 3D):

\[ \vec{u} \times \vec{v} = \begin{vmatrix} \hat{i} & \hat{j} & \hat{k} \\ u_1 & u_2 & u_3 \\ v_1 & v_2 & v_3 \end{vmatrix} \]

Propiedades: - Magnitud: \(\|\vec{u} \times \vec{v}\| = \|\vec{u}\|\|\vec{v}\|\sin\theta\) = área del paralelogramo - Dirección: perpendicular a \(\vec{u}\) y \(\vec{v}\) (regla de la mano derecha) - Anticonmutativo: \(\vec{u} \times \vec{v} = -(\vec{v} \times \vec{u})\)

# Gráfica 4.3: Producto punto y producto cruz
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(15, 10))

# Producto punto - múltiples casos
ax1 = plt.subplot(2, 3, 1)
u = np.array([3, 1])
v = np.array([2, 3])
proy = (np.dot(u, v)/np.linalg.norm(v)**2) * v

ax1.quiver(0, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color='r', label='$\vec{u}$')
ax1.quiver(0, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color='g', label='$\vec{v}$')
ax1.quiver(0, 0, proy[0], proy[1], angles='xy', scale_units='xy', scale=1, color='b', label='Proyección')
ax1.plot([u[0], proy[0]], [u[1], proy[1]], 'k--', alpha=0.5)
ax1.set_aspect('equal')
ax1.legend()
ax1.set_title('Proyección vectorial')

# Ángulos entre vectores
ax2 = plt.subplot(2, 3, 2)
vectores = [
    (np.array([2, 1]), np.array([1, 2]), 'Agudo (θ<90°)'),
    (np.array([1, 0]), np.array([0, 1]), 'Recto (θ=90°)'),
    (np.array([1, 1]), np.array([-1, -0.5]), 'Obtuso (θ>90°)')
]

colors = ['r', 'g', 'b']
for i, (u, v, label) in enumerate(vectores):
    ax2.quiver(i*3, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color=colors[i], label=label)
    ax2.quiver(i*3, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color=colors[i], linestyle='--')

ax2.set_xlim(-1, 10)
ax2.set_ylim(-2, 3)
ax2.set_aspect('equal')
ax2.legend(bbox_to_anchor=(1.05, 1))
ax2.set_title('Ángulos entre vectores')

# Producto cruz en 3D
ax3 = plt.subplot(2, 3, 3, projection='3d')
u = np.array([2, 0, 0])
v = np.array([1, 2, 0])
w = np.cross(u, v)

ax3.quiver(0, 0, 0, u[0], u[1], u[2], color='r', label='$\vec{u}$')
ax3.quiver(0, 0, 0, v[0], v[1], v[2], color='g', label='$\vec{v}$')
ax3.quiver(0, 0, 0, w[0], w[1], w[2], color='b', label='$\vec{u}×\vec{v}$')

# Paralelogramo
points = np.array([[0,0,0], u, u+v, v])
ax3.plot(points[:,0], points[:,1], points[:,2], 'k--', alpha=0.5)
ax3.plot(points[[0,2],0], points[[0,2],1], points[[0,2],2], 'k--', alpha=0.5)

ax3.set_xlim([-1, 3])
ax3.set_ylim([-1, 3])
ax3.set_zlim([-1, 3])
ax3.legend()
ax3.set_title('Producto cruz y paralelogramo')

# Regla mano derecha - múltiples casos
ax4 = plt.subplot(2, 3, 4, projection='3d')
casos = [
    (np.array([1, 0, 0]), np.array([0, 1, 0]), 'r', 'Caso 1'),
    (np.array([0, 0, 1]), np.array([0, 1, 0]), 'g', 'Caso 2'),
    (np.array([1, 1, 0]), np.array([0, 1, 1]), 'b', 'Caso 3')
]

for i, (u, v, color, label) in enumerate(casos):
    offset = i * 2
    w = np.cross(u, v)
    ax4.quiver(offset, 0, 0, u[0], u[1], u[2], color=color, label=f'{label}: $\vec{u}$')
    ax4.quiver(offset, 0, 0, v[0], v[1], v[2], color=color, linestyle='--', label=f'{label}: $\vec{v}$')
    ax4.quiver(offset, 0, 0, w[0], w[1], w[2], color=color, linestyle=':', label=f'{label}: $\vec{u}×\vec{v}$')

ax4.set_xlim([-1, 7])
ax4.set_ylim([-1, 2])
ax4.set_zlim([-1, 2])
ax4.legend(bbox_to_anchor=(1.1, 1))
ax4.set_title('Regla mano derecha - Múltiples casos')

# Área de paralelogramo
ax5 = plt.subplot(2, 3, 5, projection='3d')
u = np.array([3, 1, 0])
v = np.array([1, 3, 0])
w = np.cross(u, v)
area = np.linalg.norm(w)

ax5.quiver(0, 0, 0, u[0], u[1], u[2], color='r', label=f'$\vec{u}$ (||u||={np.linalg.norm(u):.2f})')
ax5.quiver(0, 0, 0, v[0], v[1], v[2], color='g', label=f'$\vec{v}$ (||v||={np.linalg.norm(v):.2f})')

# Dibujar paralelogramo
vertices = np.array([[0,0,0], u, u+v, v])
ax5.plot(vertices[:,0], vertices[:,1], vertices[:,2], 'k-', alpha=0.5)
ax5.plot(vertices[[0,2],0], vertices[[0,2],1], vertices[[0,2],2], 'k-', alpha=0.5)
ax5.fill(vertices[[0,1,2,3,0],0], vertices[[0,1,2,3,0],1], vertices[[0,1,2,3,0],2], alpha=0.3)

ax5.set_xlim([-1, 5])
ax5.set_ylim([-1, 5])
ax5.set_zlim([-1, 1])
ax5.legend()
ax5.set_title(f'Área paralelogramo = {area:.2f}')

# Vectores ortogonales
ax6 = plt.subplot(2, 3, 6)
vectores_ort = [
    (np.array([1, 2]), np.array([-2, 1]), 'Ortogonales ($u·v=0$)'),
    (np.array([2, 1]), np.array([-1, 2]), 'Ortogonales ($u·v=0$)'),
    (np.array([3, 1]), np.array([1, -3]), 'Ortogonales ($u·v=0$)')
]

for i, (u, v, label) in enumerate(vectores_ort):
    offset = i * 3
    ax6.quiver(offset, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color='r')
    ax6.quiver(offset, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color='g')
    ax6.text(offset, -1.5, f'u·v={np.dot(u,v)}', ha='center')

ax6.set_xlim([-1, 10])
ax6.set_ylim([-2, 3])
ax6.set_aspect('equal')
ax6.set_title('Vectores ortogonales')

plt.suptitle('Gráfica 4.3: Productos vectoriales - Múltiples casos y aplicaciones')
plt.tight_layout()
plt.show()

4.4 Aplicaciones Geométricas Avanzadas

Triple producto escalar:

\[ \vec{u} \cdot (\vec{v} \times \vec{w}) = \begin{vmatrix} u_1 & u_2 & u_3 \\ v_1 & v_2 & v_3 \\ w_1 & w_2 & w_3 \end{vmatrix} \]

Interpretación geométrica: - Volumen del paralelepípedo: \(V = |\vec{u} \cdot (\vec{v} \times \vec{w})|\) - Volumen del tetraedro: \(V_{\text{tetra}} = \frac{1}{6}|\vec{u} \cdot (\vec{v} \times \vec{w})|\)

Fórmulas clave:

\[ \boxed{A_{\text{triángulo}} = \frac{1}{2}\|\vec{u} \times \vec{v}\|} $$ $$ \boxed{V_{\text{paralelepípedo}} = |\vec{u} \cdot (\vec{v} \times \vec{w})|} $$ $$ \boxed{V_{\text{tetraedro}} = \frac{1}{6}|\vec{u} \cdot (\vec{v} \times \vec{w})|} \]

# Gráfica 4.4: Aplicaciones geométricas - Paralelepípedos y volúmenes
fig = plt.figure(figsize=(15, 10))

# Paralelepípedo 1
ax1 = plt.subplot(2, 3, 1, projection='3d')
u1 = np.array([3, 0, 0])
v1 = np.array([1, 2, 0])
w1 = np.array([0, 0, 2])
vol1 = abs(np.dot(u1, np.cross(v1, w1)))

# Generar vértices del paralelepípedo
vertices1 = []
for i in range(2):
    for j in range(2):
        for k in range(2):
            vertices1.append(i*u1 + j*v1 + k*w1)
vertices1 = np.array(vertices1)

# Dibujar aristas
edges = [(0,1), (0,2), (0,4), (1,3), (1,5), (2,3), (2,6), (3,7), (4,5), (4,6), (5,7), (6,7)]
for start, end in edges:
    ax1.plot([vertices1[start,0], vertices1[end,0]],
             [vertices1[start,1], vertices1[end,1]],
             [vertices1[start,2], vertices1[end,2]], 'k-', alpha=0.7)

ax1.quiver(0, 0, 0, u1[0], u1[1], u1[2], color='r', label='$\vec{u}$')
ax1.quiver(0, 0, 0, v1[0], v1[1], v1[2], color='g', label='$\vec{v}$')
ax1.quiver(0, 0, 0, w1[0], w1[1], w1[2], color='b', label='$\vec{w}$')

ax1.set_xlim([-1, 5])
ax1.set_ylim([-1, 3])
ax1.set_zlim([-1, 3])
ax1.legend()
ax1.set_title(f'Paralelepípedo 1\nVolumen = {vol1}')

# Paralelepípedo 2 (oblicuo)
ax2 = plt.subplot(2, 3, 2, projection='3d')
u2 = np.array([2, 1, 0])
v2 = np.array([1, 2, 1])
w2 = np.array([0, 1, 2])
vol2 = abs(np.dot(u2, np.cross(v2, w2)))

vertices2 = []
for i in range(2):
    for j in range(2):
        for k in range(2):
            vertices2.append(i*u2 + j*v2 + k*w2)
vertices2 = np.array(vertices2)

for start, end in edges:
    ax2.plot([vertices2[start,0], vertices2[end,0]],
             [vertices2[start,1], vertices2[end,1]],
             [vertices2[start,2], vertices2[end,2]], 'k-', alpha=0.7)

ax2.quiver(0, 0, 0, u2[0], u2[1], u2[2], color='r', label='$\vec{u}$')
ax2.quiver(0, 0, 0, v2[0], v2[1], v2[2], color='g', label='$\vec{v}$')
ax2.quiver(0, 0, 0, w2[0], w2[1], w2[2], color='b', label='$\vec{w}$')

ax2.set_xlim([-1, 4])
ax2.set_ylim([-1, 4])
ax2.set_zlim([-1, 4])
ax2.legend()
ax2.set_title(f'Paralelepípedo 2 (oblicuo)\nVolumen = {vol2:.2f}')

# Tetraedro formado por u, v, w
ax3 = plt.subplot(2, 3, 3, projection='3d')
u3 = np.array([3, 0, 0])
v3 = np.array([0, 3, 0])
w3 = np.array([0, 0, 3])
vol_tetra = abs(np.dot(u3, np.cross(v3, w3)))/6

# Vértices del tetraedro
tetra_vertices = np.array([[0,0,0], u3, v3, w3])
tetra_edges = [(0,1), (0,2), (0,3), (1,2), (1,3), (2,3)]

for start, end in tetra_edges:
    ax3.plot([tetra_vertices[start,0], tetra_vertices[end,0]],
             [tetra_vertices[start,1], tetra_vertices[end,1]],
             [tetra_vertices[start,2], tetra_vertices[end,2]], 'k-', alpha=0.7)

# Caras del tetraedro
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
faces = [[tetra_vertices[0], tetra_vertices[1], tetra_vertices[2]],
         [tetra_vertices[0], tetra_vertices[1], tetra_vertices[3]],
         [tetra_vertices[0], tetra_vertices[2], tetra_vertices[3]],
         [tetra_vertices[1], tetra_vertices[2], tetra_vertices[3]]]

ax3.add_collection3d(Poly3DCollection(faces, alpha=0.3, color=['red', 'green', 'blue', 'yellow']))

ax3.quiver(0, 0, 0, u3[0], u3[1], u3[2], color='r', label='$\vec{u}$')
ax3.quiver(0, 0, 0, v3[0], v3[1], v3[2], color='g', label='$\vec{v}$')
ax3.quiver(0, 0, 0, w3[0], w3[1], w3[2], color='b', label='$\vec{w}$')

ax3.set_xlim([-1, 4])
ax3.set_ylim([-1, 4])
ax3.set_zlim([-1, 4])
ax3.legend()
ax3.set_title(f'Tetraedro\nVolumen = {vol_tetra:.2f}')

# Área de triángulos en 2D
ax4 = plt.subplot(2, 3, 4)
triangulos = [
    (np.array([3, 0]), np.array([0, 3]), 'Rectángulo'),
    (np.array([2, 1]), np.array([1, 3]), 'Escaleno'),
    (np.array([4, 0]), np.array([2, 2]), 'Oblicuo')
]

for i, (u, v, tipo) in enumerate(triangulos):
    offset = i * 5
    area = 0.5 * np.linalg.norm(np.cross(u, v))

    # Dibujar triángulo
    vertices = np.array([[0,0], u, v])
    ax4.plot(vertices[:,0] + offset, vertices[:,1], 'k-')
    ax4.fill(vertices[:,0] + offset, vertices[:,1], alpha=0.3)

    ax4.quiver(offset, 0, u[0], u[1], angles='xy', scale_units='xy', scale=1, color='r')
    ax4.quiver(offset, 0, v[0], v[1], angles='xy', scale_units='xy', scale=1, color='g')
    ax4.text(offset + 1, -0.5, f'Área={area:.2f}\n{tipo}', ha='center')

ax4.set_xlim([-1, 16])
ax4.set_ylim([-1, 4])
ax4.set_aspect('equal')
ax4.set_title('Área de triángulos (½||u×v||)')

# Proyección de volumen
ax5 = plt.subplot(2, 3, 5, projection='3d')
# Caso degenerado (volumen cero)
u5 = np.array([2, 1, 0])
v5 = np.array([1, 2, 0])  # Coplanar con u
w5 = np.array([3, 3, 0])  # Coplanar con u y v
vol_degen = abs(np.dot(u5, np.cross(v5, w5)))

ax5.quiver(0, 0, 0, u5[0], u5[1], u5[2], color='r', label='$\vec{u}$')
ax5.quiver(0, 0, 0, v5[0], v5[1], v5[2], color='g', label='$\vec{v}$')
ax5.quiver(0, 0, 0, w5[0], w5[1], w5[2], color='b', label='$\vec{w}$')

ax5.set_xlim([-1, 4])
ax5.set_ylim([-1, 4])
ax5.set_zlim([-1, 1])
ax5.legend()
ax5.set_title(f'Vectores coplanares\nVolumen = {vol_degen} (degenerado)')

# Prisma triangular
ax6 = plt.subplot(2, 3, 6, projection='3d')
# Base triangular
u6 = np.array([3, 0, 0])
v6 = np.array([1, 2, 0])
w6 = np.array([0, 0, 3])  # Altura

# Triángulo base
tri_base = np.array([[0,0,0], u6, v6, [0,0,0]])
ax6.plot(tri_base[:,0], tri_base[:,1], tri_base[:,2], 'b-', alpha=0.5)
ax6.fill(tri_base[:,0], tri_base[:,1], tri_base[:,2], alpha=0.2, color='blue')

# Triángulo superior
tri_top = tri_base + w6
ax6.plot(tri_top[:,0], tri_top[:,1], tri_top[:,2], 'r-', alpha=0.5)
ax6.fill(tri_top[:,0], tri_top[:,1], tri_top[:,2], alpha=0.2, color='red')

# Aristas verticales
for i in range(3):
    ax6.plot([tri_base[i,0], tri_top[i,0]],
             [tri_base[i,1], tri_top[i,1]],
             [tri_base[i,2], tri_top[i,2]], 'k-', alpha=0.5)

ax6.quiver(0, 0, 0, u6[0], u6[1], u6[2], color='g', label='Base 1')
ax6.quiver(0, 0, 0, v6[0], v6[1], v6[2], color='g', label='Base 2')
ax6.quiver(0, 0, 0, w6[0], w6[1], w6[2], color='r', label='Altura')

area_base = 0.5 * np.linalg.norm(np.cross(u6, v6))
vol_prisma = area_base * np.linalg.norm(w6)

ax6.set_xlim([-1, 4])
ax6.set_ylim([-1, 3])
ax6.set_zlim([-1, 4])
ax6.legend()
ax6.set_title(f'Prisma triangular\nVolumen = {vol_prisma:.2f}')

plt.suptitle('Gráfica 4.4: Aplicaciones geométricas - Volúmenes y áreas')
plt.tight_layout()
plt.show()

5. MATRICES Y OPERACIONES MATRICIALES

5.1 Fundamentos Matriciales

Definición: Matriz \(m \times n\) es arreglo rectangular de números:

\[ A = \begin{bmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{m1} & a_{m2} & \cdots & a_{mn} \end{bmatrix} \]

Tipos especiales: - Matriz cuadrada: \(m = n\) - Matriz identidad: \(I_n = \text{diag}(1,1,\ldots,1)\) - Matriz diagonal: \(a_{ij} = 0\) para \(i \neq j\) - Matriz triangular superior/inferior

5.2 Operaciones Matriciales

Suma y resta:

\[ A \pm B = [a_{ij} \pm b_{ij}] \quad \text{(mismas dimensiones)} \]

Multiplicación por escalar:

\[ kA = [ka_{ij}] \]

Multiplicación de matrices:

$$ C = AB \quad \text{donde} \quad c_{ij} = \sum_{k=1}^{p} a_{ik}b_{kj} $$ Condición: \(A_{m\times p}\) y \(B_{p\times n}\)

Propiedades importantes:

1. NO conmutativa: \(AB \neq BA\) en general
2. Asociativa: \((AB)C = A(BC)\)
3. Distributiva: \(A(B+C) = AB + AC\)
4. Transpuesta: \((AB)^T = B^TA^T\)

5.3 Determinantes

Para matrices 2×2:

\[ \det\begin{bmatrix}a & b \\ c & d\end{bmatrix} = ad - bc \]

Para matrices 3×3 (regla de Sarrus):

\[ \det\begin{bmatrix}a & b & c \\ d & e & f \\ g & h & i\end{bmatrix} = aei + bfg + cdh - ceg - bdi - afh \]

Propiedades:

1. \(\det(AB) = \det(A)\det(B)\)
2. \(\det(A^T) = \det(A)\)
3. \(\det(kA) = k^n\det(A)\)
4. Intercambiar filas → \(\det\) cambia de signo

5.4 Matriz Inversa

Definición: \(A^{-1}\) tal que \(AA^{-1} = A^{-1}A = I\)

Condición de existencia: \(A\) es invertible si y solo si \(\det(A) \neq 0\)

Método de Gauss-Jordan:

1. Formar matriz aumentada \([A|I]\)
2. Aplicar operaciones elementales hasta obtener \([I|A^{-1}]\)

Método por adjunta:

$$ A^{-1} = \frac{1}{\det(A)}\text{adj}(A) $$ donde \(\text{adj}(A) = [C_{ji}]\) (matriz de cofactores transpuesta)

5.5 Sistemas de Ecuaciones Lineales

Forma matricial:

\[ A\vec{x} = \vec{b} \]

Tipos de sistemas:

1. Consistente determinado: Solución única (\(\det(A) \neq 0\))
2. Consistente indeterminado: Infinitas soluciones
3. Inconsistente: No tiene solución

Métodos de solución:

1. Eliminación Gaussiana
2. Regla de Cramer (solo para \(n \times n\) con \(\det(A) \neq 0\)):

$$ x_i = \frac{\det(A_i)}{\det(A)} $$ donde \(A_i\) es \(A\) con columna \(i\) reemplazada por \(\vec{b}\)

5.6 Valores y Vectores Propios

Definición:

\(\lambda\) es valor propio de \(A\) si existe \(\vec{v} \neq \vec{0}\) tal que:

\[ A\vec{v} = \lambda\vec{v} \]

Ecuación característica:

\[ \det(A - \lambda I) = 0 \]

Proceso para encontrar valores/vectores propios:

1. Resolver \(\det(A - \lambda I) = 0\) para encontrar \(\lambda\)
2. Para cada \(\lambda_i\), resolver \((A - \lambda_i I)\vec{v} = \vec{0}\) para encontrar \(\vec{v}_i\)

Diagonalización:

\(A\) es diagonalizable si existe \(P\) invertible tal que:

$$ A = PDP^{-1} $$ donde \(D\) es diagonal con valores propios y \(P\) tiene vectores propios como columnas.

6. APLICACIONES PRÁCTICAS Y ESTRATEGIAS

6.1 Resolución Sistemática de Problemas

Para operaciones con vectores:

1. Identificar el tipo de operación requerida
2. Aplicar fórmula correspondiente:
3. Suma/resta: componente a componente
4. Producto punto: sumar productos de componentes
5. Producto cruz: usar determinante simbólico
6. Interpretar geométricamente el resultado

Para sistemas de ecuaciones:

1. Escribir en forma matricial \(A\vec{x} = \vec{b}\)
2. Calcular \(\det(A)\) para determinar tipo de sistema
3. Aplicar método adecuado:
4. Si \(\det(A) \neq 0\): usar eliminación, Cramer o inversa
5. Si \(\det(A) = 0\): analizar consistencia

6.2 Verificación de Resultados

Para vectores: - Verificar ortogonalidad: \(\vec{u} \cdot \vec{v} = 0\) - Verificar paralelismo: \(\vec{u} \times \vec{v} = \vec{0}\) - Comprobar magnitudes con fórmulas conocidas

Para matrices: - Verificar \(AA^{-1} = I\) para inversas - Comprobar \(\det(AB) = \det(A)\det(B)\) - Verificar \((AB)^T = B^TA^T\)

6.3 Casos Especiales y Excepciones

Vectores:

1. Vectores paralelos: Producto cruz = \(\vec{0}\)
2. Vectores ortogonales: Producto punto = \(0\)
3. Vectores coplanares: Triple producto escalar = \(0\)

Matrices:

1. Matriz singular: \(\det(A) = 0\), no invertible
2. Matriz simétrica: \(A = A^T\), valores propios reales
3. Matriz ortogonal: \(A^T = A^{-1}\)

6.4 Consejos para Exámenes

1. Dibujar siempre que sea posible para visualizar el problema
2. Verificar dimensiones antes de operaciones matriciales
3. Usar propiedades para simplificar cálculos
4. Comprobar resultados con métodos alternativos
5. Practicar con problemas que combinen múltiples conceptos