19. Matriz inversa

La inversa de una matriz revierte su transformación. Existe únicamente para matrices cuadradas no singulares y produce la identidad al multiplicarse por la matriz original.

19.1 Introducción

Para un número distinto de cero, su inverso multiplicativo es el número que produce 1 al multiplicarse. Por ejemplo, el inverso de 4 es 1/4.

En matrices, el papel del número 1 lo cumple la matriz identidad. La matriz inversa de A es aquella que, al multiplicarse por A, produce la identidad.

AA-1 = A-1A = I

19.2 Definición

Sea A una matriz cuadrada de orden n. Si existe una matriz B del mismo orden tal que:

AB = BA = In

entonces B es la inversa de A y se escribe B = A-1. En ese caso decimos que A es invertible o no singular.

El exponente -1 no significa elevar cada elemento a -1 ni calcular sus recíprocos individualmente.

19.3 Condiciones de existencia

Condición Necesaria para la inversa habitual
La matriz es cuadrada Sí
det(A) ≠ 0 Sí
Filas y columnas independientes Sí
Rango igual al orden n Sí
Todos los elementos distintos de cero No

Estas condiciones son equivalentes para una matriz cuadrada. Más adelante estudiaremos el rango y la independencia lineal con detalle.

19.4 Unicidad y producto por ambos lados

Si una matriz cuadrada tiene inversa, esa inversa es única. No puede haber dos matrices diferentes que reviertan completamente la misma transformación.

Además, en matrices cuadradas, si B cumple AB = I, también cumple BA = I. Por eso se utiliza la misma inversa a la izquierda y a la derecha.

La inversa, cuando existe, tiene el mismo orden que A y es única.

19.5 Fórmula para una matriz 2 × 2

Sea:

A = [a   b]
    [c   d]

det(A) = ad - bc

Si det(A) ≠ 0, la inversa es:

A-1 = 1/(ad - bc) · [  d   -b ]
                         [-c     a ] 
function inversa2x2(A) {
  const [[a, b], [c, d]] = A;
  const det = a * d - b * c;

  if (det === 0) throw new Error("La matriz no tiene inversa");

  return [
    [ d / det, -b / det],
    [-c / det,  a / det]
  ];
}

console.log(inversa2x2([[4, 1], [2, 1]]));

19.6 Ejemplo paso a paso

Consideremos la matriz:

A = [4   1]
    [2   1]

det(A) = 4·1 - 1·2 = 2

A-1 = 1/2 · [ 1   -1 ] = [ 0.5   -0.5 ]
                      [ -2    4 ]   [ -1      2 ]

El determinante distinto de cero permite realizar la división.

19.7 Verificación mediante multiplicación

La forma más directa de comprobar una inversa es multiplicar en ambos órdenes y comparar con la identidad.

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 = [[4, 1], [2, 1]];
const inversa = [[0.5, -0.5], [-1, 2]];

console.log(multiplicar2x2(A, inversa));
console.log(multiplicar2x2(inversa, A));

Ambos resultados son I2.

19.8 Matrices sin inversa

Una matriz singular tiene determinante cero y no puede revertir su transformación.

S = [1   2]
    [2   4]

det(S) = 1·4 - 2·2 = 0

La segunda fila es el doble de la primera. La transformación pierde una dimensión y distintas entradas pueden producir la misma salida.

function esInvertible2x2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return det !== 0;
}

console.log(esInvertible2x2([[4, 1], [2, 1]]));
console.log(esInvertible2x2([[1, 2], [2, 4]]));

19.9 Identidad y matrices diagonales

La identidad es su propia inversa. Una matriz diagonal es invertible si todos sus elementos diagonales son distintos de cero; su inversa contiene los recíprocos.

I-1 = I

diag(d1, ..., dn)-1
= diag(1/d1, ..., 1/dn) 
function inversaDiagonal(diagonal) {
  if (diagonal.some(valor => valor === 0)) {
    throw new Error("Todos los valores diagonales deben ser distintos de cero");
  }

  return diagonal.map((valor, i) =>
    diagonal.map((_, j) => i === j ? 1 / valor : 0)
  );
}

console.log(inversaDiagonal([2, 4, -5]));

19.10 Inversa de un producto

La inversa de un producto invierte cada factor y también invierte su orden.

(AB)-1 = B-1A-1

El orden es esencial: B-1 revierte primero la acción de B que quedó más cerca de la salida de AB.

const multiplicar = (A, B) => A.map(fila =>
  B[0].map((_, j) =>
    fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
  )
);

function inversa2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}

const A = [[2, 0], [0, 3]];
const B = [[1, 1], [0, 1]];

console.log(inversa2(multiplicar(A, B)));
console.log(multiplicar(inversa2(B), inversa2(A)));

19.11 Inversa y transpuesta

Transponer e invertir pueden aplicarse en cualquier orden.

(AT)-1 = (A-1)T 
const transponer = A => A[0].map((_, j) => A.map(fila => fila[j]));
function inversa2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}

const A = [[4, 1], [2, 1]];

console.log(inversa2(transponer(A)));
console.log(transponer(inversa2(A)));

19.12 Inversa de un múltiplo escalar

Si A es invertible y k ≠ 0, entonces:

(kA)-1 = (1/k)A-1 
function inversa2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}
const escalar = (A, k) => A.map(fila => fila.map(valor => k * valor));

