13. Propiedades de las operaciones matriciales

Las propiedades matriciales permiten reorganizar y simplificar expresiones sin cambiar su resultado. Algunas coinciden con la aritmética de números, pero otras presentan diferencias fundamentales.

13.1 Introducción

En los temas anteriores aprendimos a sumar matrices, multiplicarlas por escalares y calcular productos matriciales. Ahora reuniremos las propiedades que permiten trabajar con expresiones más extensas.

Antes de aplicar una propiedad siempre debemos revisar las dimensiones. Una igualdad algebraica solo tiene sentido cuando todas las operaciones involucradas están definidas.

Las propiedades ayudan a cambiar agrupaciones y distribuir operaciones.
No autorizan a cambiar arbitrariamente el orden de los factores.

13.2 Dimensiones y cerradura

La cerradura significa que, al aplicar una operación a elementos de un conjunto, el resultado continúa perteneciendo al mismo conjunto.

Operación Condición Orden del resultado
A + B A y B son m × n m × n
A - B A y B son m × n m × n
kA A es m × n m × n
AB A es m × n y B es n × p m × p
AB con matrices cuadradas A y B son n × n n × n

Las matrices m × n son cerradas bajo suma y multiplicación por escalares. Las matrices cuadradas n × n también son cerradas bajo multiplicación matricial.

13.3 Conmutatividad de la suma

El orden de los sumandos no modifica el resultado.

A + B = B + A 
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("A + B:", sumar(A, B));
console.log("B + A:", sumar(B, A));

La propiedad se cumple porque cada par aij + bij es una suma de números.

13.4 Asociatividad de la suma

Podemos cambiar la agrupación de tres matrices del mismo orden.

(A + B) + C = A + (B + C) 
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]];
const C = [[2, 0], [1, 3]];

console.log(sumar(sumar(A, B), C));
console.log(sumar(A, sumar(B, C)));

13.5 Elemento neutro de la suma

Para cada orden m × n existe una matriz nula O del mismo orden que no modifica a A al sumarse.

A + O = O + A = A 
const A = [[3, -1, 5], [2, 4, 7]];
const O = A.map(fila => fila.map(() => 0));

const resultado = A.map((fila, i) =>
  fila.map((valor, j) => valor + O[i][j])
);

console.log(resultado);

13.6 Inverso aditivo

Cada matriz A posee una matriz opuesta -A. Al sumarlas obtenemos la matriz nula.

A + (-A) = O
A - B = A + (-B) 
const A = [[2, -5], [3, 7]];
const opuesta = A.map(fila => fila.map(valor => -valor));

const resultado = A.map((fila, i) =>
  fila.map((valor, j) => valor + opuesta[i][j])
);

console.log(opuesta);
console.log(resultado);

La resta no es conmutativa ni asociativa, pero puede analizarse como una suma de matrices opuestas.

13.7 Distributividad de un escalar respecto de matrices

Un escalar puede distribuirse sobre una suma o una resta de matrices.

k(A + B) = kA + kB
k(A - B) = kA - kB 
const A = [[1, 2], [3, 4]];
const B = [[5, 6], [7, 8]];
const k = 3;

const izquierda = A.map((fila, i) =>
  fila.map((valor, j) => k * (valor + B[i][j]))
);

const derecha = A.map((fila, i) =>
  fila.map((valor, j) => k * valor + k * B[i][j])
);

console.log(izquierda);
console.log(derecha);

13.8 Distributividad de la suma de escalares

Una suma de escalares que multiplica una matriz también puede distribuirse.

(k + h)A = kA + hA 
const A = [[2, 4], [6, 8]];
const k = 2;
const h = -0.5;

const izquierda = A.map(fila =>
  fila.map(valor => (k + h) * valor)
);

const derecha = A.map(fila =>
  fila.map(valor => k * valor + h * valor)
);

console.log(izquierda);
console.log(derecha);

13.9 Asociación e identidad de escalares

Los escalares pueden agruparse antes de actuar sobre la matriz. El número 1 no modifica la matriz.

k(hA) = (kh)A
1A = A
0A = O 
const A = [[1, -2], [3, 5]];
const k = 4;
const h = -2;

const agrupado = A.map(fila =>
  fila.map(valor => k * (h * valor))
);

const productoPrevio = A.map(fila =>
  fila.map(valor => (k * h) * valor)
);

console.log(agrupado);
console.log(productoPrevio);

13.10 Asociatividad de la multiplicación matricial

Si las dimensiones son compatibles, podemos cambiar la agrupación del producto sin cambiar el orden de los factores.

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

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

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

La propiedad permite elegir la agrupación con menor costo computacional en ciertos productos de dimensiones diferentes.

13.11 Distributividad de la multiplicación

El producto matricial se distribuye sobre la suma por la izquierda y por la derecha.

