Proceso de Gram-Schmidt

Los dos primeros pasos del proceso Gram-Schmidt

En matemáticas, particularmente en álgebra lineal y análisis numérico, el proceso de Gram-Schmidt es un método para ortonormalizar un conjunto de vectores en un espacio de producto interno, más comúnmente el espacio euclidiano Rⁿ equipado con el producto interno estándar. El proceso de Gram-Schmidt toma un conjunto finito de vectores linealmente independientes S = {v₁,..., v_k} para k ≤ < i>n y genera un conjunto ortogonal S′ = {u₁,..., u_k} que abarca el mismo subespacio k-dimensional de Rⁿ como S.

El método lleva el nombre de Jørgen Pedersen Gram y Erhard Schmidt, pero Pierre-Simon Laplace lo conocía antes que Gram y Schmidt. En la teoría de las descomposiciones de grupos de Lie, se generaliza mediante la descomposición de Iwasawa.

La aplicación del proceso de Gram-Schmidt a los vectores de columna de una matriz de rango de columna completa produce la descomposición QR (se descompone en una matriz ortogonal y otra triangular).

El proceso de Gram-Schmidt

El proceso modificado Gram-Schmidt que se ejecuta en tres vectores linealmente independientes y no ortogonales de una base para R³. Haga clic en la imagen para obtener detalles. La modificación se explica en la sección de Estabilidad Numérica de este artículo.

Definimos el operador de proyección por