const A = [[4, 1], [2, 1]];
const k = 3;

console.log(inversa2(escalar(A, k)));
console.log(escalar(inversa2(A), 1 / k));

19.13 Inversa de la inversa y potencias

(A-1)-1 = A
(Am)-1 = (A-1)m 
const multiplicar = (A, B) => A.map(fila =>
  B[0].map((_, j) =>
    fila.reduce((suma, valor, k) => suma + valor * B[k][j], 0)
  )
);
function inversa2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}

const A = [[2, 1], [1, 2]];
const A2 = multiplicar(A, A);
const inversa = inversa2(A);

console.log(inversa2(A2));
console.log(multiplicar(inversa, inversa));

19.14 Resolución de sistemas lineales

Si A es invertible, el sistema Ax = b puede escribirse como:

Ax = b
A-1Ax = A-1b
x = A-1b 
function inversa2(A) {
  const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}
const matrizPorVector = (A, v) => A.map(fila =>
  fila.reduce((suma, valor, j) => suma + valor * v[j], 0)
);

const A = [[2, 1], [1, 3]];
const b = [7, 11];
const x = matrizPorVector(inversa2(A), b);

console.log(x);
console.log("Verificación Ax:", matrizPorVector(A, x));

En software numérico suele ser más eficiente y estable resolver Ax = b directamente mediante factorización o eliminación que calcular A-1 de forma explícita.

19.15 Interpretación geométrica

Si A rota, escala o deforma el espacio sin colapsarlo, A-1 revierte esa transformación.

const aplicar = (A, v) => A.map(fila =>
  fila.reduce((suma, valor, j) => suma + valor * v[j], 0)
);

const transformacion = [[2, 0], [0, 0.5]];
const inversa = [[0.5, 0], [0, 2]];
const punto = [3, 4];

const transformado = aplicar(transformacion, punto);
const recuperado = aplicar(inversa, transformado);

console.log(transformado);
console.log(recuperado);

La primera matriz duplica x y reduce y a la mitad; la inversa realiza exactamente lo contrario.

19.16 Relación con el determinante

El determinante de la inversa es el recíproco del determinante original.

det(A-1) = 1 / det(A) 
const det2 = A => A[0][0] * A[1][1] - A[0][1] * A[1][0];
function inversa2(A) {
  const det = det2(A);
  return [[A[1][1] / det, -A[0][1] / det],
          [-A[1][0] / det, A[0][0] / det]];
}

const A = [[4, 1], [2, 1]];

console.log(det2(inversa2(A)));
console.log(1 / det2(A));

19.17 Implementación robusta para orden 2

Con datos decimales conviene validar la forma y utilizar una tolerancia relacionada con la escala.

function inversa2x2(A, factorTolerancia = 100) {
  const valida = Array.isArray(A) && A.length === 2 &&
    A.every(fila =>
      Array.isArray(fila) && fila.length === 2 && fila.every(Number.isFinite)
    );

  if (!valida) throw new Error("Se requiere una matriz numérica 2 × 2");

  const [[a, b], [c, d]] = A;
  const det = a * d - b * c;
  const escala = Math.max(...A.flat().map(Math.abs));
  const tolerancia = factorTolerancia * Number.EPSILON * Math.max(1, escala ** 2);

  if (Math.abs(det) <= tolerancia) {
    throw new Error("La matriz es singular o numéricamente casi singular");
  }

  return [[d / det, -b / det], [-c / det, a / det]];
}

console.log(inversa2x2([[4, 1], [2, 1]]));

19.18 Matrices casi singulares y errores frecuentes

Una matriz puede tener determinante distinto de cero pero muy pequeño respecto de sus elementos. Su inversa puede contener valores enormes y amplificar errores de entrada.

const A = [[1, 1], [1, 1.000001]];
const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
const inversa = [
  [ A[1][1] / det, -A[0][1] / det],
  [-A[1][0] / det,  A[0][0] / det]
];

console.log("Determinante:", det);
console.log("Inversa:", inversa);

Los errores frecuentes son invertir elementos individualmente, olvidar invertir el orden en (AB)-1, intentar invertir una matriz rectangular o singular, comparar el determinante con cero sin tolerancia y formar la inversa cuando solo se necesita resolver un sistema.

19.19 Qué debes recordar de este tema

  • La inversa satisface AA-1 = A-1A = I.
  • La inversa habitual existe para matrices cuadradas con determinante no nulo.
  • La inversa es única y tiene el mismo orden que A.
  • La inversa no se obtiene calculando recíprocos elemento a elemento.
  • (AB)-1 = B-1A-1.
  • (AT)-1 = (A-1)T.
  • det(A-1) = 1/det(A).
  • La fórmula x = A-1b resuelve sistemas, aunque no siempre conviene formar la inversa.
  • Una matriz casi singular puede amplificar fuertemente los errores numéricos.

19.20 Conclusión

La matriz inversa permite deshacer una transformación y resolver ecuaciones matriciales. Su existencia depende de conservar todas las dimensiones, condición reflejada por un determinante distinto de cero.

En el próximo tema estudiaremos métodos para calcular la inversa: fórmula de orden 2, matriz adjunta y eliminación de Gauss-Jordan.

Volver al índice