$ \renewcommand{\R}[1][{}]{{\mathbb{R}}^{#1}} \renewcommand{\Z}[1][{}]{{\mathbb{Z}}^{#1}} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \renewcommand{\getitemR}[1]{\getItem{#1}} \renewcommand{\getItem}{\pmb{\mid}} \renewcommand{\elemR}[2]{{#1}^{\phantom{\T}}_{\getitemR{#2}}} \renewcommand{\elemRP}[2]{{\big(#1\big)}^{\phantom{\T}}_{\getitemR{#2}}} \renewcommand{\elemRPE}[2]{\big({#1}^{\phantom{\T}}_{\getitemR{#2}}\big)} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \renewcommand{\Vect}[2][{}]{{\boldsymbol{#2}}_{#1}} \renewcommand{\eleVR}[2] {\elemR {\Vect{#1}}{#2}} % con subindices \renewcommand{\eleVRP}[2] {\elemRP {\Vect{#1}}{#2}} % con subindices y paréntesis interior \renewcommand{\eleVRPE}[2]{\elemRPE{\Vect{#1}}{#2}} % con subindices y paréntesis exterior %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \renewcommand{\VectC}[2][{}] {\elemR {\Mat{#2}}{#1}} % con subindices \renewcommand{\VectCP}[2][{}] {\elemRP {\Mat{#2}}{#1}} % con subindices y paréntesis \renewcommand{\VectCPE}[2][{}]{\elemRPE{\Mat{#2}}{#1}} % con subindices y paréntesis exterior %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \renewcommand{\mat}[1]{\mathbf{#1}} \renewcommand{\Mat} [2][{}]{{\mat{#2}}_{#1}} \renewcommand{\T}{\intercal} \renewcommand{\MatT}[2][{}]{{\mat{#2}}^{\T}_{#1}} \renewcommand{\VectC}[2][{}] {\elemR {\Mat{#2}}{#1}} % con subindices \renewcommand{\VectCP}[2][{}] {\elemRP {\Mat{#2}}{#1}} % con subindices y paréntesis \renewcommand{\VectCPE}[2][{}] {\elemRPE {\Mat{#2}}{#1}} % con subindices y paréntesis exterior \renewcommand{\VectCC}[2][{}] {\elemRR {\Mat{#2}}{#1}} % con () \renewcommand{\VectCCC}[2][{}] {\elemRRR{\Mat{#2}}{#1}} % con texto "col" %SELECCIÓNA de FILAS y COlUMNAS DE UNA MATRIZ TRANSPUESTA PARA GENERAR UN VECTOR DE Rn \renewcommand{\VectTC}[2][{}] {\elemR{\MatT{#2}\!}{#1}} % con subindices \renewcommand{\VectTCC}[2][{}] {\elemRR{ \MatT{#2}}{#1}} % con () \renewcommand{\VectTCCC}[2][{}] {\elemRRR{\MatT{#2}}{#1}} % con texto "col" $
${\huge\text{Jupyter notebook de la Lección 4}}$
Índice de contenidos de este notebook (Requiere ejecutar todo el Notebook para que aparezca el índice)
pip install nacal
Requirement already satisfied: nacal in /home/marcos/.local/lib/python3.9/site-packages (0.1.13) Requirement already satisfied: sympy>=1.1.0 in /usr/lib/python3/dist-packages (from nacal) (1.7.1) Note: you may need to restart the kernel to use updated packages.
from nacal import *
Consideraremos dos tipos de transformaciones elementales que
denotaremos con tuplas. Para indicar que una tupla en particular es
una abreviatura de una transformación elemental, la escribiremos como
argumento de la clase T
.
Tipo I: Las transformaciones elementales del primer tipo suman $a$ veces el vector $i$-ésimo al vector $j$-ésimo:
$$ \underset{\left[\left(a\right)\mathbf{i}+\mathbf{j} \right]}{\mathbf{\tau}} $$denotaremos estas transformaciones con una tupla de tres componentes:
T( (a, i, j) )
.
Por ejemplo, la abreviatura de la transformación elemental que suma 3 veces el vector segundo al vector primero se escribe
T( (3, 2, 1) )
$\underset{\left[\left(3\right)\mathbf{2}+\mathbf{1} \right]}{\pmb{\tau}}$
Fíjese que el índice del vector modificado aparece en último lugar; que a dicho vector se le suma un múltiplo de otro vector, cuyo índice apare en segundo lugar; y que el coeficiente por el que se multiplica aparece en primer lugar.
Tipo II: Las Transformaciones Elementales de segundo tipo multiplican el vector $j$-ésimo por un número $a$.
$$ \underset{\left[\left(a\right)\mathbf{j}\right]}{\mathbf{\tau}} $$denotaremos estas transformaciones con una tupla de dos componentes:
T( (a, j) )
.
Por ejemplo, la transformación elemental que multiplica por 5 al segundo vector se escribe
T( (5, 2) )
$\underset{\left[\left(5\right)\mathbf{2}\right]}{\pmb{\tau}}$
Nuevamente, el índice del vector modificado aparece en último lugar, y el coeficiente por el que se multiplica aparece en primer lugar.
Es posible combinar una sucesión de transformaciones elementales; por
ejemplo una combinación de las dos transformaciones anteriores
$$
\underset{\begin{subarray}{c} \left[\left(a\right)\mathbf
{j}\right]\\\left[\left(b\right)\mathbf{p}+\mathbf{q} \right]\end
{subarray}}{\mathbf{\tau}}
$$
en este caso, el argumento de la clase T
debe ser ___una lista de
abreviaturas___.
Por ejemplo, podemos combinar las dos transformaciones de más arriba
T( [(3, 2, 1), (5, 2)] )
$\underset{\begin{subarray}{c} \left[\left(3\right)\mathbf{2}+\mathbf{1} \right]\\\left[\left(5\right)\mathbf{2}\right]\end{subarray}}{\pmb{\tau}}$
Cuando aplicamos una transformación elemental por la derecha de una
matriz, modificamos sus columnas. La actuación de una transformación
elemental se indica con el símbolo &
Por ejemplo, considere la matriz $\Mat{A}$
A=Matrix([Vector((1,2)), Vector((0,3)), Vector((-2,2))])
A
$\left[ \begin{array}{ccc}1&0&-2\\2&3&2\\ \end{array} \right]$
vamos a sumar el doble (2) de la primera columna (1) de $\Mat{A}$ a su tercera columna (3).
A & T( (2,1,3) )
$\left[ \begin{array}{ccc}1&0&0\\2&3&6\\ \end{array} \right]$
Cuando aplicamos una transformación elemental sobre una matriz, modificamos la matriz. Así que ahora la matriz $\Mat{A}$ ha cambiado:
A
$\left[ \begin{array}{ccc}1&0&0\\2&3&6\\ \end{array} \right]$
Si queremos aplicar transformaciones sobre una matriz y no perder la matriz original, necesitamos hacer una copia. Por ejemplo, definamos la siguiente matriz $\Mat{A}$
x = Vector((1, 1, -2)); y = Vector((1, -2, 1)); z = Vector((-2, 1, 1))
A = Matrix([x,y,z])
A
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\-2&1&1\\ \end{array} \right]$
y hagamos una copia (con Matrix(A)
) a la que aplicaremos un par de
transformaciones
B = Matrix(A)
B & T( (2,1,3) ) & T( (5, 2) )
$\left[ \begin{array}{ccc}1&5&0\\1&-10&3\\-2&5&-3\\ \end{array} \right]$
Ahora $\,\Mat{B}\,$ ha cambiado, pero $\,\Mat{A}\,$ se mantiene.
A
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\-2&1&1\\ \end{array} \right]$
Si aplicamos una transformación elemental a otra transformación elemental, logramos una transformación que es la composición de ambas. Por ejemplo
z = T( (2,1,3) ) & T( (5, 2) )
z
$\underset{\begin{subarray}{c} \left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(5\right)\mathbf{2}\right]\end{subarray}}{\pmb{\tau}}$
si aplicamos z
a una copia de A
, obtendremos el mismo resultado
que obtuvimos más arriba
C = Matrix(A)
C & z
$\left[ \begin{array}{ccc}1&5&0\\1&-10&3\\-2&5&-3\\ \end{array} \right]$
Los objetos de la clase T
poseen un atributo t
, donde se almacena
el listado de abreviaturas. Por ejemplo, en el atributo t
de de z
aparece el listado con las abreviaturas de las transformaciones
aplicadas más arriba:
z.t
[(2, 1, 3), (5, 2)]
Hay múltiples combinaciones de transformaciones elementales que logran intercambiar de posición dos vectores. La siguiente es un ejemplo de secuencia que intercambia los vectores primero y tercero:
intercambio = T( [ (-1,3), (-1,3,1), (1,1,3), (-1,3,1) ] )
Matrix(A) & intercambio
$\left[ \begin{array}{ccc}-2&1&1\\1&-2&1\\1&1&-2\\ \end{array} \right]$
Afortunadamente hay una forma más sencilla de realizar un intercambio.
El conjunto compuesto por los dos índices de los vectores que queremos
intercambiar es una abreviatura del intercambio. Por ejemplo T( {s, t} )
intercambia los vectores $s$-ésimo y $t$-ésimo:
Así, para intercambiar las columnas primera y tercera de una copia de $\Mat{A}$ basta con escribir
Matrix(A) & T( {1,3} )
$\left[ \begin{array}{ccc}-2&1&1\\1&-2&1\\1&1&-2\\ \end{array} \right]$
Si el conjunto solo contiene un índice, el intercambio no hace nada
Matrix(A) & T( {1,1} )
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\-2&1&1\\ \end{array} \right]$
Cuando las transformaciones elementales actuan por la izquierda de la matriz realizan operaciones con las filas.
Por ejemplo, podemos intercabiar las dos primeras filas C
del
siguiente modo
T( {1,2} ) & C
$\left[ \begin{array}{ccc}1&-10&3\\1&5&0\\-2&5&-3\\ \end{array} \right]$
Tenga en cuenta que cuando actuan varias transformaciones por la izquierda, las primeras en actuar son las más próximas a la matriz; así, tanto
T({1,2}) & T((2,2)) & Matrix(A)
$\left[ \begin{array}{ccc}2&-4&2\\1&1&-2\\-2&1&1\\ \end{array} \right]$
como
T([ {1,2}, (2,2) ]) & Matrix(A)
$\left[ \begin{array}{ccc}2&-4&2\\1&1&-2\\-2&1&1\\ \end{array} \right]$
es equivalente a (y fíjese en los paréntesis)
T({1,2}) & ( T((2,2)) & Matrix(A) )
$\left[ \begin{array}{ccc}2&-4&2\\1&1&-2\\-2&1&1\\ \end{array} \right]$
es decir, primero se multipica por 2 la segunda fila (operación dentro del paréntesis) y luego se intercambian las dos primeras filas.
Si tenemos transformaciones actuando a izquierda y derecha, operamos tanto con las filas como con las columnas.
T( {1,2} ) & T( (2,2) ) & Matrix(A) & T( [(-3,2,3), (10,1), {2,3}] )
$\left[ \begin{array}{ccc}20&14&-4\\10&-5&1\\-20&-2&1\\ \end{array} \right]$
Diremos que transponemos una secuencia de transformaciones al invertir el orden de las transformaciones en la secuencia. Al igual que con las matrices, transponemos con el operador ~
actuando por la izquierda de T
.
h=T([ (-2, 1, 2), (-3, 1, 3), (-4, 1, 4), (-5, 1, 5), (-2, 2, 3), (4, 2, 4), (5, 2, 5) ])
h
$\underset{\begin{subarray}{c} \left[\left(-2\right)\mathbf{1}+\mathbf{2} \right]\\\left[\left(-3\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(-4\right)\mathbf{1}+\mathbf{4} \right]\\\left[\left(-5\right)\mathbf{1}+\mathbf{5} \right]\\\left[\left(-2\right)\mathbf{2}+\mathbf{3} \right]\\\left[\left(4\right)\mathbf{2}+\mathbf{4} \right]\\\left[\left(5\right)\mathbf{2}+\mathbf{5} \right]\end{subarray}}{\pmb{\tau}}$
~h
$\underset{\begin{subarray}{c} \left[\left(5\right)\mathbf{2}+\mathbf{5} \right]\\\left[\left(4\right)\mathbf{2}+\mathbf{4} \right]\\\left[\left(-2\right)\mathbf{2}+\mathbf{3} \right]\\\left[\left(-5\right)\mathbf{1}+\mathbf{5} \right]\\\left[\left(-4\right)\mathbf{1}+\mathbf{4} \right]\\\left[\left(-3\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(-2\right)\mathbf{1}+\mathbf{2} \right]\end{subarray}}{\pmb{\tau}}$
Considere la matriz obtenida tras aplicar una suceción de transformaciones sobre las columnas de la matriz identidad de orden $n$ obtenemos una matriz. Pues bien, la transpuesta de dicha sucesión aplicada sobre las filas de la matriz identidad de orden $n$ será la transpuesta de la anterior matriz.
I(5) & h
$\left[ \begin{array}{ccccc}1&-2&1&-12&-15\\0&1&-2&4&5\\0&0&1&0&0\\0&0&0&1&0\\0&0&0&0&1\\ \end{array} \right]$
(~h) & I(5)
$\left[ \begin{array}{ccccc}1&0&0&0&0\\-2&1&0&0&0\\1&-2&1&0&0\\-12&4&0&1&0\\-15&5&0&0&1\\ \end{array} \right]$
Fíjese que aplicar una suceción de transformaciones es como multiplicar por una matriz, de manera que si aplicamos sobre las columnas de
B
$\left[ \begin{array}{ccc}1&5&0\\1&-10&3\\-2&5&-3\\ \end{array} \right]$
usa sucesión de transformaciones
Matrix(B) & h
$\left[ \begin{array}{ccc}1&3&-9\\1&-12&24\\-2&9&-15\\ \end{array} \right]$
la transpuesta de dicha matriz resultante
~(Matrix(B)&h)
$\left[ \begin{array}{ccc}1&1&-2\\3&-12&9\\-9&24&-15\\ \end{array} \right]$
se puede calcular con una operación que recuerda a la transpuesta del producto... pues es la transpuesta de la transformación actuando sobre la transpuesta de B
~h & ~Matrix(B)
$\left[ \begin{array}{ccc}1&1&-2\\3&-12&9\\-9&24&-15\\ \end{array} \right]$
La aplicación de una única transformación elemental sobre la matriz identidad da como resultado una matriz elemental.
Matrices elementales Tipo I: Veamos como la aplicación de la
transformación T(-5,1,3)
sobre las columnas de la matriz identidad
de orden 4 nos da una matriz parecida a la identidad, salvo porque
aparece un -5 en la posición (1,3)
I(4) & T( (-5,1,3) )
$\left[ \begin{array}{cccc}1&0&-5&0\\0&1&0&0\\0&0&1&0\\0&0&0&1\\ \end{array} \right]$
Pero la misma transformación elemental aplicada sobre las filas de la matriz identidad nos da otra matriz elemental distinta: la versión transpuesta de la matriz elemental de más arriba:
T( (-5,1,3) ) & I(4)
$\left[ \begin{array}{cccc}1&0&0&0\\0&1&0&0\\-5&0&1&0\\0&0&0&1\\ \end{array} \right]$
Por tanto, las transformaciones elementales de Tipo I están asociadas a matrices elementales distintas en función de si actuan sobre las columnas (por la derecha) o sobre las filas (por la izquierda). Fíjese que una matriz elemental es la transpuesta de la otra.
Matrices elementales Tipo II: Y ahora veamos como la aplicación de
la transformación T(100,2)
sobre las columnas de la matriz
identidad de orden 3 nos da una matriz parecida a la identidad, salvo
porque aparece un 100 en la segunda posición de la diagonal, i.e.,
posición (2,2)
I(3) & T( (100,2) )
$\left[ \begin{array}{ccc}1&0&0\\0&100&0\\0&0&1\\ \end{array} \right]$
Las matrices elementales Tipo II son simétricas; así que obtenemos identica matriz elemental cuando actuamos por la izquierda de la matriz identidad.
T( (100,2) ) & I(3)
$\left[ \begin{array}{ccc}1&0&0\\0&100&0\\0&0&1\\ \end{array} \right]$
Tenga en cuenta que la aplicación de una sucesión de transformaciones elementales NO suele ser una matriz elemental
I(3) & T( (2,1,3) ) & T( (5, 2) ) & T( (-5,3,1) ) & T ( (2,1,2) )
$\left[ \begin{array}{ccc}-9&-18&2\\0&5&0\\-5&-10&1\\ \end{array} \right]$
Matrices intercambio: La aplicación de ___un único intercambio___ entre las columnas (o entre las filas) de la matriz identidad da como resultado una matriz intercambio.
I(4) & T( {2,4} )
$\left[ \begin{array}{cccc}1&0&0&0\\0&0&0&1\\0&0&1&0\\0&1&0&0\\ \end{array} \right]$
T( {2,4} ) & I(4)
$\left[ \begin{array}{cccc}1&0&0&0\\0&0&0&1\\0&0&1&0\\0&1&0&0\\ \end{array} \right]$
Matrices permutación: La aplicación de una ___sucesión de intercambios___ entre las columnas (y/o entre las filas) de la matriz identidad da como resultado una reordenación de las columnas de la matriz identidad que denominamos matriz permutación.
T( [ {1,2}, {3,4} ] ) & I(4) & T({3,1}) & T({2,3})
$\left[ \begin{array}{cccc}0&0&1&0\\0&1&0&0\\0&0&0&1\\1&0&0&0\\ \end{array} \right]$
Compruebe con ejemplos que aplicar una transformación elemental sobre las columnas de una matriz es equivalente a multiplicar dicha matriz por la correspondiente matriz elemental; es decir, que $$ {\Mat{A}}_{\mathbf{\tau}}=\Mat{A}\big({\Mat{I}}_{\mathbf{\tau}}\big) $$
# Primero aplicamos la transformación sobre las columnas
Matrix(A) & T( (2,1,3) )
$\left[ \begin{array}{ccc}1&1&0\\1&-2&3\\-2&1&-3\\ \end{array} \right]$
# y ahora multiplicamos por la derecha por la correspondiente matriz elemental
A * ( I(A.n) & T((2,1,3)) )
$\left[ \begin{array}{ccc}1&1&0\\1&-2&3\\-2&1&-3\\ \end{array} \right]$
Compruebe que también ocurre actuado por la izquierda para transformar las filas. Primero aplicamos la trasformación sobre las filas
# Primero aplicamos la transformación sobre las filas
T( (2,1,3) ) & Matrix(A)
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\0&3&-3\\ \end{array} \right]$
# y ahora multiplicamos por la izquierda por la correspondiente matriz elemental
( I(A.m) & T((2,1,3)) ) * A
$\left[ \begin{array}{ccc}-3&3&0\\1&-2&1\\-2&1&1\\ \end{array} \right]$
Compruebe con ejemplos que en general $$ {\big(\Mat{A}\Mat{B}\big)}_{\mathbf{\tau}}=\Mat{A}\big({\Mat{B}}_{\mathbf{\tau}}\big) $$
Recuerde emplear una copia de las matrices originales si no quiere que éstas cambien
# primero el lado izquierdo de la igualdad
( A * Matrix(B) ) & T((-5,2,1))
# recuerde que si no queremos modificar las matrices originales, debemos actuar sobre copias de las mismas
$\left[ \begin{array}{ccc}81&-15&9\\-153&30&-9\\72&-15&0\\ \end{array} \right]$
# ahora el lado derecho de la igualdad
A * ( Matrix(B) & T((-5,2,1)) )
# recuerde que si no queremos modificar las matrices originales, debemos actuar sobre copias de las mismas
$\left[ \begin{array}{ccc}81&-15&9\\-153&30&-9\\72&-15&0\\ \end{array} \right]$
Esto es cierto incluso cuando se aplica una sucesión de transformaciones elementales (tanto por la derecha como por la izquierda).
Veamos un ejemplo de trasformación de las columnas:
# definimos una sucesión de transformaciones elmentales
st = T([(2, 1, 3), (5, 2), (-5, 3, 1), (2, 1, 2), {2,3}])
st
$\underset{\begin{subarray}{c} \left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(5\right)\mathbf{2}\right]\\\left[\left(-5\right)\mathbf{3}+\mathbf{1} \right]\\\left[\left(2\right)\mathbf{1}+\mathbf{2} \right]\\\left[\mathbf{2}\rightleftharpoons\mathbf{3}\right]\end{subarray}}{\pmb{\tau}}$
( A * Matrix(B) ) & st
$\left[ \begin{array}{ccc}-99&21&-273\\72&-15&294\\27&-6&-21\\ \end{array} \right]$
A * ( Matrix(B) & st )
$\left[ \begin{array}{ccc}-99&21&-273\\72&-15&294\\27&-6&-21\\ \end{array} \right]$
y ahora un ejemplo de transformación de las filas...
st & ( Matrix(A) *B )
$\left[ \begin{array}{ccc}21&-165&54\\45&-225&90\\39&-300&99\\ \end{array} \right]$
( st & Matrix(A) ) * B
$\left[ \begin{array}{ccc}21&-165&54\\45&-225&90\\39&-300&99\\ \end{array} \right]$
# primero el lado izquierdo de la igualdad
( 5 * Matrix(A) ) & st
$\left[ \begin{array}{ccc}5&0&35\\-70&15&-190\\65&-15&155\\ \end{array} \right]$
# y luego el lado derecho
5 * ( Matrix(A) & st )
$\left[ \begin{array}{ccc}5&0&35\\-70&15&-190\\65&-15&155\\ \end{array} \right]$
Compruebe, usando los dos recuadros de más abajo, la propiedad asociativa cuando se transforman las filas
Compruebe con ejemplos que en general $$ {\big(\Mat{A}+\Mat{B}\big)}_{\mathbf{\tau}}={\Mat{A}}_{\mathbf{\tau}} + {\Mat{B}}_{\mathbf{\tau}} $$
# primero el lado izquierdo de la igualdad
( Matrix(A) + Matrix(B) ) & st
$\left[ \begin{array}{ccc}-8&2&14\\-38&8&-136\\46&-10&122\\ \end{array} \right]$
# y luego el lado derecho de la igualdad
( Matrix(A) & st ) + ( Matrix(B) & st )
$\left[ \begin{array}{ccc}-8&2&14\\-38&8&-136\\46&-10&122\\ \end{array} \right]$
Esto también es cierto con las transformaciones de las filas
st & ( Matrix(A) + Matrix(B) )
$\left[ \begin{array}{ccc}-8&66&-22\\0&90&-30\\-14&120&-40\\ \end{array} \right]$
( st & Matrix(A) ) + ( st & Matrix(B) )
$\left[ \begin{array}{ccc}-8&66&-22\\0&90&-30\\-14&120&-40\\ \end{array} \right]$
La siguiente función ppivote
de nuestra librería devuelve la posición del
primer componente no negativo de un vector (cuando el vector es el
único argumento).
ppivote = lambda v, k=0: ( [i for i,c in enumerate(v.lista, 1) if (c!=0 and i>k)] + [0] )[0]
ppivote(Vector([0,4,0,0,3,0]))
2
Si a la función se le da como segundo argumento una posición desde la que empezar a buscar, entonces devuelve la posición del primer componente no negativo a partir de la posición siguiente a la indicada.
ppivote(Vector([0,4,0,0,3,0]), 2)
5
Cuando la función ppivote
no encuentra un componente no nulo devuelve el valor cero
ppivote(Vector([0,4,0,0,0,0]), 2)
0
x = Vector((1, 1, -2)); y = Vector((1, -2, 1)); z = Vector((-2, 1, 1))
A = Matrix([x,y,z])
A
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\-2&1&1\\ \end{array} \right]$
Usando la función ppivote
y las transformaciones elementales vamos a escalonar la matriz A
.
M = Matrix(A) # Hacemos una copia de A para no perder la matriz original
r = 0 # Contador de pivotes
for i in range(1,M.m+1): # En cada una de las filas:
p = ppivote((i|M),r) # buscamos la posición del primer componente no nulo a la derecha de la columna r
if p > 0: # si hemos econtrado alguno (si la fila no está llena de ceros por la derecha)
r += 1 # el contador añade un nuevo pivote a la cuenta
M & T( {r, p} ) # intercambiamos la columna $r$-ésima con la columna donde encontramos el pivote
M & T( [(fracc(-(i|M|j),(i|M|r)), r, j) for j in range(1,M.n+1) if j > r] ) # con el pivote anulamos todos
# los componentes a su derecha
M # por último mostramos el resultado (fíjese que M ya no es una copia de A)
$\left[ \begin{array}{ccc}1&0&0\\1&-3&0\\-2&3&0\\ \end{array} \right]$
Para la matriz
$$
\qquad\begin{bmatrix}1&1&-2\\1&-2&1\\-2&1&1\end{bmatrix}\qquad
$$
los pasos dados por el algoritmo han sido:
$$
\quad
\underset{\begin{subarray}{c} \left[\left(-1\right)\mathbf{1}+\mathbf{2} \right]\\\left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(1\right)\mathbf{2}+\mathbf{3} \right]\end{subarray}}{\mathbf{\tau}}\quad
$$
es decir,
$$
\begin{bmatrix}1&1&-2\\1&-2&1\\-2&1&1\end{bmatrix}\xrightarrow{\underset{\begin{subarray}{c} \left[\left(-1\right)\mathbf{1}+\mathbf{2} \right]\\\left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\end{subarray}}{\mathbf{\tau}}}\begin{bmatrix}1&0&0\\1&-3&3\\-2&3&-3\end{bmatrix}\xrightarrow{\underset{\begin{subarray}{c} \left[\left(1\right)\mathbf{2}+\mathbf{3} \right]\end{subarray}}{\mathbf{\tau}}}\begin{bmatrix}1&0&0\\1&-3&0\\-2&3&0\end{bmatrix}
$$
(donde hemos excluido del esquema los intercambios T({r,p})
cuando p==r
, pues no modifican la matriz).
(Pruebe a realizar modificaciones del anterior código para lograr nuevas variantes del mismo)
El código de más arriba está implementado en nuestra librería en la
clase ElimG
(__Elim__inación __G__aussiana)
ElimG(A)
$\left[ \begin{array}{ccc}1&0&0\\1&-3&0\\-2&3&0\\ \end{array} \right]$
... y posee algunos añadidos interesantes. Veámoslo con la siguiente matriz B
B = Matrix([[1,2,3,4,5],[0,0,-3,-5,7],[1,3,5,0,0],[0,1,0,1,0]])
B
$\left[ \begin{array}{ccccc}1&2&3&4&5\\0&0&-3&-5&7\\1&3&5&0&0\\0&1&0&1&0\\ \end{array} \right]$
Si le damos un segundo argumento no nulo, nos muestra los pasos dados:
L = ElimG(B,1)
en la representación excluye tanto los intercambios
inecesarios, como los inecesarios pasos que eliminan ceros a
la derecha del pivote... fíjese que el algoritmo recorre la fila desde
el pivote hasta el final, operando incluso cuando el componente
i,j
es un cero. Así, solo se muestran las operaciones que realmente modifican la matriz.
Fíjese que ElimG
da como resultado una forma escalonada, pero que la matriz original no ha cambiado
B
$\left[ \begin{array}{ccccc}1&2&3&4&5\\0&0&-3&-5&7\\1&3&5&0&0\\0&1&0&1&0\\ \end{array} \right]$
El método de más arriba no usa fracciones para escalonar si la matriz es "entera" (si sus componentes son enteros), pero se dan menos pasos usando solo transformaciones Tipo I. Con ElimrG
obtenemos una forma escalonada con menos transformaciones elementales (todas de Tipo I o intercambios).
L=ElimrG(B,1)
Como se puede comprobar, el proceso de eliminación de más arriba emplea operaciones elementales sobre las columnas "barriendo" las columnas de derecha a izquierda (y avanzando con las filas de arriba a abajo).
Pero podemos proceder de otros modos, por ejemplo de abajo a arriba y de derecha a izquierda. De manera que logramos una matriz triangular superior, y donde las columnas de ceros acaban a la izquierda (o cualquier otra variante). Para logralo no necesitamos modificar el código de más arriba, basta usarlo con habilidad.
El procedimiento reversed
invierte el orden de las columnas. Pongamos ambas matrices dentro de un Sistema
para verlas a la vez y comparar...
Sistema( [B, reversed(B)] )
$\left[\left[ \begin{array}{ccccc}1&2&3&4&5\\0&0&-3&-5&7\\1&3&5&0&0\\0&1&0&1&0\\ \end{array} \right];\;\left[ \begin{array}{ccccc}5&4&3&2&1\\7&-5&-3&0&0\\0&0&5&3&1\\0&1&0&1&0\\ \end{array} \right];\right]$
Así que es muy fácil invertir el orden de las filas (que son las columnas de la transpuesta):
Sistema( [B, ~reversed(~B)])
$\left[\left[ \begin{array}{ccccc}1&2&3&4&5\\0&0&-3&-5&7\\1&3&5&0&0\\0&1&0&1&0\\ \end{array} \right];\;\left[ \begin{array}{ccccc}0&1&0&1&0\\1&3&5&0&0\\0&0&-3&-5&7\\1&2&3&4&5\\ \end{array} \right];\right]$
Así, si también queremos invertir el orden de las columnas basta aplicar reversed
de nuevo
reversed(~reversed(~B))
$\left[ \begin{array}{ccccc}0&1&0&1&0\\0&0&5&3&1\\7&-5&-3&0&0\\5&4&3&2&1\\ \end{array} \right]$
Así pues, realizando ciertas operaciones de reordenamiento de la matriz, aplicando Elim
(o ElimG
) y deshaciendo las operaciones de reordenamiento, podemos lograr otras formas de eliminación:
reversed(ElimG(reversed(B))) # Por Columnas pero de derecha a izquierda (y de arriba a abajo)
$\left[ \begin{array}{ccccc}0&0&0&0&5\\0&0&0&-53&7\\0&0&1325&0&0\\0&1515&-180&5&0\\ \end{array} \right]$
... Puede investigar más variantes que traten de dejar los ceros en otra de las esquinas de la matriz (y operando con las filas o con las columnas)...
Podemos reducir más aún una matriz, por ejemplo elimando los componentes que están tanto a la derecha como a la izquierda de cada pivote y que normalicen todos los pivotes al valor $1$. Estudie el siguiente código:
M = Matrix(B)
r = 0 # Contador de pivotes
for i in range(1,M.m+1): # En cada una de las filas
p = ppivote(i|M, r) # posición del primer componente no nulo
if p > 0: # si la fila no está llena de ceros por la izquierda
r += 1 # el contador añade un nuevo pivote a la cuenta
M & T( {p, r} ) # intercambiamos las columnas
M & T( [ (fracc(-(i|M|j),(i|M|r)), r, j ) for j in range(1,M.n+1) if j != r ] ) # Eliminamos componentes
M & T( [ (fracc(1,(i|M|r)), j ) for j in range(1,M.n+1) if j == r ]) # Normalizamos cada pivote
M
$\left[ \begin{array}{ccccc}1&0&0&0&0\\0&1&0&0&0\\0&0&1&0&0\\0&0&0&1&0\\ \end{array} \right]$
Aunque obtenemos el mismo resultado con ElimGJ
(__Elim__inación __G__auss-__J__ordan por columnas)
ElimGJ(B,1)
$\left[ \begin{array}{ccccc}1&0&0&0&0\\0&1&0&0&0\\0&0&1&0&0\\0&0&0&1&0\\ \end{array} \right]$
Puede intentar programar otras formas de escalonar una matriz, por ejemplo, evitando usar fracciones, o escalonando de derecha a izquierda, o con transformaciones de las filas de arriba a abajo (o de abajo a arriba), etc.
En los libros de Álgebra Lineal se suele aplicar la eliminación por filas. Es fácil hacerlo usando la eliminación por columnas de la transpuesta, y transponiendo el resultado después.
M = Matrix(B)
~ElimG(~M)
$\left[ \begin{array}{ccccc}1&2&3&4&5\\0&3&0&-22&-1\\0&0&-3&-5&7\\0&0&0&25&1\\ \end{array} \right]$
pero obtenemos lo mismo con ElimF
(Elim__inación __Gaussiana por __F__ilas que obtiene una matriz triangular superior).
U=ElimGF(M,1)
Fíjese que para distingir si las operaciones se realizan con las filas o con las columnas, éstas aparecen por debajo de las flechas para indicar que operan con las filas, y por encima de las flechas para indicar que operan con las columnas.
Elim
, ElimG
, ElimGJ
, Elimr
, ElimrG
, ElimrGJ
, ElimF
, ElimGF
o ElimGJF
son subclases de la clase Matrix
que guardan en un atributo llamado pasos
dos listas con las secuencias de transformaciones elementales empleadas hasta llegar a la forma (pre)escalonada particular de cada caso (la primera lista tiene las abreviaturas de las transformaciones de las filas, y la segunda las de las columnas). En el atributo rango
guarda el número de pivotes que ha encontrado en la forma escalonada.
(Todas estas variantes devuelven alguna forma escalonada de la matriz original, pero sin modificar la matriz original).
x = Vector((1, 1, -2)); y = Vector((1, -2, 1)); z = Vector((-2, 1, 1))
A = Matrix([x,y,z])
A
$\left[ \begin{array}{ccc}1&1&-2\\1&-2&1\\-2&1&1\\ \end{array} \right]$
Elim(A)
$\left[ \begin{array}{ccc}1&0&0\\1&-3&0\\-2&3&0\\ \end{array} \right]$
El número de pivotes es el número de pivotes de la forma escalonada y se guarda en el atributo .rango
Elim(A).rango
2
el método rango()
de la clase Matrix
hace lo mismo
A.rg()
2
Los pasos dados en el proceso de eliminación se guardan en el atributo .pasos
, que contiene una lista
con dos sublistas. La primera con las transformaciones aplicadas a las filas y la segunda con las aplicadas a las columnas. Cada una de estas sublistas incluye las trasnformaciones dadas en cada paso (en este ejemplo se dieron dos pasos)
p=Elim(A).pasos
p
[[], [T([(-1, 1, 2), (2, 1, 3)]), T([(1, 2, 3)])]]
Así, los pasos correspondientes a las filas han sido
p[0]
[]
y los pasos correspondientes a las columnas
p[1]
[T([(-1, 1, 2), (2, 1, 3)]), T([(1, 2, 3)])]
Podemos visualizar las transformaciones aplicadas sobre las columnas en cada uno de los dos pasos dados:
display(p[1][0])
$\underset{\begin{subarray}{c} \left[\left(-1\right)\mathbf{1}+\mathbf{2} \right]\\\left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\end{subarray}}{\pmb{\tau}}$
display(p[1][1])
$\underset{\begin{subarray}{c} \left[\left(1\right)\mathbf{2}+\mathbf{3} \right]\end{subarray}}{\pmb{\tau}}$
Por comodidad también se guardan todas las tranformaciones aplicadas a las filas en el atributo .TrF
(que es un objeto de la clase T
con la composición de todas las transformaciones aplicadas a las filas) y todas las transformaciones aplicadas a las columnas en .TrC
. Así
Elim(A).TrC
$\underset{\begin{subarray}{c} \left[\left(-1\right)\mathbf{1}+\mathbf{2} \right]\\\left[\left(2\right)\mathbf{1}+\mathbf{3} \right]\\\left[\left(1\right)\mathbf{2}+\mathbf{3} \right]\end{subarray}}{\pmb{\tau}}$
Podemos aplicar dicha secuencia de transformaciones a las columnas de la matriz identidad de orden 3
E = I(3) & T(p[1])
E
$\left[ \begin{array}{ccc}1&-1&1\\0&1&1\\0&0&1\\ \end{array} \right]$
y sabemos que el producto de A
por E
debe darnos la misma forma escalonada
A*E
$\left[ \begin{array}{ccc}1&0&0\\1&-3&0\\-2&3&0\\ \end{array} \right]$
Que también deberíamos obtener directamente si aplicamos las transformaciones sobre las columnas de A
(aunque ahora si estaremos modificando la matriz original)... lo haremos sobre una copia de A
Matrix(A) & T(p[1])
$\left[ \begin{array}{ccc}1&0&0\\1&-3&0\\-2&3&0\\ \end{array} \right]$
Fíjese que si queremos obtener una matriz diagonal, podemos secillamente encadenar a un método de eliminación que nos dé una matriz triangular superior, un método que nos dé una triangular inferior:
D=ElimG(ElimF(B),1)
p=D.pasos
Cuando encadenamos de esta forma las transformaciones, en .pasos
se almacenan todos los dados sobre la matriz original. Recuerde que pasos
tiene dos listas de abreviaturas. La primera contiene las relativas a las operaciones efectuadas sobre las filas, y la segunda las de las columnas. Por tanto, si aplicamos las primeras por la izquierda y las segundas por la derecha, obtendremos la misma matriz diagonal:
T(p[0]) & Matrix(B) & T(p[1])
$\left[ \begin{array}{ccccc}1&0&0&0&0\\0&-3&0&0&0\\0&0&3&0&0\\0&0&0&75&0\\ \end{array} \right]$
Una vez más, podemos obtener el mismo resultado vía producto de matrices. Aplicamos la lista de operaciones realizadas sobre las filas a la matriz identidad de orden 4
F = T(p[0]) & I(4)
Y aplicamos la lista correspondiente a las transformaciones de las columnas a las columnas de la identidad de orden 5
C = I(5) & T(p[1])
Ahora el producto F*B*C
debe arrojar el mismo resultado
F*B*C
$\left[ \begin{array}{ccccc}1&0&0&0&0\\0&-3&0&0&0\\0&0&3&0&0\\0&0&0&75&0\\ \end{array} \right]$
A continuacion puede ver un resumen de procedimientos (pero puede encontrar más en la documentación de la librería)
---- FIN DE LA LECCIÓN -----
Lo que sigue es sólo para crear un índice de contenidos de este notebook (y se muestra al principio de la página)
%%javascript
$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')
$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')