$${displaystyle operatorname {proj} _{mathbf {u}(mathbf {v})={frac {langle mathbf {v}mathbf {u}rangle }{langle mathbf {u}mathbf {u} {}} {Mathbfu} {} {} {}} {}}}}}} {$$

Donde ${displaystyle langle mathbf {v}mathbf {u} rangle }$ denota el producto interior de los vectores v y u. Este operador proyecta el vector v ortogonalmente en la línea abarcada por vector u. Si u = 0, definimos ${displaystyle operatorname {proj} _{mathbf {0}(mathbf {v}):=mathbf {0}$, es decir, el mapa de proyección ${displaystyle operatorname {proj} _{mathbf {0}$ es el mapa cero, enviando cada vector al vector cero.

El proceso de Gram-Schmidt funciona de la siguiente manera:

$${displaystyle {begin{aligned}mathbf {u} ¿Por qué? - Hola. "Mathbf" ♪♪♪♪ {v} ################################################################################################################################################################################################################################################################ {proj} _{s} {f} {fn} {fn}} {cH})} {m}} {c} {c}}} {c}}} {fnMitbf} {fnMitbf} - Hola. ¿Qué? ################################################################################################################################################################################################################################################################ ################################################################################################################################################################################################################################################################ {proj} _{i} {c} {c}})-fnuncio {proj} _{mthbf {u} _{2}}(mathbf {v} _{3}), compañeromathbf {e} - ¿Qué? - Hola. - Hola. - ¿Qué? ################################################################################################################################################################################################################################################################ {f} {f} {f} {f} {f}})-f}-f}-f}-f} {f} {f} {f} {f} {f} {f})-f}-f} ################################################################################################################################################################################################################################################################ 'vdots ' 'vdots 'Mathbf {u} ¿Qué? ################################################################################################################################################################################################################################################################ {fnK} {cHFF} {cHFF} {cHFF} {cHFF} {cHFF} {c} {cHFF}} {c}} {cHFF} {cHFF}} {fnMitbf} - Hola. - Hola.$$

La secuencia u₁,..., u_k es el sistema requerido de vectores ortogonales, y los vectores normalizados e₁,..., e_k forman un conjunto ortonormal. El cálculo de la secuencia u₁,..., u_k se conoce como ortogonalización Gram-Schmidt, mientras que el cálculo de la secuencia e₁,..., e_k se conoce como ortonormalización de Gram-Schmidt ya que los vectores están normalizados.

Para comprobar que estas fórmulas producen una secuencia ortogonal, primer cálculo ${displaystyle langle mathbf {u} _{1},mathbf {u} ¿Qué?$ sustituyendo la fórmula anterior u₂Tenemos cero. Entonces usa esto para calcular ${displaystyle langle mathbf {u} _{1},mathbf {u} - ¿Qué?$ sustitución de la fórmula para u₃Tenemos cero. La prueba general procede por inducción matemática.

Geométricamente, este método procede de la siguiente manera: para calcular u_i, proyecta v _i ortogonalmente sobre el subespacio U generado por u₁,..., u_i−1, que es el mismo que el subespacio generado por v₁,..., v_i−1. El vector u_i se define entonces como la diferencia entre v_i y esta proyección, garantizada para ser ortogonal a todos los vectores en el subespacio U.

El proceso de Gram-Schmidt también se aplica a una secuencia infinita numerable linealmente independiente {v_i} _i. El resultado es una secuencia ortogonal (u ortonormal) {u_i}_i tal que para el número natural n: el lapso algebraico de v₁,..., v_n es el mismo que el de u₁,..., u_n.

Si el proceso de Gram-Schmidt se aplica a una secuencia linealmente dependiente, genera el vector 0 en la iésimo paso, asumiendo que v_i es una combinación lineal de v₁,..., v_i−1 . Si se va a producir una base ortonormal, entonces el algoritmo debe probar los vectores cero en la salida y descartarlos porque ningún múltiplo de un vector cero puede tener una longitud de 1. El número de vectores de salida por el algoritmo será entonces la dimensión del espacio ocupado por las entradas originales.

Una variante del proceso Gram-Schmidt utilizando la recursión transfinita aplicada a una secuencia infinita (posiblemente incontable) de vectores ${displaystyle (v_{alpha })_{alpha =lambda}$ produce un conjunto de vectores ortonormales ${displaystyle (u_{alpha })_{alpha =kappa }$ con ${displaystyle kappa leq lambda }$ tal que para cualquier ${displaystyle alpha leq lambda }$, la terminación del lapso de ${displaystyle {u_{beta }:beta se hizomin(alphakappa)}}$ es lo mismo que el de ${displaystyle {v_{beta }:beta se hizo \alpha}$. En particular, cuando se aplica a una base (algebraica) de un espacio Hilbert (o, más generalmente, una base de cualquier subespacial denso), produce una base ortonormal (funcional-analítica). Tenga en cuenta que en el caso general a menudo la desigualdad estricta ${displaystyle kappa }lambda }$ sostiene, incluso si el conjunto de inicio era linealmente independiente, y el lapso de ${displaystyle (u_{alpha })_{alpha =kappa }$ no debe ser un subespacio del lazo ${displaystyle (v_{alpha })_{alpha =lambda}$ (Más allá, es un subespacio de su terminación).

Ejemplo

Espacio euclidiano

Considere el siguiente conjunto de vectores en R² (con el producto interno convencional)

$${displaystyle S=left {cH00} {1}={begin{bmatrix}31end{bmatrix}mathbf {fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif}$$

Ahora, realice Gram-Schmidt para obtener un conjunto ortogonal de vectores:

$${displaystyle mathbf {u} ¿Qué? {1}={begin{bmatrix}31end{bmatrix}}$$

$${displaystyle mathbf {u} ¿Qué? {v} ################################################################################################################################################################################################################################################################ {fnMicrosoft} {2})={begin{bmatrix}22end{bmatrix}-operatorname {proj} _{begin{begin{smallmatrix}31end{smallmatrix}right]}{begin{bmatrix}2end{bmatrix} {b} {b} {b} {b}}{b}}}{b}}}}{b}}}}{b}}{b}{b}}}{b} {b} {begin}{b} {begin}}}}}}}}{b}{b} {b} {b} {b} {b} {b} {b}{b} {begin {b} {b} {b}{b} {b}{b} {b}{b}}}{b} {b}}}}}} {8}{10} {begin{bmatrix}31end{bmatrix}={begin{bmatrix}-2/5\6/5end{bmatrix}}}$$

Comprobamos que los vectores u₁ y u₂ son de hecho ortogonales:

$${displaystyle langle mathbf {u} _{1},mathbf {u} _{2}rangle =leftlangle {begin{bmatrix}31end{bmatrix}},{begin{bmatrix}-2/56/5end{bmatrix}rightrangle - ¿Qué?$$

Para vectores distintos de cero, podemos normalizar los vectores dividiendo sus tamaños como se muestra arriba:

$${displaystyle mathbf {e} {fnK} {f} {fnK}} {begin{bmatrix}31end{bmatrix}}}$$

$${displaystyle mathbf {e} {2}={frac {1}{sqrt {40 over 25}{begin{bmatrix}-2/5\6/5end{bmatrix}}={frac {1}{sqrt {10}{begin{bmatrix}-13end{bmatrix}}}}} {ccH0}}} {c} {cccccccccH00}}}} {ccccccH0} {cccccH0} {cccccH0} {cccH0} {cH0} {cH0}} {ccH00} {ccccccccH0} {cH0} {cccccH0}ccccccc$$

Propiedades

Denote by ${displaystyle operatorname {GS} (mathbf {v} _{1},dotsmathbf {v} _{k})}$ el resultado de aplicar el proceso Gram-Schmidt a una colección de vectores ${displaystyle mathbf {v} _{1},dotsmathbf {v} ¿Qué?$. Esto produce un mapa ${displaystyle operatorname {GS} colon (mathbb {R} ^{n})^{k}to (mathbb {R} } {n})} {k}} {} {}} {} {c}} {c} {cH}} {c}}}}}}}}} {c}}}}}}} {c}}}}}} {}}}}}}}}} {c}}}}}}}}} {c}}}}}}}}} {c}}}}}} {c}}}}}}}}}}}}}}}} {c}}}}}}}} {c}}}}}}}}}}}}}}}}}}} {c}}}}}}}}}}}}}}}}}}}}}}}}}}}}} {c}}}}}}}}}}}}}}}}}}$.

