Propiedades de las matrices: la multiplicación de matrices es asociativa y distributiva, no es conmutativa

Nota.
El producto interno de matrices es:

• Asociativa: Sí
• Distributiva: Sí
• Conmutativa: NO
  El producto interno de vectores es:
• Asociativa: Sí
• Distributiva: Sí
• Conmutativa: Sí

La ley conmutativa solo aplica en la multiplicación de matrices cuando éstas son matrices cuadradas y al mismo tiempo son matrices diagonales. Aquí puedes encontrar la definición de matriz cuadrada y diagonal.
Dejo el código para que lo comprueben.

A = np.array([[7, 0, 0, 0], [0, 5, 0, 0], [0, 0, 2, 0], [0, 0, 0, 20]])
B = np.array([[1, 0, 0, 0], [0, 8, 0, 0], [0, 0, 13, 0], [0, 0, 0, 4]])
print(A.dot(B) == B.dot(A))

Esto da como respuesta:

array([[ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True],
       [ True,  True,  True,  True]])

Dejo la matrices para que copien y peguen.

A = np.array([[2,3],[5,7],[11,13]])
B = np.array([[1,3],[2,1]])
C = np.array([[3,1],[4,2]])

Propiedades de multiplicación de matrices

• Asociativa: podemos asociar las multiplicaciones en el orden que queramos:
  AxBxC = (AxB)xC = Ax(BxC)
• Distributiva con respecto a la suma: si tenemos la multiplicación de una matriz multiplicada por la suma de otras dos, será equivalente a la suma de las multiplicaciones de la matriz por cada una de las otras dos (en el mismo orden): Ax(B+C) = AxB +AxC
• Conmutativa: La multiplicación de matrices no es conmutativa, es decir no se puede invertir el orden de multiplicacion: AxB != BxA

Nota:
El producto interno de dos vectores sí es conmutativo: AxB = BxA

para entender mejor los conceptos de algebra lineal recomiendo este video!
https://youtu.be/XkY2DOUCWMU

Acá el reto:

EJERCICIO

Para el ejercicio propuesto, Sean las matrices:

a de dimensión n x m (n filas y m columnas)
b de dimensión m x q (m filas y q columnas)

el producto interno [email protected] es válido ya que se cumple que el número de columnas de la primera sea igual al de las filas de la segunda. Sin embargo [email protected] no es valido ya que no cumple la condición dada para el caso [email protected] Esto es general para matrices a y b que cumplan las condiciones expuestas donde n y q diferente de m.

La multiplicación de matrices puede ser conmutativa en caso de que las matrices sean cuadradas, pequeña acotación

import numpy as np

A = np.array([[1,2,3],[4,5,6],[7,8,9]])
B = np.array([[2,3],[1,2],[4,5]])

