La matriz nula es el elemento neutro de la suma y la matriz identidad es el elemento neutro de la multiplicación. Ambas permiten expresar propiedades, inicializar algoritmos y comprobar operaciones matriciales.
En la aritmética, sumar cero no modifica un número y multiplicar por uno tampoco lo modifica. El álgebra de matrices posee estructuras que cumplen papeles semejantes: la matriz nula y la matriz identidad.
Estas matrices aparecen al expresar propiedades, resolver ecuaciones, calcular inversas, definir potencias e inicializar algoritmos. Sin embargo, su orden debe ser compatible con las matrices que participan en cada operación.
Una matriz nula, también llamada matriz cero, es aquella cuyos elementos son todos iguales a cero. Puede ser cuadrada o rectangular.
El subíndice 2 × 3 indica su orden. Es importante especificarlo porque existen matrices nulas de cualquier dimensión.
La matriz nula suele representarse con O o con un cero destacado. Cuando el contexto no determina su tamaño, se agrega el orden como subíndice.
| Notación | Orden | Cantidad de ceros |
|---|---|---|
| O1×3 | 1 × 3 | 3 |
| O2×2 | 2 × 2 | 4 |
| O3×1 | 3 × 1 | 3 |
| O4×5 | 4 × 5 | 20 |
Dos matrices nulas de órdenes diferentes no son iguales y no siempre pueden participar en la misma operación.
Podemos construir una matriz nula rectangular indicando su cantidad de filas y columnas.
function crearMatrizNula(filas, columnas) {
return Array.from({ length: filas }, () =>
Array.from({ length: columnas }, () => 0)
);
}
const O23 = crearMatrizNula(2, 3);
console.log(O23);Cada fila se crea de forma independiente, evitando referencias compartidas entre los arreglos internos.
Para verificar que una matriz sea nula debemos comprobar todos sus elementos.
function esMatrizNula(matriz) {
return matriz.length > 0 && matriz.every(fila =>
fila.length > 0 && fila.every(valor => valor === 0)
);
}
console.log(esMatrizNula([[0, 0], [0, 0]]));
console.log(esMatrizNula([[0, 0], [0, 1]]));Encontrar muchos ceros no es suficiente: un solo elemento distinto de cero impide que la matriz sea nula.
La matriz nula es el elemento neutro de la suma matricial. Si O tiene el mismo orden que A, entonces:
function sumarMatrices(A, B) {
return A.map((fila, i) =>
fila.map((valor, j) => valor + B[i][j])
);
}
const A = [[2, 5, 1], [4, 3, 7]];
const O = [[0, 0, 0], [0, 0, 0]];
console.log(sumarMatrices(A, O));Cada elemento aij se suma con cero, por lo que conserva su valor.
Multiplicar cualquier matriz por el escalar cero produce una matriz nula del mismo orden.
const A = [[2, 5], [4, 3]];
const O = A.map(fila =>
fila.map(valor => 0 * valor)
);
console.log(O);También, si las dimensiones permiten realizar el producto, una matriz multiplicada por una matriz nula produce otra matriz nula: AO = O y OA = O, con el orden correspondiente al resultado.
Una matriz identidad es una matriz cuadrada que tiene unos en la diagonal principal y ceros en todas las demás posiciones.
El subíndice indica el orden. La matriz I3 es 3 × 3 y la matriz In es n × n.
| Notación | Representación | Orden |
|---|---|---|
| I1 | [[1]] | 1 × 1 |
| I2 | [[1, 0], [0, 1]] | 2 × 2 |
| I3 | [[1, 0, 0], [0, 1, 0], [0, 0, 1]] | 3 × 3 |
No existe una matriz identidad rectangular no cuadrada en el sentido habitual del elemento neutro bilateral de la multiplicación.
Cada posición de la diagonal cumple fila = columna. Esa condición permite generar la matriz.
function crearIdentidad(orden) {
return Array.from({ length: orden }, (_, fila) =>
Array.from({ length: orden }, (_, columna) =>
fila === columna ? 1 : 0
)
);
}
console.log(crearIdentidad(4));La validación exige comprobar que la matriz sea cuadrada, que la diagonal contenga unos y que las demás posiciones contengan ceros.
function esIdentidad(matriz) {
const n = matriz.length;
if (!n || !matriz.every(fila => fila.length === n)) return false;
return matriz.every((fila, i) =>
fila.every((valor, j) =>
valor === (i === j ? 1 : 0)
)
);
}
console.log(esIdentidad([[1, 0], [0, 1]]));
console.log(esIdentidad([[1, 0], [1, 1]]));La matriz identidad es el elemento neutro de la multiplicación matricial. Si A es una matriz de orden m × n, se utilizan identidades de órdenes diferentes a cada lado:
function multiplicar(A, B) {
return A.map(fila =>
B[0].map((_, j) =>
fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
)
);
}
const A = [[2, 5, 1], [4, 3, 7]];
const I2 = [[1, 0], [0, 1]];
const I3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
console.log(multiplicar(I2, A));
console.log(multiplicar(A, I3));La matriz A es 2 × 3. Por eso se multiplica por I2 a la izquierda y por I3 a la derecha.
Al multiplicar un vector por la matriz identidad, sus componentes no cambian. Geométricamente, representa la transformación que deja cada punto exactamente donde estaba.
function matrizPorVector(A, vector) {
return A.map(fila =>
fila.reduce((suma, valor, j) => suma + valor * vector[j], 0)
);
}
const I3 = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
const posicion = [8, -2, 5];
console.log(matrizPorVector(I3, posicion));En gráficos, la identidad puede utilizarse como estado inicial antes de acumular rotaciones, escalados u otras transformaciones.
La inversa de una matriz cuadrada A es una matriz A-1 que, al multiplicarse por A, produce la identidad.
No todas las matrices cuadradas tienen inversa. Cuando existe, la identidad permite comprobar el resultado del cálculo.
function multiplicar2x2(A, B) {
return [
[A[0][0] * B[0][0] + A[0][1] * B[1][0],
A[0][0] * B[0][1] + A[0][1] * B[1][1]],
[A[1][0] * B[0][0] + A[1][1] * B[1][0],
A[1][0] * B[0][1] + A[1][1] * B[1][1]]
];
}
const A = [[2, 0], [0, 4]];
const inversa = [[0.5, 0], [0, 0.25]];
console.log(multiplicar2x2(A, inversa));Para una matriz cuadrada A, la potencia Ak representa la multiplicación repetida de A por sí misma. Por convenio, la potencia cero se define como la identidad del mismo orden.
La identidad permite iniciar algoritmos que calculan potencias acumulando productos sin alterar el primer resultado.
Los elementos neutros son útiles para inicializar acumuladores.
function crearIdentidad(orden) {
return Array.from({ length: orden }, (_, i) =>
Array.from({ length: orden }, (_, j) => i === j ? 1 : 0)
);
}
const acumuladorProducto = crearIdentidad(3);
const acumuladorSuma = Array.from({ length: 3 }, () => [0, 0, 0]);
console.log(acumuladorProducto);
console.log(acumuladorSuma);Los cálculos con números de punto flotante pueden producir pequeñas diferencias de redondeo. Después de varias operaciones, un valor esperado como cero podría ser 0.0000000001.
En esos casos conviene comparar con una tolerancia en lugar de exigir igualdad exacta.
function esIdentidadAproximada(matriz, tolerancia = 1e-9) {
const n = matriz.length;
if (!n || !matriz.every(fila => fila.length === n)) return false;
return matriz.every((fila, i) =>
fila.every((valor, j) => {
const esperado = i === j ? 1 : 0;
return Math.abs(valor - esperado) <= tolerancia;
})
);
}
const casiIdentidad = [[1, 1e-12], [-1e-12, 1]];
console.log(esIdentidadAproximada(casiIdentidad));La matriz nula y la matriz identidad trasladan a las matrices las ideas de cero y uno como elementos neutros. Su orden y posición dentro de una operación son esenciales para conservar la compatibilidad de dimensiones.
En el próximo tema estudiaremos las matrices diagonales, triangulares y simétricas, estructuras que aprovechan la ubicación especial de sus elementos.