14. Transpuesta de una matriz

14.1 Introducción

Transponer una matriz significa convertir sus filas en columnas y sus columnas en filas. Los valores no se modifican: solamente cambian de posición.

La transpuesta aparece al trabajar con vectores fila y columna, matrices simétricas, productos matriciales, conjuntos de datos y sistemas de ecuaciones.

14.2 Definición y notación

La transpuesta de A se representa como A^T. Si A = [a_ij], entonces:

El primer índice se convierte en segundo y el segundo se convierte en primero. El elemento ubicado en la fila i y columna j de A aparece en la fila j y columna i de A^T.

14.3 Dimensiones de la transpuesta

Si A tiene orden m × n, su transpuesta tiene orden n × m.

La cantidad total de elementos permanece igual: m · n = n · m.

14.4 Ejemplo paso a paso

La primera fila [1, 2, 3] se convierte en la primera columna. La segunda fila [4, 5, 6] se convierte en la segunda columna.

const A = [[1, 2, 3], [4, 5, 6]];

const AT = A[0].map((_, columna) =>
  A.map(fila => fila[columna])
);

console.log(AT);
console.log(`Orden: ${AT.length} × ${AT[0].length}`);

14.5 Vector fila y vector columna

La transpuesta convierte un vector fila en un vector columna y viceversa.

const vectorFila = [[2, 5, 7]];
const vectorColumna = vectorFila[0].map(valor => [valor]);
const filaRecuperada = [vectorColumna.map(fila => fila[0])];

console.log(vectorColumna);
console.log(filaRecuperada);

14.6 Algoritmo general en JavaScript

Para formar cada fila del resultado, tomamos una columna completa de la matriz original.

function transponer(matriz) {
  const filas = matriz.length;
  const columnas = matriz[0].length;
  const resultado = Array.from({ length: columnas }, () =>
    Array(filas)
  );

  for (let i = 0; i < filas; i++) {
    for (let j = 0; j < columnas; j++) {
      resultado[j][i] = matriz[i][j];
    }
  }

  return resultado;
}

console.log(transponer([[1, 2, 3], [4, 5, 6]]));

La asignación resultado[j][i] = matriz[i][j] traduce directamente la definición matemática.

14.7 Correspondencia de índices

Podemos comprobar posiciones específicas para entender el intercambio de índices.

const A = [[10, 20, 30], [40, 50, 60]];
const AT = A[0].map((_, j) => A.map(fila => fila[j]));

console.log("a₁₂:", A[0][1]);
console.log("(Aᵀ)₂₁:", AT[1][0]);
console.log("a₂₃:", A[1][2]);
console.log("(Aᵀ)₃₂:", AT[2][1]);

14.8 Transponer dos veces

La transpuesta de la transpuesta recupera la matriz original. Por eso se dice que la transposición es una operación involutiva.

const transponer = matriz => matriz[0].map((_, j) =>
  matriz.map(fila => fila[j])
);

const A = [[1, 2, 3], [4, 5, 6]];
const dobleTranspuesta = transponer(transponer(A));

console.log(dobleTranspuesta);

14.9 Transpuesta de una suma

La transposición se distribuye respecto de la suma y de la resta.

const transponer = M => M[0].map((_, j) => M.map(fila => fila[j]));
const sumar = (A, B) => A.map((fila, i) =>
  fila.map((valor, j) => valor + B[i][j])
);

const A = [[1, 2, 3], [4, 5, 6]];
const B = [[6, 5, 4], [3, 2, 1]];

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

14.10 Transpuesta de un múltiplo escalar

El escalar puede aplicarse antes o después de transponer.

const transponer = M => M[0].map((_, j) => M.map(fila => fila[j]));
const escalar = (M, k) => M.map(fila => fila.map(valor => k * valor));

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

console.log(transponer(escalar(A, k)));
console.log(escalar(transponer(A), k));

14.11 Transpuesta de un producto

Al transponer un producto matricial debemos transponer cada factor e invertir su orden.

El orden se invierte porque las filas de AB deben convertirse en columnas compatibles en el producto transpuesto.