Tiene las siguientes propiedades:

• Es continuo
• Es la orientación preservando en el sentido de que ${displaystyle operatorname {or} (mathbf {v} _{1},dotsmathbf {v} _{k})=operatorname {or} (operatorname {GS} (mathbf {v} _{1},dotsmathbf {v} _{k})})}}$.
• Se comunica con mapas ortogonales:

Vamos ${displaystyle gcolon mathbb {R} ^{n}to mathbb {R} {fn}$ ser ortogonal (con respecto al producto interno dado). Entonces tenemos

$${fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif} {fnMicrosoft Sans Serif}$$

Además, una versión parametrizada del proceso Gram-Schmidt produce una retracción de deformación (fuerte) del grupo lineal general ${displaystyle mathrm {GL} (mathbb {R} ^{n}}$ sobre el grupo ortogonal ${displaystyle O(mathbb {R} {n})}$.

Estabilidad numérica

Cuando este proceso se implementa en un ordenador, los vectores ${displaystyle mathbf {u} ¿Qué?$ a menudo no son bastante ortogonales, debido a errores de redondeo. Para el proceso Gram-Schmidt como se describe anteriormente (a veces referido como "Gram-Schmidt clásico") esta pérdida de ortogonalidad es particularmente mala; por lo tanto, se dice que el proceso (clásico) Gram-Schmidt es numéricamente inestable.

El proceso de Gram-Schmidt se puede estabilizar con una pequeña modificación; esta versión a veces se denomina Gram-Schmidt modificada o MGS. Este enfoque da el mismo resultado que la fórmula original en aritmética exacta e introduce errores más pequeños en la aritmética de precisión finita. En lugar de calcular el vector u_k como

$${displaystyle mathbf {u} - ¿Qué? [Proj] _{mathbf {u} {cHFF}(mathbf {v} _{k})-operatorname {proj} _{mathbf {u} {ch} {ch}-cdots -operatorname {proj} _{mthbf {u} _{k-1}(mathbf {v} _{k}),}} {c} {c} {c}}}} {ccH0}$$

$${displaystyle {begin{aligned}mathbf {u} {{k}{(1) {=mathbf {v} - ¿Por qué? {proj} _{i} {c} {c} {c}c}\\c})\mthbf {u} _{k}}}{(2)}mthbf {u} _{} {c} {c}c} {c}c}cc}c}c}c}c}c}cH9c}c}\c}c}c}c}c}c}c}c}c}c}c}cccH9cH9cH9c}c}c}c}c}ccH9cH9cH9cH9c}c}c}c}cccc}c}cH9cH9cH9cH9c}c}c}c}c}c}c}cH {proj} _{mathbf {u}{2}left(mathbf {u} _{k}{(1)}right),\\\;;vdots\\mathbf {u} _{k}{k-2)} sensible=mathbf {u} _{k}}\f}f}-f}-nombre {fnK} ¿Por qué? {fnK} {fnMicrosoft}fnK} {fnMicrosoft}} {f}}} {f}}} {f}}} {f}}} {fnMitbf {f}} {f}} {fnK}}} {f}}} {f}}}}f}f}f}f}}}f}f}f}f}f}}f}}f}f}}f}}}}f}f}f}f}f}f}f}}f}f}f}f}}}}f}f}f}fnKfnKf}}}}}f}}f}f}f}f}fnKf}f}}}}}fnKfnKf}f}f}}}}}f}}}}}}}}}$$

Este método se usa en la animación anterior, cuando se usa el vector intermedio v'₃ al ortogonalizar el vector azul v₃.