A(B + C) = AB + AC
(A + B)C = AC + BC 
const sumar = (A, B) => A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

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

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

console.log(multiplicar(A, sumar(B, C)));
console.log(sumar(multiplicar(A, B), multiplicar(A, C)));

13.12 La multiplicación no es conmutativa

En general, intercambiar los factores cambia el resultado. Además, puede existir AB sin que exista BA.

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

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

console.log("AB:", multiplicar(A, B));
console.log("BA:", multiplicar(B, A));

Algunas matrices particulares sí conmutan, pero eso debe demostrarse en cada caso.

13.13 Elemento neutro de la multiplicación

La matriz identidad conserva una matriz al multiplicarla con el orden adecuado. Para A de orden m × n:

ImA = A
AIn = A 
const multiplicar = (A, B) => 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));

13.14 Matriz nula y divisores de cero

Una matriz nula compatible produce un producto nulo. Sin embargo, el recíproco de esta afirmación no es válido para matrices.

AO = O y OA = O, con dimensiones compatibles.

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

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

console.log("A no es nula:", A);
console.log("B no es nula:", B);
console.log("AB:", multiplicar(A, B));

Las matrices A y B son divisores de cero: ninguna es nula, pero su producto sí lo es.

13.15 La cancelación no siempre es válida

De AB = AC no podemos concluir automáticamente B = C. La cancelación por la izquierda es válida si A posee inversa; sin esa condición puede fallar.

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

const A = [[1, 0], [0, 0]];
const B = [[0, 0], [0, 0]];
const C = [[0, 0], [0, 1]];

console.log("AB:", multiplicar(A, B));
console.log("AC:", multiplicar(A, C));
console.log("B y C son diferentes:", B, C);

A no es invertible. Por eso puede eliminar la diferencia existente entre B y C.

13.16 Potencias de una matriz

Para una matriz cuadrada A, las potencias son productos repetidos de la misma matriz. Como A conmuta consigo misma, se cumplen reglas semejantes a las potencias numéricas.

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

function potencia(A, exponente) {
  let resultado = A.map((fila, i) =>
    fila.map((_, j) => i === j ? 1 : 0)
  );

  for (let i = 0; i < exponente; i++) {
    resultado = multiplicar(resultado, A);
  }
  return resultado;
}

const A = [[1, 1], [0, 1]];

console.log(multiplicar(potencia(A, 2), potencia(A, 3)));
console.log(potencia(A, 5));

En general, (AB)n ≠ AnBn si A y B no conmutan.

13.17 Simplificación de expresiones

Las propiedades permiten agrupar términos semejantes y reducir la cantidad de operaciones.

2A + 3A = (2 + 3)A = 5A
A(B + C) - AB = AB + AC - AB = AC 
const A = [[1, 2], [3, 4]];

const expresionLarga = A.map(fila =>
  fila.map(valor => 2 * valor + 3 * valor)
);

const expresionSimplificada = A.map(fila =>
  fila.map(valor => 5 * valor)
);

console.log(expresionLarga);
console.log(expresionSimplificada);

Simplificar antes de programar puede reducir recorridos y mejorar la claridad del algoritmo.

13.18 Resumen y errores frecuentes

Propiedad Suma Producto matricial
Conmutativa Sí No, en general
Asociativa Sí Sí
Elemento neutro Matriz nula Matriz identidad
Inverso Toda matriz tiene opuesta Solo algunas matrices tienen inversa
Distributiva No corresponde sobre sí misma Sí, respecto de la suma

Los errores más frecuentes son intercambiar factores, cancelar matrices no invertibles, ignorar dimensiones, aplicar reglas de números que no valen para matrices y suponer que AB = O obliga a que un factor sea nulo.

13.19 Qué debes recordar de este tema

  • La suma matricial es conmutativa y asociativa.
  • La matriz nula es el neutro de la suma y -A es el inverso aditivo.
  • La multiplicación por escalares cumple propiedades distributivas y asociativas.
  • El producto matricial es asociativo y distributivo respecto de la suma.
  • El producto matricial no es conmutativo en general.
  • La matriz identidad es el neutro de la multiplicación.
  • Puede ocurrir AB = O con A y B no nulas.
  • La cancelación requiere condiciones adicionales, como la existencia de inversa.
  • Toda propiedad debe aplicarse respetando las dimensiones.

13.20 Conclusión

Las propiedades matriciales permiten transformar expresiones con seguridad, elegir agrupaciones convenientes y evitar cálculos repetidos. La clave es distinguir qué reglas se conservan desde la aritmética y cuáles fallan por la falta de conmutatividad y de inversas.

En el próximo tema estudiaremos la transpuesta de una matriz y las propiedades que relacionan la transposición con la suma, los escalares y el producto matricial.

Volver al índice