AB =A.dot(B)
BA = B.dot(A)```

Según lo que el profesor nos ha explicado, en la línea 13 el v1 y v2 son matrices de 2filasx1columna.

dejo aquí mi reto

en el segundo caso hay que trasponerla porque de otra forma da un error por lo que no cumplen la misma función si las giramos.

# Mi solución al ejercicio

import numpy as np

matriz_1 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]])
matriz_2 = np.array([[16, 17], [18, 19], [20, 21], [22, 23], [24, 25]])

print(np.dot(matriz_1, matriz_2))
print(np.dot(matriz_2, matriz_1)) 

Dejo aquí la tarea solicitada:

Este es el código que realice para el ejercicio de esta clase:

A = np.random.randint(10, size=(7,3))
B = np.random.randint(10, size=(3,4))
C = A.dot(B)
print('Matriz A')
print(A)
print('Matriz B')
print(B)
print('Resultado')
print(C)

Y esto fue lo que me dio como resultado

Matriz A
[[7 0 4]
[4 8 7]
[6 4 7]
[7 8 2]
[7 2 1]
[5 3 9]
[4 0 5]]
Matriz B
[[7 3 6 8]
[9 2 9 6]
[2 9 2 7]]
Resultado
[[ 57 57 50 84]
[114 91 110 129]
[ 92 89 86 121]
[125 55 118 118]
[ 69 34 62 75]
[ 80 102 75 121]
[ 38 57 34 67]]

Aquí una función para comparar matrices de dimensiones iguales, sea cual sea el tamaño:

def comparaMatriz(X, Y):
    iguales = 0
    for i in range(X.shape[0]):
        for j in range(X.shape[1]):
            if X[i][j] == Y[i][j]:
                iguales += 1

    if iguales == X.size:
        print('Las matrices son iguales')
    else:
        print('Las matrces son diferentes')

Para la respuesta del reto:
La matriz a la iizq. de la multiplicacion (producto interno) debe tener la misma dimension en su columna que filas en la matriz de la derecha

Nota.- Las matrices casi nunca son conmutativas, pero sí existen casos.

X = np.array([[5,5],[5,5]])
Y = np.array([[5,5],[5,5]])

M = X.dot(Y)
N = Y.dot(X)

print(M==N)
print('\n')
print(M)
print('\n')
print(N)


[[ True  True]
 [ True  True]]


[[50 50]
 [50 50]]


[[50 50]
 [50 50]]

Puedes usar el operador @ en vez de la funcion .dot():

 A.dot(B)  es igual  A @ B

Tres maneras de escribir una multiplicacion

C = np.dot(A,B)
C = A.dot(B)
C = A @ B

Es importante mencionar que si A es una matriz cuadrada de nxn y A tiene inversa, (Denotamos a la inversa de A como A’) entonces tenemos que A*A’ = I y A’A = I, por lo tanto AA’ conmutan.

P. INTERNO MATRICES
Asociativa: Ax(BxC) = (AxB)xC Verdadero
Distributiva: Ax(B+C) = (AxB) + (AxC) Verdadero
Conmutativa: BxC = CxB Falso

Aquí está el ejercicio resuelto del final:

M1 = np.array([ [1,2], [3,4], [5,6] ])
M2 = np.array([ [1,2,3,4], [5,6,7,8] ])
M3 = M1 @ M2
print(M1, '\n', '-'*30)
print(M2,  '\n', '-'*30)
print(M3)

[[1 2]
 [3 4]
 [5 6]] 
 ------------------------------
[[1 2 3 4]
 [5 6 7 8]] 
 ------------------------------
[[11 14 17 20]
 [23 30 37 44]
 [35 46 57 68]]

Cuando se invierten los lugares de las matrices marca un error.

M4 = M2 @ M1
print(M4)

ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 4)

Se hace las operaciones con los mismos datos de la clase anterior:

A = np.array([[1,2,3], [4, 5, 6], [7, 8, 9],[10,11,12]])
B = np.array([[2,3], [5, 7], [11,13]])
C = A.dot(B)
D = B.dot(A)
print(C)
print(D)

Al imprimir D, da el siguiente erro: “ValueError: shapes (3,2) and (4,3) not aligned: 2 (dim 1) != 4 (dim 0)”

Les comparto mi par de matrices. El producto interno de A.dot(B) es posible, mientras que en el caso B.dot(A) no lo es.

import numpy as np

A = np.array([[1, 2, 3],[7, 8, 9], [4, 5, 6]])
B = np.array([[10, 11],[12, 13], [14, 15]])

print(A.shape)
print(B.shape)
# Resultado: (3, 3)  (3, 2)

AB = A.dot(B)
print(AB)
# Resultado: [[ 76  82] [292 316] [184 199]]

# BA = B.dot(A)
# print(BA)
# Resultado: ValueError: shapes (3,2) and (3,3) not aligned: 2 (dim 1) != 3 (dim 0)```

matrizA = np.array([[1,2,3],[8,5,5],[8,5,6],[4,8,9]])
matrizB = np.array([[2,7],[8,9],[7,4]])
pA = matrizA.dot(matrizB) It´s right
but: pB = matrizB.dot(matrizA)
ValueError Traceback (most recent call last)
<ipython-input-76-fdcfebccb210> in <module>
----> 1 pB = matrizB.dot(matrizA)

ValueError: shapes (3,2) and (4,3) not aligned: 2 (dim 1) != 4 (dim 0)

• Propiedad asociativa: Ax(BxC) = (AxB)xC - Se cumple la igualdad
• Propiedad Distributiva: Ax(B+C) = (AxB) + (AxC) Se cumple la igualdad
• Propiedad Conmutativa: BxC = CxB - No se cumple la igualdad

