Una transformación lineal preserva sumas y productos por escalares. Esta propiedad permite conocer su efecto sobre todo un espacio a partir de su acción sobre una base.
Una transformación toma un vector de entrada y produce un vector de salida. Puede cambiar su posición, orientación, escala o incluso la dimensión del espacio.
Las transformaciones lineales son especiales porque respetan la estructura vectorial. Por eso pueden estudiarse mediante bases, matrices y sistemas de ecuaciones.
Una transformación T de V en W asigna a cada vector v de V un único vector T(v) de W:
V es el dominio y W el codominio. Ambos espacios deben trabajar sobre el mismo cuerpo de escalares para la definición usual de linealidad.
const T = ([x, y, z]) => [x + y, z - y];
console.log(T([2, 3, 7])); // [5, 4]
// T transforma vectores de R³ en vectores de R².T es lineal si para todos los vectores u, v y todo escalar c cumple:
Ambas condiciones son necesarias. Verificar solamente una no demuestra linealidad.
const T = ([x, y]) => [2 * x - y, 3 * y];
const sumar = (u, v) => u.map((valor, i) => valor + v[i]);
const u = [1, 2];
const v = [3, -1];
console.log(T(sumar(u, v)));
console.log(sumar(T(u), T(v)));
// Ambos resultados son [7, 3].Las dos condiciones pueden reunirse en una sola propiedad:
Por extensión, T preserva cualquier combinación lineal finita.
const T = ([x, y]) => [x + y, x - y];
const u = [1, 2];
const v = [3, 4];
const a = 2;
const b = -1;
const entrada = u.map((valor, i) => a * valor + b * v[i]);
const derecha = T(u).map((valor, i) => a * valor + b * T(v)[i]);
console.log(T(entrada)); // [-4, 0]
console.log(derecha); // [-4, 0]Aplicando homogeneidad con el escalar 0:
Por tanto, si T(0) ≠ 0, podemos concluir inmediatamente que T no es lineal.
const lineal = ([x, y]) => [2 * x, x - y];
const traslacion = ([x, y]) => [x + 3, y - 1];
console.log(lineal([0, 0])); // [0, 0]
console.log(traslacion([0, 0])); // [3, -1]: no es linealEl escalado T(x, y) = (sxx, syy) es lineal. Puede ampliar, reducir, reflejar o aplastar direcciones.
function escalar2D([x, y], sx, sy) {
return [sx * x, sy * y];
}
console.log(escalar2D([3, -2], 2, 0.5)); // [6, -1]
console.log(escalar2D([3, -2], -1, 1)); // [-3, -2]Si algún factor es cero, la transformación pierde información y no puede invertirse.
Rotar el plano un ángulo θ alrededor del origen es una transformación lineal:
function rotar([x, y], grados) {
const theta = grados * Math.PI / 180;
const c = Math.cos(theta);
const s = Math.sin(theta);
return [c * x - s * y, s * x + c * y];
}
console.log(rotar([1, 0], 90)); // aproximadamente [0, 1]Una rotación alrededor de un punto distinto del origen incluye una traslación y no es lineal en las coordenadas usuales.
La proyección sobre una recta que pasa por el origen es lineal. Por ejemplo, proyectar sobre el eje x elimina la componente y:
const proyectarEjeX = ([x, y]) => [x, 0];
console.log(proyectarEjeX([4, 7])); // [4, 0]
console.log(proyectarEjeX([-2, 3])); // [-2, 0]La transformación reduce el plano a una recta, por lo que pierde la información vertical.
Un cizallamiento horizontal desplaza x en proporción a y:
function cizallarHorizontal([x, y], k) {
return [x + k * y, y];
}
console.log(cizallarHorizontal([2, 3], 0.5)); // [3.5, 3]Las líneas paralelas permanecen paralelas, aunque cambian los ángulos y la forma.
Una traslación tiene la forma T(v) = v + a con a ≠ 0. No preserva el origen y tampoco cumple homogeneidad.
La traslación es una transformación afín. Puede manejarse junto con operaciones lineales usando coordenadas homogéneas, que se estudiarán en aplicaciones geométricas.
| Transformación | Motivo de no linealidad |
|---|---|
| T(x, y) = (x2, y) | No preserva el producto por escalares |
| T(x, y) = (|x|, y) | No preserva la suma en general |
| T(x, y) = (x + 1, y) | No lleva cero a cero |
| T(x, y) = (xy, y) | Incluye un producto entre variables |
const cuadratica = ([x, y]) => [x ** 2, y];
const v = [2, 1];
console.log(cuadratica(v).map(valor => 2 * valor)); // [8, 2]
console.log(cuadratica(v.map(valor => 2 * valor))); // [16, 2]
// T(2v) no coincide con 2T(v).Si B = {b1, ..., bn} es una base y v = c1b1 + ... + cnbn, entonces:
Por eso basta conocer la imagen de los vectores de una base para conocer T sobre todo el espacio.
const Te1 = [2, 1];
const Te2 = [-1, 3];
const v = [4, -2]; // 4e1 - 2e2
const Tv = Te1.map((valor, i) => v[0] * valor + v[1] * Te2[i]);
console.log(Tv); // [10, -2]El núcleo reúne los vectores que T transforma en cero:
El núcleo es un subespacio del dominio y describe la información que desaparece.
const T = ([x, y, z]) => [x + y, y + z];
const vectorDelNucleo = [-1, 1, -1];
console.log(T(vectorDelNucleo)); // [0, 0]La imagen contiene todos los resultados que T puede producir:
Es un subespacio del codominio. Su dimensión es el rango de la transformación.
const T = ([x, y, z]) => {
const a = x + y;
return [a, 2 * a];
};
console.log(T([3, -1, 9])); // [2, 4]
console.log(T([0, 5, -2])); // [5, 10]
// Todas las salidas están sobre la recta (a, 2a).Si el dominio V tiene dimensión finita:
Por ejemplo, la proyección T(x, y, z) = (x, y) tiene rango 2 y núcleo generado por (0, 0, 1), de dimensión 1. La suma es 3.
const dimensionDominio = 3;
const rango = 2;
const nulidad = dimensionDominio - rango;
console.log({ rango, nulidad }); // { rango: 2, nulidad: 1 }| Propiedad | Criterio lineal |
|---|---|
| Inyectiva | ker(T) = {0} |
| Sobreyectiva | im(T) coincide con el codominio |
| Invertible | Es inyectiva y sobreyectiva |
Entre espacios de igual dimensión finita, una transformación lineal es inyectiva si y solo si es sobreyectiva; en ese caso es invertible.
La composición de transformaciones lineales también es lineal. Si S : U → V y T : V → W, entonces T ∘ S : U → W.
const escalar = ([x, y]) => [2 * x, 2 * y];
const rotar90 = ([x, y]) => [-y, x];
const componer = (T, S) => vector => T(S(vector));
const transformar = componer(rotar90, escalar);
console.log(transformar([3, 1])); // [-2, 6]Si T es invertible, T-1 también es lineal y deshace su efecto.
Las transformaciones lineales aparecen en gráficos, procesamiento de imágenes, señales, compresión, aprendizaje automático y simulación.
Una prueba con algunos vectores puede detectar un fallo, pero no demuestra por sí sola que una función sea lineal para todas las entradas.
function comprobarEjemplo(T, u, v, a, tolerancia = 1e-10) {
const sumar = (x, y) => x.map((valor, i) => valor + y[i]);
const escalar = (k, x) => x.map(valor => k * valor);
const cerca = (x, y) => x.every((valor, i) => Math.abs(valor - y[i]) <= tolerancia);
return cerca(T(sumar(u, v)), sumar(T(u), T(v))) &&
cerca(T(escalar(a, u)), escalar(a, T(u)));
}
console.log(comprobarEjemplo(([x, y]) => [2 * x, x + y], [1, 2], [3, 4], -2));
// true para esta pruebaErrores habituales son confundir transformaciones lineales con afines, comprobar solo T(0) = 0, olvidar una de las dos condiciones, confundir imagen con codominio y suponer que toda transformación lineal tiene inversa.
Las transformaciones lineales preservan la estructura esencial de los espacios vectoriales. Sus núcleos e imágenes permiten medir pérdida de información y alcance, mientras que su acción sobre una base resume todo su comportamiento.
En el próximo tema aprenderemos a representar una transformación lineal mediante una matriz.