La traza es la suma de los elementos de la diagonal principal de una matriz cuadrada. Produce un único número y posee propiedades útiles para simplificar expresiones y analizar transformaciones.
Una matriz puede contener muchos elementos, pero algunas operaciones extraen de ella un único número. La traza toma solamente los valores de la diagonal principal y los suma.
Aunque el cálculo es sencillo, la traza aparece en estadística, geometría, optimización, aprendizaje automático y estudio de transformaciones lineales.
Sea A una matriz cuadrada de orden n. La traza se representa como tr(A) y se define mediante:
El resultado es un escalar. Los elementos fuera de la diagonal principal no participan directamente en el cálculo.
Los valores 8 y 2 no se suman porque se encuentran fuera de la diagonal principal.
const B = [
[4, 2, 1],
[7, -3, 5],
[6, 8, 9]
];
const traza = B.reduce((suma, fila, i) =>
suma + fila[i],
0
);
console.log(traza);En este curso definiremos la traza para matrices cuadradas. Así, la diagonal principal relaciona cada fila con una columna correspondiente dentro del mismo espacio.
| Orden | ¿Es cuadrada? | ¿Definimos traza? |
|---|---|---|
| 1 × 1 | Sí | Sí |
| 2 × 2 | Sí | Sí |
| 3 × 3 | Sí | Sí |
| 2 × 3 | No | No |
| 4 × 2 | No | No |
Una implementación segura debe comprobar que la matriz sea cuadrada y numérica.
function traza(matriz) {
if (!Array.isArray(matriz) || matriz.length === 0) {
throw new Error("La matriz no puede estar vacía");
}
const n = matriz.length;
const valida = matriz.every(fila =>
Array.isArray(fila) &&
fila.length === n &&
fila.every(Number.isFinite)
);
if (!valida) throw new Error("La traza requiere una matriz cuadrada numérica");
return matriz.reduce((suma, fila, i) => suma + fila[i], 0);
}
console.log(traza([[3, 8], [2, 5]]));La traza de una suma es la suma de las trazas. La misma relación se cumple con la resta.
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const sumar = (A, B) => A.map((fila, i) =>
fila.map((valor, j) => valor + B[i][j])
);
const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
console.log(traza(sumar(A, B)));
console.log(traza(A) + traza(B));Un escalar puede salir de la traza.
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const A = [[2, 5], [1, 7]];
const k = -3;
const kA = A.map(fila => fila.map(valor => k * valor));
console.log(traza(kA));
console.log(k * traza(A));Las dos propiedades anteriores se resumen diciendo que la traza es una operación lineal.
Transponer no cambia los elementos de la diagonal principal, por lo que la traza permanece igual.
const transponer = A => A[0].map((_, j) => A.map(fila => fila[j]));
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
console.log(traza(A));
console.log(traza(transponer(A)));Si los productos AB y BA están definidos y son cuadrados, sus trazas son iguales.
Esto no significa que AB = BA. Las matrices producto pueden ser diferentes y aun así compartir la misma traza.
const multiplicar = (A, B) => A.map(fila =>
B[0].map((_, j) =>
fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
)
);
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const A = [[1, 2], [0, 1]];
const B = [[2, 0], [3, 1]];
const AB = multiplicar(A, B);
const BA = multiplicar(B, A);
console.log(AB, traza(AB));
console.log(BA, traza(BA));La igualdad tr(AB) = tr(BA) también puede aplicarse cuando A y B son rectangulares compatibles. Si A es m × n y B es n × m, entonces AB es m × m y BA es n × n.
const multiplicar = (A, B) => A.map(fila =>
B[0].map((_, j) =>
fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
)
);
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const A = [[1, 2, 3], [4, 5, 6]];
const B = [[7, 8], [9, 10], [11, 12]];
const AB = multiplicar(A, B);
const BA = multiplicar(B, A);
console.log(`AB es ${AB.length} × ${AB[0].length}, traza:`, traza(AB));
console.log(`BA es ${BA.length} × ${BA[0].length}, traza:`, traza(BA));En un producto de varios factores compatibles, podemos mover cíclicamente los factores sin cambiar la traza.
No podemos realizar una permutación arbitraria. Por ejemplo, tr(ABC) no tiene por qué ser igual a tr(ACB).
const multiplicar = (A, B) => A.map(fila =>
B[0].map((_, j) =>
fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
)
);
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const A = [[1, 2], [0, 1]];
const B = [[2, 0], [1, 3]];
const C = [[1, 1], [2, 0]];
console.log(traza(multiplicar(multiplicar(A, B), C)));
console.log(traza(multiplicar(multiplicar(B, C), A)));
console.log(traza(multiplicar(multiplicar(C, A), B)));La identidad In contiene n unos en su diagonal, mientras que la matriz nula contiene ceros.
function crearIdentidad(n) {
return Array.from({ length: n }, (_, i) =>
Array.from({ length: n }, (_, j) => i === j ? 1 : 0)
);
}
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
const I4 = crearIdentidad(4);
const O4 = Array.from({ length: 4 }, () => [0, 0, 0, 0]);
console.log(traza(I4));
console.log(traza(O4));En una matriz diagonal o triangular, la traza sigue siendo la suma de la diagonal. Los ceros estructurales fuera de ella no afectan el cálculo.
const diagonal = [[5, 0, 0], [0, 2, 0], [0, 0, 8]];
const triangular = [[3, 7, 1], [0, -2, 4], [0, 0, 6]];
const traza = A => A.reduce((suma, fila, i) => suma + fila[i], 0);
console.log("Diagonal:", traza(diagonal));
console.log("Triangular:", traza(triangular));Para matrices A y B del mismo orden, la suma de los productos de elementos correspondientes puede expresarse mediante la traza.
function productoFrobenius(A, B) {
return A.reduce((total, fila, i) =>
total + fila.reduce(
(suma, valor, j) => suma + valor * B[i][j],
0
),
0
);
}
const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
console.log(productoFrobenius(A, B));Esta relación se utiliza para medir similitud y definir normas de matrices.
| Área | Uso |
|---|---|
| Estadística | Suma de varianzas en una matriz de covarianza |
| Geometría | Describir parte del comportamiento de una transformación |
| Optimización | Expresar funciones y derivadas matriciales |
| Aprendizaje automático | Formular pérdidas y regularizaciones |
| Álgebra lineal | Relacionar una matriz con la suma de sus valores propios |
const covarianza = [
[4.2, 1.1, 0.4],
[1.1, 2.8, 0.7],
[0.4, 0.7, 3.5]
];
const varianzaTotal = covarianza.reduce(
(suma, fila, i) => suma + fila[i],
0
);
console.log(varianzaTotal);La diagonal contiene la varianza de cada variable; la traza suma todas esas varianzas.
Para una matriz n × n, calcular la traza requiere leer solamente n elementos. No es necesario recorrer los n² valores.
Cuando la diagonal contiene muchos números de magnitudes muy diferentes, los errores de redondeo pueden acumularse. Una suma compensada puede mejorar la precisión.
function trazaCompensada(A) {
let suma = 0;
let compensacion = 0;
for (let i = 0; i < A.length; i++) {
const valor = A[i][i];
const temporal = suma + valor;
if (Math.abs(suma) >= Math.abs(valor)) {
compensacion += (suma - temporal) + valor;
} else {
compensacion += (valor - temporal) + suma;
}
suma = temporal;
}
return suma + compensacion;
}
const A = [[1e16, 0, 0], [0, 1, 0], [0, 0, -1e16]];
console.log(trazaCompensada(A));La traza resume la diagonal principal en un solo número y permite transformar expresiones matriciales mediante propiedades lineales y cíclicas. Su cálculo es económico porque solo necesita n elementos de una matriz n × n.
En el próximo tema estudiaremos los determinantes, escalares que permiten analizar cambios de escala, invertibilidad y dependencia en matrices cuadradas.