matriz_1 = np.array([[1,2,3],[5,6,11],[7,8,9],[10,11,12]])
matriz_2 = np.array([[1,2,3,9,8],[4,5,6,0,5],[8,5,2,4,10]])
dimensionM1 = matriz_1.shape
dimensionM2 = matriz_2.shape
producto_interno_1 = matriz_1.dot(matriz_2)
print("\nmatriz 1")
print(matriz_1)
print("\nmatriz 2")
print(matriz_2)
print("\nDimensión matriz 1")
print(dimensionM1)
print("\nDimensión matriz 2")
print(dimensionM2)
print("\nproducto interno matriz_1.dot(matriz_2)")
print(producto_interno_1)


matriz 1
[[ 1  2  3]
 [ 5  6 11]
 [ 7  8  9]
 [10 11 12]]

matriz 2
[[ 1  2  3  9  8]
 [ 4  5  6  0  5]
 [ 8  5  2  4 10]]

Dimensión matriz 1
(4, 3)

Dimensión matriz 2
(3, 5)

producto interno matriz_1.dot(matriz_2)
[[ 33  27  21  21  48]
 [117  95  73  89 180]
 [111  99  87  99 186]
 [150 135 120 138 255]]```

Serán dos matrices en cuyo caso el numero de columnas de la primera no tenga el mismo valor que el numero de filas de la segunda.

Una forma más general para resolver esto es la siguiente:
Tienen que darse dos matrices con dimensiones de la siguiente forma: 𝐴𝑛,𝑚×𝐵𝑚,𝑜 para que no pueda invertise el rol en el producto interno, ya que si se dan de la forma 𝐴𝑛,𝑚×𝐵𝑚,𝑛 si pueden invertirse sus roles o dicho de otra forma realizar el producto interno de 𝐴×𝐵 o de 𝐵×𝐴

MA1 = np.array([[1,2,3],
               [2,3,6],
               [4,5,6],
               [6,7,8],
               [8,9,5]])
MA2 = np.array([[3,1],
               [2,1],
               [1,1]])

MA1_MA2 = MA1.dot(MA2)
print(MA1_MA2)
MA2_MA1 = MA2.dot(MA1)
print(MA2_MA1)```


[[10  6]
 [18 11]
 [28 15]
 [40 21]
 [47 22]]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-7-035238f160d1> in <module>
     10 MA1_MA2 = MA1.dot(MA2)
     11 print(MA1_MA2)
---> 12 MA2_MA1 = MA2.dot(MA1)
     13 print(MA2_MA1)

ValueError: shapes (3,2) and (5,3) not aligned: 2 (dim 1) != 5 (dim 0)

A = np.array([[7,8,9,10,11],[5,7,6,5,4]])
B = np.array([[1],[3],[2],[1],[8]])
print(A.shape)
print(B.shape)
(2, 5)
(5, 1)
A.dot(B)
array([[147],
       [ 75]])
B.dot(A)
ValueError: shapes (5,1) and (2,5) not aligned: 1 (dim 1) != 2 (dim 0)

matriz=np.array([[1,3,5],
                [5,6,7],
                [10,11,13]])
vector=np.array([[1,2,4],[3,6,5]])

vector.dot(matriz)
array([[ 51,  59,  71],
       [ 83, 100, 122]])
ValueError                                Traceback (most recent call last)
c:\Users\jvent\Documents\Python Scripts\Miner_Stat\Python\notebook_pruebas.py in 
----> 98 matriz.dot(vector)

ValueError: shapes (3,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)

Podemos usar las matrices usadas para la clase como ejemplo de matrices no cuadradas en las cuales no se cumple la propidad conmutativa ya que no tienen la misma cantidad de columnas y de filas al hacer la operación en diferente orden.

Ejercicio:

A = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
B = np.array([[2,3],[5,7],[11,13]])
A_tB = A.dot(B)
tB_tA = B.T.dot(A.T)
print(A_tB)
print(tB_tA)
------------------------------------
# Output:
[[ 45  56]
 [ 99 125]
 [153 194]
 [207 263]]
[[ 45  99 153 207]
 [ 56 125 194 263]]