const transponer = M => M[0].map((_, j) => M.map(fila => fila[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, 5, 6]];
const B = [[1, 2], [3, 4], [5, 6]];

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

Escribir A^TB^T sin invertir los factores es un error frecuente.

14.12 Matrices simétricas

Una matriz cuadrada es simétrica si coincide con su transpuesta.

function esSimetrica(A) {
  const n = A.length;
  if (!n || !A.every(fila => fila.length === n)) return false;

  return A.every((fila, i) =>
    fila.every((valor, j) => valor === A[j][i])
  );
}

console.log(esSimetrica([[2, 5, 1], [5, 3, 7], [1, 7, 4]]));

14.13 Matrices antisimétricas

Una matriz antisimétrica cumple A^T = -A. Sus elementos reflejados tienen signos opuestos y su diagonal principal contiene ceros.

function esAntisimetrica(A) {
  const n = A.length;
  if (!n || !A.every(fila => fila.length === n)) return false;

  return A.every((fila, i) =>
    fila.every((valor, j) => valor === -A[j][i])
  );
}

const A = [[0, 2, -3], [-2, 0, 4], [3, -4, 0]];
console.log(esAntisimetrica(A));

14.14 Productos que generan matrices simétricas

Para cualquier matriz real A, los productos A^TA y AA^T son simétricos, aunque A sea rectangular.

const transponer = M => M[0].map((_, j) => M.map(fila => fila[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, 5, 6]];
const gram = multiplicar(transponer(A), A);

console.log(gram);
console.log(transponer(gram));

A^TA recibe el nombre de matriz de Gram de las columnas de A.

14.15 Transponer conjuntos de datos

Si las filas representan observaciones y las columnas características, transponer intercambia esos papeles.

const notas = [
  [8, 7, 9],
  [6, 8, 7],
  [9, 10, 8],
  [7, 6, 8]
];

const porEvaluacion = notas[0].map((_, j) =>
  notas.map(estudiante => estudiante[j])
);

console.log(porEvaluacion);

La operación no cambia los datos, pero modifica la forma en que se recorren y agrupan.

14.16 Aplicaciones en programación

• Convertir vectores fila en vectores columna.
• Reorganizar tablas y conjuntos de datos.
• Formar matrices de Gram y covarianza.
• Expresar productos escalares como u^Tv.
• Calcular gradientes en ciencia de datos e inteligencia artificial.
• Relacionar transformaciones y sistemas de coordenadas.
• Comprobar si una matriz es simétrica o antisimétrica.

14.17 Implementación con validación

Una función segura comprueba que la entrada sea una matriz rectangular no vacía.

function transponer(matriz) {
  if (!Array.isArray(matriz) || matriz.length === 0) {
    throw new Error("La matriz no puede estar vacía");
  }
  if (!matriz.every(fila => Array.isArray(fila))) {
    throw new Error("Cada fila debe ser un arreglo");
  }

  const columnas = matriz[0].length;
  if (!columnas || !matriz.every(fila => fila.length === columnas)) {
    throw new Error("La matriz debe ser rectangular");
  }

  return Array.from({ length: columnas }, (_, j) =>
    matriz.map(fila => fila[j])
  );
}

console.log(transponer([[1, 2, 3], [4, 5, 6]]));

14.18 Transposición en el lugar y errores frecuentes

Una matriz cuadrada puede transponerse en el lugar intercambiando los elementos a ambos lados de la diagonal.

const A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

for (let i = 0; i < A.length; i++) {
  for (let j = i + 1; j < A.length; j++) {
    [A[i][j], A[j][i]] = [A[j][i], A[i][j]];
  }
}

console.log(A);

Los errores frecuentes son cambiar los valores en lugar de las posiciones, no invertir las dimensiones, confundir transpuesta con inversa, olvidar invertir los factores de un producto y usar transposición en el lugar sobre una matriz rectangular.

14.19 Qué debes recordar de este tema

• La transpuesta intercambia filas y columnas.
• Si A es m × n, entonces A^T es n × m.
• Se cumple (A^T)^T = A.
• Se cumple (A + B)^T = A^T + B^T.
• Se cumple (kA)^T = kA^T.
• Se cumple (AB)^T = B^TA^T.
• Una matriz simétrica cumple A = A^T.
• Los productos A^TA y AA^T son simétricos.

14.20 Conclusión

La transpuesta reorganiza una matriz sin alterar sus valores. Su aparente sencillez permite relacionar filas con columnas, expresar simetrías y transformar correctamente sumas y productos.

En el próximo tema estudiaremos la traza de una matriz, una operación que suma los elementos de la diagonal principal.