|
L'algoritmo di Gram-Schmidt.
Non sempre è facile trovare una base ortonormale per un dato spazio vettoriale.
Se, ad esempio
V = {(x1,x2,x3,x4): x1 + x2 + x3 + x4 = 0}
si vede facilmente che V ha dimensione minore di 4 essendo un sottospazio di R4, inoltre i 3 vettori di V
u1 = (1,-1,0,0) , u2 = (0,1,-1,0) , u3 = (0,0,1,-1)
sono linearmente indipendenti e dunque V è di dimensione 3. Tuttavia questi vettori non sono ortogonali tra loro. Ad esempio
u1 non è ortogonale a u2 dato che u1.u2 = -1.
Anche dal punto di vista dei moduli questi vettori non vanno bene dato che hanno tutti come modulo la radice di 2.
L'algoritmo di Gram-Schmidt,
che ora esponiamo, da un procedimento per ricavare da un qualunque insieme di generatori di un dato spazio vettoriale, una base ortonormale. Sia
V = Span(u1, u2, ... , um)
- Se u1 = 0 eliminiamolo dal nostro elenco. Sarà ancora
Span(u1, u2, ... , um) = Span(u2, ... , um). Se invece
u1 non è zero sostituiamolo con il suo normalizzato cioè col vettore
Il vettore e1 ha modulo 1 e Span(u1, u2, ... , um) =
Span(e1, u2, ... , um) dato che
e1 Î Span(u1, u2, ... , um) e
u1 Î Span(e1, u2, ... , um).
Se i vettori della lista sono esauriti, l'algoritmo è finito: {e1} è una base ortonormale di V e dim V = 1, altrimenti tra i
generatori di V esiste un altro
vettore u2
- Togliamo da u2 la sua proiezione ortogonale di su e1 in modo che il vettore restante
e'2 = u2 - (u2.e1)e1
sia
ortogonale a e1. Se e'2 = 0 allora u2, essendo combinazione lineare di e1,
può essere tolto dalla lista e Span(e1, u2, ... , um) =
Span(e1, ... , um). Altrimenti sostituiamo u2 con
il normalizzato di e'2 cioè con
A questo punto e1 e e2 sono due vettori di modulo 1 e ortogonali tra loro. Inoltre
V=
Span(e1, u2, ... , um)=Span(e1, e2, ... , um)
dato che
e2 Î Span(e1, u2, ... , um) e
u2 Î Span(e1, e2, ... , um).
Se i vettori della lista sono esauriti, l'algoritmo è finito:{e1,e2} è una base ortonormale di V
e dimV = 2, altrimenti tra i
generatori di V esiste un altro
vettore u3 e possiamo iterare il procedimento.
- Togliamo da u3 la sua proiezione ortogonale sullo spazio generato da
e1 e e2 in modo che il vettore restante
e'3 = u3 - [(u3.e1)e1
+ (u3.e2)e2]
sia ortogonale sia a e1 che a e2. Se e'3 = 0
allora u3, essendo combinazione lineare di e1 ed e2 ,
può essere tolto dalla lista e Span(e1, e2, u3 ... , um) =
Span(e1, e2, ... , um). Altrimenti sostituiamo u3 con
il normalizzato di e'3 cioè con
A questo punto e1 , e2 , e3 sono tre vettori di modulo 1 e ortogonali tra loro
a due a due. Inoltre
V=
Span(e1, e2, u3, ... , um)=
Span(e1, e2, e3, ... , um)
dato che
e3 Î Span(e1, e2, u3, ... , um) e
u3 Î Span(e1, e2, e3, ... , um)
Se i vettori della lista sono esauriti, l'algoritmo è finito: {e1,e2,e3} è
una base ortonormale di V e dim V = 3, altrimenti iteriamo
il procedimento col vettore successivo fino ad esaurimento dei vettori.
Esempio
Consideriamo lo spazio vettoriale
V = {(x1,x2,x3,x4): x1 + x2 + x3 + x4 = 0}
= Span(u1, u2,u3)
dove
u1 = (1,-1,0,0) , u2 = (0,1,-1,0) , u3 = (0,0,1,-1)
e applichiamo l'algoritmo di Gram-Schmidt a questi tre vettori.

Si vede immediatamente che i tre vettori {e1,e2,e3} sono vettori di V
dal momento che la somma delle loro componenti è zero e inoltre sono di modulo 1 e a due a due ortogonali.
| |