Un conjunto es linealmente independiente cuando ninguno de sus vectores puede construirse a partir de los demás. La dependencia revela direcciones redundantes.
Un conjunto de vectores puede contener información repetida. Si un vector es múltiplo o combinación de otros, no aporta una dirección nueva.
La independencia lineal formaliza la ausencia de esa redundancia. Es esencial para construir bases, medir dimensiones y determinar si una representación mediante coordenadas es única.
Dados v1, ..., vk, estudiamos las combinaciones lineales que producen el vector cero:
La elección c1 = ... = ck = 0 siempre funciona y se denomina solución trivial. La pregunta es si existe alguna solución con al menos un coeficiente no nulo.
function combinacion(vectores, coeficientes) {
return vectores[0].map((_, componente) =>
vectores.reduce(
(suma, vector, i) => suma + coeficientes[i] * vector[componente],
0
)
);
}
console.log(combinacion([[1, 0], [0, 1]], [0, 0])); // [0, 0]Los vectores v1, ..., vk son linealmente independientes si la única forma de producir el vector cero es utilizar todos los coeficientes iguales a cero.
En ese caso ninguno de los vectores puede escribirse como combinación lineal de los restantes.
Un conjunto es linealmente dependiente si existe una combinación no trivial que produce cero.
Despejando un coeficiente no nulo se demuestra que alguno de los vectores es combinación de los demás.
const v1 = [1, 0];
const v2 = [0, 1];
const v3 = [1, 1];
const relacion = v1.map((valor, i) => valor + v2[i] - v3[i]);
console.log(relacion); // [0, 0]: v1 + v2 - v3 = 0Los vectores (1, 0) y (0, 1) son independientes. Si:
al comparar componentes se obtiene a = 0 y b = 0.
const v1 = [1, 0];
const v2 = [0, 1];
const determinante = v1[0] * v2[1] - v2[0] * v1[1];
console.log(determinante); // 1: los vectores son independientesDos vectores no nulos son dependientes si uno es múltiplo escalar del otro. Por ejemplo, (2, 4) y (−1, −2) apuntan sobre la misma recta.
function dependientes2D(u, v, tolerancia = 1e-10) {
const determinante = u[0] * v[1] - u[1] * v[0];
return Math.abs(determinante) <= tolerancia;
}
console.log(dependientes2D([2, 4], [-1, -2])); // true
console.log(dependientes2D([2, 4], [1, 3])); // falseEn un espacio de dimensión n, cualquier conjunto con más de n vectores es linealmente dependiente.
| Espacio | Cantidad que garantiza dependencia |
|---|---|
| ℝ2 | 3 o más vectores |
| ℝ3 | 4 o más vectores |
| ℝn | Más de n vectores |
Por ejemplo, en ℝ2 el vector (1, 1) necesariamente depende de dos direcciones independientes como (1, 0) y (0, 1).
Los vectores canónicos e1, e2 y e3 son independientes. La ecuación ae1 + be2 + ce3 = 0 obliga a que a = b = c = 0.
const e1 = [1, 0, 0];
const e2 = [0, 1, 0];
const e3 = [0, 0, 1];
const matriz = [e1, e2, e3];
const det =
matriz[0][0] * (matriz[1][1] * matriz[2][2] - matriz[1][2] * matriz[2][1]) -
matriz[0][1] * (matriz[1][0] * matriz[2][2] - matriz[1][2] * matriz[2][0]) +
matriz[0][2] * (matriz[1][0] * matriz[2][1] - matriz[1][1] * matriz[2][0]);
console.log(det); // 1Todo conjunto que contiene el vector cero es dependiente. Basta asignar un coeficiente no nulo al vector cero y cero a todos los demás.
function contieneVectorCero(vectores, tolerancia = 1e-12) {
return vectores.some(vector =>
vector.every(componente => Math.abs(componente) <= tolerancia)
);
}
console.log(contieneVectorCero([[1, 0], [0, 0], [0, 1]])); // trueSe colocan los vectores como columnas de una matriz A. La ecuación de dependencia se convierte en:
Las columnas son independientes si el sistema homogéneo solo tiene la solución c = 0. Equivalentemente:
function vectoresComoColumnas(vectores) {
const dimension = vectores[0].length;
return Array.from({ length: dimension }, (_, fila) =>
vectores.map(vector => vector[fila])
);
}
console.log(vectoresComoColumnas([[1, 2, 0], [3, -1, 4]]));
// [[1, 3], [2, -1], [0, 4]]Si hay n vectores de ℝn, la matriz de columnas es cuadrada y puede utilizarse el determinante:
Este criterio solo se aplica directamente cuando la matriz formada es cuadrada.
function det2Columnas(u, v) {
return u[0] * v[1] - v[0] * u[1];
}
console.log(det2Columnas([1, 2], [3, 4])); // -2: independientes
console.log(det2Columnas([1, 2], [2, 4])); // 0: dependientesPara cualquier cantidad de vectores, la eliminación de Gauss ofrece un método general:
La siguiente función calcula el rango de la matriz de columnas con pivoteo parcial.
function rango(matriz, tolerancia = 1e-10) {
const m = matriz.map(fila => [...fila]);
const columnas = m[0]?.length ?? 0;
let pivotes = 0;
for (let columna = 0; columna < columnas && pivotes < m.length; columna++) {
let mejor = pivotes;
for (let fila = pivotes + 1; fila < m.length; fila++) {
if (Math.abs(m[fila][columna]) > Math.abs(m[mejor][columna])) mejor = fila;
}
if (Math.abs(m[mejor][columna]) <= tolerancia) continue;
[m[pivotes], m[mejor]] = [m[mejor], m[pivotes]];
for (let fila = pivotes + 1; fila < m.length; fila++) {
const factor = m[fila][columna] / m[pivotes][columna];
for (let j = columna; j < columnas; j++) {
m[fila][j] -= factor * m[pivotes][j];
}
}
pivotes++;
}
return pivotes;
}
function sonIndependientes(vectores) {
if (vectores.length === 0) return true;
const dimension = vectores[0].length;
if (vectores.some(v => v.length !== dimension)) throw new Error("Dimensiones distintas");
const matriz = Array.from({ length: dimension }, (_, i) =>
vectores.map(v => v[i])
);
return rango(matriz) === vectores.length;
}
console.log(sonIndependientes([[1, 0], [0, 1]])); // true
console.log(sonIndependientes([[1, 0], [0, 1], [1, 1]])); // falseNo basta con saber que un conjunto es dependiente: a menudo interesa exhibir la relación. Si v3 = v1 + 2v2, entonces:
const v1 = [1, 0, 1];
const v2 = [0, 1, 1];
const v3 = [1, 2, 3];
const coeficientes = [1, 2, -1];
const vectores = [v1, v2, v3];
const resultado = v1.map((_, componente) =>
vectores.reduce(
(suma, vector, i) => suma + coeficientes[i] * vector[componente],
0
)
);
console.log(resultado); // [0, 0, 0]En general, los coeficientes se obtienen resolviendo Ac = 0 y buscando una solución no trivial.
| Conjunto | Independencia geométrica |
|---|---|
| Un vector | Es independiente si no es cero |
| Dos vectores en ℝ2 o ℝ3 | Son independientes si no son paralelos |
| Tres vectores en ℝ3 | Son independientes si no están contenidos en un mismo plano por el origen |
La independencia indica que cada vector permite avanzar en una dirección que los anteriores no podían generar.
const tieneDuplicados = vectores =>
vectores.some((v, i) =>
vectores.some((w, j) => j > i && v.every((valor, k) => valor === w[k]))
);
console.log(tieneDuplicados([[1, 0], [0, 1], [1, 0]])); // trueEn un conjunto de datos, una característica que es combinación exacta de otras no agrega información lineal. Por ejemplo, si total = precio + impuesto, las tres columnas contienen una relación.
const precio = [100, 200, 150];
const impuesto = [21, 42, 31.5];
const total = precio.map((valor, i) => valor + impuesto[i]);
const relacion = total.map(
(valor, i) => precio[i] + impuesto[i] - valor
);
console.log(relacion); // [0, 0, 0]Eliminar redundancia puede reducir almacenamiento, simplificar modelos y evitar matrices singulares.
Con datos decimales, dos vectores pueden ser casi dependientes sin serlo exactamente. El resultado computacional depende de una tolerancia relacionada con la escala y la precisión requeridas.
const u = [1, 2];
const v = [2, 4 + 1e-12];
const determinante = u[0] * v[1] - u[1] * v[0];
console.log(determinante); // un valor muy pequeño, no exactamente cero
console.log(Math.abs(determinante) < 1e-10); // casi dependientesErrores habituales son comprobar solo si hay vectores iguales, confundir ortogonalidad con independencia, usar el determinante en una matriz rectangular, colocar mal los vectores como columnas y comparar residuos decimales exactamente con cero.
La independencia lineal identifica conjuntos sin direcciones redundantes. Los sistemas homogéneos, el rango y el determinante ofrecen criterios equivalentes para detectarla.
En el próximo tema utilizaremos este concepto para definir bases y la dimensión de un espacio vectorial.