Aquí está otra descripción del algoritmo modificado. Dados los vectores ${displaystyle v_{1},v_{2},dotsv_{n}$, en nuestro primer paso producimos vectores ${displaystyle v_{1},v_{2}{(1)},dotsv_{}{(1)}}$eliminando componentes a lo largo de la dirección ${displaystyle v_{1}$. En fórmulas, ${displaystyle v_{k}{(1)}:=v_{k}-{frac {langle v_{k},v_{1}rangle }v_{1}$. Después de este paso ya tenemos dos de nuestros vectores ortogonales deseados ${displaystyle u_{1},dotsu_{n}$, a saber ${displaystyle U_{1}=v_{1},u_{2}=v_{2}{(1)}$, pero también hicimos ${displaystyle v_{3}{(1)},dotsv_{n}{(1)}}$ ya ortogonal a ${displaystyle U_{1}$. A continuación, ortogonalizamos los vectores restantes contra ${displaystyle u_{2}=v_{2}{(1)}$. Esto significa que computamos ${displaystyle v_{3}{(2)},v_{4}{(2)},dotsv_{n}{(2)}}$ por resta ${displaystyle v_{k}{(2)}:=v_{k}{(1)}-{frac {langle v_{k}^{(1)},u_{2}rangle }{langle u_{2},u_{2}rangle }u_{2}$. Ahora hemos almacenado los vectores ${displaystyle v_{1},v_{2}{(1)},v_{3}{(2)},v_{4}^{(2)},dotsv_{n}{(2)}} {} {}} {} {}} {c}}}$ donde los primeros tres vectores ya están ${displaystyle U_{1},u_{2},u_{3}$ y los vectores restantes ya son ortogonales ${displaystyle U_{1},u_{2}$. Como debe ser claro ahora, el siguiente paso ortogonaliza ${displaystyle v_{4}{(2)},dotsv_{n}{(2)}}$ contra la ${displaystyle u_{3}=v_{3}{(2)}$. Procediendo de esta manera encontramos el conjunto completo de vectores ortogonales ${displaystyle u_{1},dotsu_{n}$. Si los vectores ortonormales son deseados, entonces normalizamos a medida que vamos, para que los denominadores en las fórmulas de resta se conviertan en uno.

Algoritmo

El siguiente algoritmo de MATLAB implementa la ortonormalización de Gram-Schmidt para vectores euclidianos. Los vectores v₁,..., v_k (columnas de la matriz V, de modo que V(:,j) es el jésimo vector) son reemplazado por vectores ortonormales (columnas de U) que abarcan el mismo subespacio.

función U = graschmidt()V) [n, k] = tamaño()V); U = ceros()n,k); U(:1) = V(:1) / norma()V(:1)); para i = 2:k U(:i) = V(:i); para j = 1:i-1 U(:i) = U(:i) - ()U(:j)'U(:i) * U(:j); final U(:i) = U(:i) / norma()U(:i)); finalfinal

El costo de este algoritmo es asintóticamente O(nk²) operaciones de coma flotante, donde n es la dimensionalidad de los vectores.

Vía eliminación gaussiana

Si las filas {}v₁,... v_k} están escritos como matriz ${displaystyle A}$, luego aplicar la eliminación gausiana a la matriz aumentada ${displaystyle left[AA^{mathsf {T}SobrevivirAright]$ producirá los vectores ortogonalizados en lugar de ${displaystyle A}$. Sin embargo, la matriz ${displaystyle AA^{mathsf {T}}$ debe ser llevado a la forma de echelon fila, utilizando sólo la operación de fila de añadir un escalar múltiple de una fila a otra. Por ejemplo, tomando ${displaystyle mathbf {v} {1}={begin{bmatrix}3 ventaja1end{bmatrix}mathbf {cHFF} {cH00} {cH00}} {cH00}} {cHFF}}}} {begin{bmatrix}2}end{bmatrix}}}}}}}}}}}} {begin{begin{bmatrix} {bmatrix}2}}}}}}}}}}}}}}}}}}}}}}}}}}}}} {begin {begin {begin{begin{begin{bmatrix}}}}}}}}}} {begin{bmatrix}}}}}}}}}}}}}}}}}}} {begin{begin{bmatrix}}}}}}}} {begin{begin{bmatrix}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}$ como arriba, tenemos

$${displaystyle left[AA^{mathsf {T}spetoAright]=left[{begin{array}{rr habitr}10 implica8 ventaja3 implica18 círculo8 implica2end{array}right]}}}$$

Y reducir esto a la forma escalonada de filas produce