OPERAZIONI PRELIMINARI

A={{},{},{}}

A//MatrixForm
Det[A]
FullSimplify[Det[A]]
MatrixRank[A]

(*Parti di matrice*)
A[[{(*righe*)},{(*colonne*)}]]

RAPPRESENTAZIONI

NUCLEO

(*Quello che vale peri il nucleo vale anche per un qualsiasi sottospazio visto che fa parte del dominio*)

(*Cartesiana*)
(*Le righe della matrice associata sono i coefficienti delle equazioni del nucleo*)
(*Devo solo scrivere le righe della matrice come equazioni, eliminando però le righe linearmente dipendenti*)
a = A[[1]].{x, y, z}
b = A[[2]].{x, y, z}

(*Parametrica*)
(*Uso il comando che mi da la base nel nucleo e scrivo i vettori per colonne*)
NullSpace[A]
(*O metto in sistema le equazioni trovate con la cartesiana e risolvo*)
Solve[{a == 0, b == 0, c == 0}, {x, y, z}](*le incognite in cui risolvere il sistema variano in relazione al rango della magtrice (rango = n-2 corrispondono 2 parametri)*)

IMMAGINE

(*Parametrica*)
(*Le conlonne sono sistemi di generatori dell'immagine*)
(*Eliminando le colonne linearmente dipendenti ho già la rappresentazione paramentrica con numero di parametri uguale al numero di colonne rimaste*)
M=A[[{1,2,3},{1,2}]]
M//MatrixForm
(*Nel caso fosse già in rappresentazione cartesiana basta risolvere il sistema delle equazioni del sistema*)
a = A[[1]].{x, y,z,t}
b = A[[2]].{x, y,z,t}
Solve[{a==0,b==0},{x,y}]
(*Il numero di incognite dipende dai parametri e delle equazioni linearmente dipendenti del sistema*)

(*Cartesiana*)
(*Prendo la matrice precedentemente trovata (lineramente indipendente) e ci aggiungo x y z, il determinante deve essere uguale a zero*)
B=Join[Transpose[{{x,y,z}}],A[[{1,2,3},{1,2}]],2]
B//MatrixForm
Det[B]
w=FullSimplify[Det[B]]
Solve[w==0,{x}]
(*Il numero di incognite è n-rango di A*)

AUTOVALORI

(*Prima faccio vedere il calcolo del polinomio caratteristico (t * Id_n - A) e la sua semplificazione da dove mi vengono fuori gli autovalori*)
MC=(t*IdentityMatrix[n]-A)(*Matrice Caratteristica*)
MC//MatrixForm

q=CharacteristicPolynomial[A,t]
FullSimplify[q]

(*Scrivo gli autovalori con le molteplicità algebriche*)
Eigenvalues[A]
Eigenvalues[N[A]](*Nel caso dovessi trovare i valori numerici*)

(*Se sono presenti autovalori con m.a. > 1 guardo la m.g.
n è la dimensione dell spazio e g è l'autovalore.*)
(*Oppure si può guardare con il metodo sottostante quanti vettori ha una base dell'autospazio considerato e quindi capire anche la sua dimensione o m.g.*)
n-MatrixRank[g*IdentityMatrix[n]-A]

(*Trovo una base x l'autospazio relativo all'autovalore g*)
NullSpace[g*IdentityMatrix[n]-A]

(*BASE SPETTRALE*)
(*Se e solo se la somma delle m.g. è uguale a n; con il metodo sopra trovo le basi dei relativi autospazi e le unisco*)
Join[NullSpace[g*IdentityMatrix[n]-A],NullSpace[...], ...]

CLASSIFICAZIONE DI UNA CONICA

(*Equazione della conica:*)
A[[{2},{2}]]*x^2+A[[{3},{3}]]*y^2+2*A[[{2},{3}]]*xy+2*A[[{1},{2}]]*x+2*A[[{1},{3}]]*y+A[[{1},{1}]]

w=FullSimplify[Det[A]]

(*Conica degenere?*)
(*Basta guardare se 0 è autovalore o il det sempre ≠ da 0*)
Solve[w== 0,g]

M00=A[[{2,3},{2,3}]]
M00//MatrixForm
Det[M00]
q=FullSimplify[Det[M00]]
(*Parabola*)
Solve[q== 0,g]

(*Ellisse*)
Reduce[q > 0,g]
(*Vuota?*)
(*Lo si può sapere anche guardando se il discriminante della conica è definito positivo, quindi guardando i discriminanti dei minori o guardando il segno degli autovalori (auotovalori tutti positivi ==> definita positiva)*)
Reduce[A[[3,3]]*Det[A]>0,g]

(*Iperbole*)
Reduce[q < 0,g]

Prodotto scalare

(*Una forma bilineare è un prodotto scalare <==> è simmetrica e definita positiva*)
(*Bisogna imporre agli autovalori di essere tutti positivi*)
{e,f,h}=Eigenvalues[A]
Reduce[{e>0,f>0,h>0},g](*g sta per gamma o una variabile qualunque*)

COMPLEMENTO ORTOGONALE

(((* )^⊥)Im S*)

(*Cartesiana*)
(*Le colonne sono i coefficienti delle equazioni del complemento ortogonale dell'immagine*)
(*Prendo le colonne linearmente indipendenti e le scrivo per righe*)
Transpose[A].{x,y,z}

(*Parametrica*)
(*Risolvo il sistema della cartesiana*)
{i,o,p}=Transpose[A].{x,y,z,t}
Solve[{i==0,o==0,p==0},{x,y,z}]
(*Il numero di incogniete sono il numero di righe lin indip*)

(((* )^⊥)Ker S*)

(*Parametrica*)
(*Le righe sono generatori del complemento ortogonale del nucleo*)
(*Prendo le righe linearmente indipendenti! e le metto in colonna con parametri uguale al numero di colonne linearmente dipendenti*)
Transpose[A]

(*Cartesiana*)
(*Se trovo una base del nucleo le sue componenti saranno i coefficienti delle equazioni del nucleo*)
{a,b}=NullSpace[A].{x, y, z}

a = Transpose[A][[1]].{x, y, z,t}
b = Transpose[A][[2]].{x, y, z, t}

(*PROIEZIONE ORTOGONALE*)
(*è M = A * (G^(-1)) (( * )^t)A, dove G ((= )^t)A * A *)
(*A è una base del sottospazio*)

(*Oppure Dopo aver trovato la base ortogonale per il sottospazio, la matrice della proiezione ortogonale è il prodotto tra la base ortogonale scritta per colonne e la sua trasposta*)
f=FullSimplify[Orthogonalize[{(*base del sottospazio*)}]]
f//MatrixForm
Transpose[f].f//MatrixForm (*Sarebbe A (( * )^t)A, visto che G = 1*)
(*Se si ha la matrice della trasformazione per trovare una base ortogonale del sottospazio basta fare Orthogonalize[Transpose[A]]*)