Un espacio vectorial es un conjunto cuyos elementos pueden sumarse y multiplicarse por escalares respetando reglas comunes. Esta estructura reúne bajo una misma teoría vectores, matrices, polinomios y muchas otras entidades.
Hasta ahora hemos utilizado vectores como listas de coordenadas. El concepto de espacio vectorial abstrae las propiedades esenciales de esas listas y permite aplicarlas a objetos aparentemente diferentes.
Una matriz, un polinomio o una función también pueden comportarse como vectores si admiten una suma y una multiplicación por escalares que cumplen ciertos axiomas.
Un espacio vectorial V sobre un cuerpo de escalares K es un conjunto equipado con dos operaciones:
Estas operaciones deben producir elementos de V y satisfacer los axiomas de los espacios vectoriales. En este curso trabajaremos principalmente con escalares reales, es decir, K = ℝ.
| Espacio | Sus vectores | Ejemplo |
|---|---|---|
| ℝ2 | Pares de números reales | (3, −1) |
| ℝn | Listas de n números reales | (x1, ..., xn) |
| Mm×n | Matrices reales m × n | [[1, 2], [0, 3]] |
| P2 | Polinomios de grado menor o igual que 2 | 2 + x − 3x2 |
| Funciones reales | Funciones con suma y producto escalar usuales | f(x) = sen(x) |
Las operaciones deben definirse de forma compatible con la naturaleza de cada objeto.
En ℝn, la suma y el producto por un escalar se realizan componente a componente:
function sumar(u, v) {
if (u.length !== v.length) throw new Error("Dimensiones diferentes");
return u.map((valor, i) => valor + v[i]);
}
function escalar(lambda, v) {
return v.map(valor => lambda * valor);
}
console.log(sumar([1, 2, 3], [4, -1, 2])); // [5, 1, 5]
console.log(escalar(3, [1, 2, 3])); // [3, 6, 9]Para todos u, v, w de V, la suma debe cumplir:
| Axioma | Expresión |
|---|---|
| Cierre | u + v pertenece a V |
| Conmutatividad | u + v = v + u |
| Asociatividad | (u + v) + w = u + (v + w) |
| Vector cero | Existe 0 tal que v + 0 = v |
| Vector opuesto | Existe −v tal que v + (−v) = 0 |
const sumar = (u, v) => u.map((valor, i) => valor + v[i]);
const u = [1, 2];
const v = [3, -1];
console.log(sumar(u, v)); // [4, 1]
console.log(sumar(v, u)); // [4, 1]Para escalares λ, μ y vectores u, v se exige:
const sumar = (u, v) => u.map((x, i) => x + v[i]);
const porEscalar = (k, v) => v.map(x => k * x);
const u = [1, 3];
const v = [2, -1];
const k = 4;
console.log(porEscalar(k, sumar(u, v)));
console.log(sumar(porEscalar(k, u), porEscalar(k, v)));
// Ambos resultados son [12, 8].El vector cero actúa como elemento neutro de la suma. En ℝn tiene todas sus componentes iguales a cero. El opuesto de v se obtiene multiplicándolo por −1.
function vectorCero(dimension) {
return Array(dimension).fill(0);
}
const v = [4, -2, 7];
const opuesto = v.map(valor => -valor);
const suma = v.map((valor, i) => valor + opuesto[i]);
console.log(vectorCero(3)); // [0, 0, 0]
console.log(suma); // [0, 0, 0]Todo espacio vectorial contiene exactamente un vector cero, y cada vector posee un único opuesto.
Los elementos de ℝ2 son pares ordenados (x, y). Geométricamente pueden interpretarse como posiciones o desplazamientos en el plano.
La suma combina desplazamientos y el producto por escalares cambia su magnitud y, si el escalar es negativo, también su sentido.
const desplazamiento1 = [3, 1];
const desplazamiento2 = [-2, 4];
const total = desplazamiento1.map((valor, i) => valor + desplazamiento2[i]);
console.log(total); // [1, 5]ℝn generaliza el plano y el espacio tridimensional. Un vector contiene exactamente n componentes reales, aunque n sea demasiado grande para visualizarlo.
En programación, un vector de ℝn puede representar las características de un dato: edad, altura, peso, puntuación y otras mediciones.
const dato = [28, 1.75, 72, 0.83];
const nombres = ["edad", "altura", "peso", "puntuación"];
const descripcion = Object.fromEntries(
nombres.map((nombre, i) => [nombre, dato[i]])
);
console.log(descripcion);El conjunto de todas las matrices reales de tamaño fijo m × n es un espacio vectorial. La suma y el producto por escalares se realizan elemento a elemento.
El tamaño debe permanecer fijo: una matriz 2 × 2 y una matriz 3 × 2 no pertenecen al mismo espacio M2×2.
const A = [[1, 2], [3, 4]];
const B = [[-1, 0], [2, 5]];
const suma = A.map((fila, i) =>
fila.map((valor, j) => valor + B[i][j])
);
const dobleA = A.map(fila => fila.map(valor => 2 * valor));
console.log(suma); // [[0, 2], [5, 9]]
console.log(dobleA); // [[2, 4], [6, 8]]Los polinomios de grado menor o igual que 2 forman P2. Podemos representarlos mediante sus coeficientes [a0, a1, a2]:
const p = [2, 1, -3]; // 2 + x - 3x²
const q = [-1, 4, 2]; // -1 + 4x + 2x²
const suma = p.map((coeficiente, i) => coeficiente + q[i]);
console.log(suma); // [1, 5, -1]: 1 + 5x - x²La representación por coeficientes muestra que P2 se comporta de manera similar a ℝ3.
Un subconjunto W de un espacio V es un subespacio si, usando las mismas operaciones de V, también constituye un espacio vectorial.
Para comprobarlo basta verificar tres condiciones:
El conjunto W = {(x, y, z) ∈ ℝ3 : z = x + y} es un plano que pasa por el origen.
Si dos vectores cumplen la ecuación, su suma también la cumple. Multiplicar cualquiera de ellos por un escalar conserva la relación.
const pertenece = ([x, y, z]) => Math.abs(z - x - y) < 1e-10;
const u = [1, 2, 3];
const v = [4, -1, 3];
const suma = u.map((valor, i) => valor + v[i]);
const multiplo = u.map(valor => -2 * valor);
console.log(pertenece(u), pertenece(v)); // true, true
console.log(pertenece(suma), pertenece(multiplo)); // true, trueEl plano S = {(x, y, z) : z = x + y + 1} no es un subespacio. No contiene al vector cero, ya que 0 ≠ 0 + 0 + 1.
const pertenece = ([x, y, z]) => Math.abs(z - x - y - 1) < 1e-10;
const cero = [0, 0, 0];
console.log(pertenece(cero)); // falseUn plano desplazado puede ser un conjunto geométrico útil, pero si no pasa por el origen no es un subespacio del espacio vectorial usual.
Una combinación lineal de v1, ..., vk es cualquier vector de la forma:
function combinacionLineal(vectores, escalares) {
if (vectores.length !== escalares.length || vectores.length === 0) {
throw new Error("Datos incompatibles");
}
return vectores[0].map((_, componente) =>
vectores.reduce(
(suma, vector, i) => suma + escalares[i] * vector[componente],
0
)
);
}
const vectores = [[1, 0, 1], [0, 1, 1]];
console.log(combinacionLineal(vectores, [2, -1])); // [2, -1, 1]El espacio generado por un conjunto de vectores es el conjunto de todas sus combinaciones lineales. Se escribe:
El espacio generado siempre es un subespacio. Por ejemplo, gen{(1, 0, 1), (0, 1, 1)} es precisamente el plano z = x + y.
function puntoDelPlano(s, t) {
const v1 = [1, 0, 1];
const v2 = [0, 1, 1];
return v1.map((valor, i) => s * valor + t * v2[i]);
}
console.log(puntoDelPlano(3, 4)); // [3, 4, 7]Para decidir si un vector w pertenece a gen{v1, ..., vk}, se buscan escalares que satisfagan:
Esta igualdad produce un sistema lineal. Si es compatible, w pertenece al espacio generado.
// Para v1 = (1, 0, 1), v2 = (0, 1, 1),
// las dos primeras componentes obligan a usar s = x y t = y.
function perteneceAlGenerado([x, y, z], tolerancia = 1e-10) {
return Math.abs((x + y) - z) < tolerancia;
}
console.log(perteneceAlGenerado([3, 4, 7])); // true
console.log(perteneceAlGenerado([3, 4, 8])); // falseLos espacios vectoriales aparecen en gráficos, procesamiento de señales, aprendizaje automático, compresión, simulaciones y representación de datos. La abstracción permite aplicar los mismos algoritmos a diferentes tipos de objetos.
Errores habituales:
Los espacios vectoriales proporcionan un lenguaje común para estudiar coordenadas, matrices, polinomios y muchos otros objetos. Sus axiomas garantizan que las operaciones lineales se comporten de forma coherente.
En el próximo tema volveremos a la interpretación geométrica para estudiar vectores en el plano y en el espacio.