Un vecteur `x` de dimension `x1` constitue une liste de `x1` éléments. Chaque composante du vecteur possède un indice `i` qui le localise dans la liste et se note `x_i` ou de façon plus explicite `x[i]`. Et l'indice évoluent comme suit, `i"∈"{1..x1}`. On note l'ensemble des vecteurs de dimension `n` par `RR^(n)`.
Une matrice `a` de dimension `a1"×"a2` constitue un tableau. Chaque composante de la matrice possède 2 indices `i,j` qui le localisent dans le tableau et se note `a_(i,j)` ou de façon plus explicite `a[i,j]`. Et ces indices évoluent comme suit `i"∈"{1..a1}`, `j"∈"{1..a2}`. On note l'ensemble des matrices de dimension `n"×"m` par `RR^(n×m)`.
Les vecteurs sont identifiés au matrice de dimension `n"×"1`.
Voici le produit d'une matrice par un vecteur, le produit de deux matrices, l'opération de transposition d'un vecteur, et l'opération de transposition d'une matrice :
`x "∈" RR^(n×m)`
`y "∈" RR^(m)`
`z "∈" RR^(n)``z=xy` `AAi, z[i]=sum_s x[i,s]y[s]` `x "∈" RR^(n×m)`
`y "∈" RR^(m×p)`
`z "∈" RR^(n×p)``z=xy` `AAiAAj, z[i,j]=sum_s x[i,s]y[s,j]` `x "∈" RR^(n)`
`z "∈" RR^(1×n)``z=x^"t"` `AAiAAj, z[1,i]=x[i]` `x "∈" RR^(n×m)`
`z "∈" RR^(m×n)``z=x^"t"` `AAiAAj, z[i,j]=x[j,i]`
Voici le produit scalaire de deux vecteurs noté `x"·"y`, le produit croisé de deux vecteurs noté `x"×"y` :
`x "∈" RR^(n)`
`y "∈" RR^(n)`
`z "∈" RR``z=x"·"y` `z=sum_s x[s]y[s]` `x "∈" RR^(n)`
`y "∈" RR^(m)`
`z "∈" RR^(n×m)``z=x"×"y` `AAiAAj, z[i,j]=x[i]y[j]`
Dans ces expressions, le typage par inférence détermine le domaine où évolue `i,j,k,s`, et détermine donc la dimension de la matrice résultat `z`.
il y a un moyen mnémotechnique permettant de décrire visuellement comment s'opère le produit de deux matrices. Pour cela, on représente une matrice de dimension `n"×"m` par un tableau de `n` lignes et de `m` colonnes. Par exemple, la matrice `a` de dimension `2"×"3` se présente comme suit :
`a=( (a_(1,1), a_(1,2), a_(1,3)), (a_(2,1), a_(2,2), a_(2,3)) )`
Et on note sa transposé, opération qui consiste à intervertir les lignes avec les colonnes, comme suit :
`a^"t"=( (a_(1,1), a_(2,1)), (a_(1,2), a_(2,2)), (a_(1,3), a_(2,3)))`
Les indices jouant un role important, on adopte une seconde notation des composantes de la matrice les mettant en exergue :
`a=( (a[1,1], a[1,2], a[1,3]), (a[2,1], a[2,2], a[2,3]) )`
Une matrice ne comprenant qu'une colonne est appelée une matrice colonne ou de dimension de la forme `n"×"1`. Une matrice ne comprenant qu'une ligne est appelée une matrice ligne ou de dimension de la forme `1"×"n`. La matrice ligne est obtenu en prenant la transposé d'une matrice colonne et vis-versa.
Voici des exemples de produit de matrices. Le nombre de colonnes de la première matrice doit être égale au nombre de lignes de la seconde matrice. Une ligne de la première matrice est composée avec une colonne de la seconde matrice pour donner un scalaire placé au même numéro de ligne utilisé et au même numéro de colonne utilisé :
`(a,b)((x),(y)) = ax"+"by` |
`((a),(b))(x,y) = ((ax,ay),(bx,by))` |
`((a,b),(c,d))((x),(y)) = ((ax"+"by),(cx"+"dy))` |
`((a,b),(c,d))((x,z),(y,t)) = ((ax"+"by,az"+"bt),(cx"+"dy,cz"+"dt))` |
On adopte la convention suivante : Une variable surmontée d'une flèche désigne un vecteur que l'on identifie toujours à une matrice colonne. Une matrice ligne s'obtient en prenant la transposé d'un vecteur. Puis, afin d'alléger l'écriture, une variable déclarée comme vecteur, soit par le contexte ou soit parcequ'elle possède une flèche, peut être présentée indifféremment en ligne ou en colonne, elle constitura toujours, in fine, une matrice colonne.
Etant donnés deux vecteurs `vec x, vec y` à 3 composantes `vec x=(x_1,x_2,x_3)` et `vec y=(y_1,y_2,y_3)`. Comme ce sont des vecteurs, ils définissent des matrices colonnes :
Leur transposé définissent des matrices lignes :
Le produit scalaire, noté `"·"`, s'écrit :
`vecx "·" vecy = vec(x)^"t" vec(y) = (x_1,x_2,x_3)((y_1),(y_2),(y_3))=x_1y_1+x_2y_2+x_3y_3`
Le produit croisé, noté `"×"`, s'écrit :
`vecx"×"vecy = vecx vecy^t = ((x_1),(x_2),(x_3))(y_1,y_2,y_3) = ( (x_1y_1, x_1y_2, x_1y_3),(x_2y_1, x_2y_2, x_2y_3),(x_3y_1, x_3y_2, x_3y_3))`
Pour s'affranchire des conventions arbitraires du calcul matriciel, on utilise à la place des matrices, des vecteurs de vecteurs et des vecteurs de vecteurs de vecteurs et ainsi de suite. Et on utilise deux opérations de produit ; le produit croisé noté par absence de symbole, et le produit scalaire généralisé noté `"·"`, telles que décrits dans ces exemples :
`avec x =a((x_1),(x_2))= ((ax_1),(ax_2))`
`((a),(b))vec x = ((avec x),(bvec x)) = ((a),(b))((x_1),(x_2)) = (( ((ax_1),(ax_2)) ),( ((bx_1),(bx_2))))`
`((a),(b))"·"((x_1),(x_2)) = ax_1+bx_2`
Le produit croisé s'évalue de gauche à droite et est prioritaire au produit scalaire généralisé qui s'évalue de droite à gauche. Et on note :
`vecx^2=vecx"·"vecx`
`vecx^square=vecxvecx`
Étant donné une fonction `vec f` de `RR^2` vers `RR^3`. On adopte la notation des physiciens. On considère un système physique possédant deux variables d'état `vec f` et `vec x` :
`vecx=((x_1),(x_2)) vecf=((f_1),(f_2),(f_3))`
Autrement dit, le système possède 5 variables d'état `x_1,x_2,f_1,f_2,f_3`, liées par le neurone suivant :
`vec f"←"(x_1,x_2)`
Et donc :
`f_1"←"(x_1,x_2)`
`f_2"←"(x_1,x_2)`
`f_3"←"(x_1,x_2)`
On adopte également l'écriture vectoriel en utilisant les même parenthèses d'appel, la différence se faisant sur le type d'argument qui est ici un vecteur au lieu de 2 arguments réels.
`vec f"←"(vec x)`
Et donc
`f_1"←"(vec x)`
`f_2"←"(vec x)`
`f_3"←"(vec x)`
Formellement il y a donc deux systèmes de coordonnées par défaut, soit `(x_1,x_2)` ou soit `(vecx)` et qui sont évidement liés par une bijection.
`vec f"="vec(f)(vecx)"="vec(f)(x_1,x_2)`
`f_1"="f_1(vecx)"="f_1(x_1,x_2)`
`f_2"="f_2(vecx)"="f_2(x_1,x_2)`
`f_3"="f_2(vecx)"="f_2(x_1,x_2)`
A chaque variable correspond un élément différentiel qui exprime une variation infiniment petite lorsque le système évolue continument, `dx_1,dx_2,df_1,df_2` et `dvec f` et `dvecx` avec :
`dvec(x) = ((dx_1),(dx_2)) dvecf=((df_1),(df_2),(df_3))`
Et les dérivées partielles sont définies comme suit :
`(del vec f)/(delx_1) = lim_(epsilon->0)(f(x_1"+"epsilon,x_2)-f)/epsilon`
`(del vec f)/(delx_2) = lim_(epsilon->0)(f(x_1,x_2"+"epsilon)-f)/epsilon`
L'équation différentielle exprimant que `vec(x)|->vec(f)(vecx)` est dérivable, s'écrit comme suit :
`d vecf = (del vecf)/(delx_1)dx_1+(del vecf)/(delx_2)dx_2`
`d vecf = sum_i (del vec f)/(del x_i) dx_i`
Ce qui se décompose selon les composantes de `vec f` :
`d f_1 = (del f_1)/(delx_1)dx_1+(del f_1)/(delx_2)dx_2`
`d f_2 = (del f_2)/(delx_1)dx_1+(del f_2)/(delx_2)dx_2`
`d f_3 = (del f_3)/(delx_1)dx_1+(del f_3)/(delx_2)dx_2`
Et qui se recompose en un produit matriciel :
`((d f_1),(df_2),(df_3)) = ( ((del f_1)/(del x_1), (del f_1)/(del x_2)), ((del f_2)/(del x_1), (del f_2)/(delx_2)), ((del f_3)/(del x_1), (del f_3)/(delx_2)) ) ((dx_1),(dx_2))`
`dvec f = f’ d vecx`
Ainsi, la dérivée de `vec f` est parfois représenté par la matrice suivante :
`f’ = ( ((del f_1)/(del x_1), (del f_1)/(del x_2)), ((del f_2)/(del x_1), (del f_2)/(delx_2)), ((del f_3)/(del x_1), (del f_3)/(delx_2)) )`
`AAiAAj, f’[i,j] = (delf_i)/(delx_j)`
Qui, appliqué à `dvecx` produit la variation de `vecf` correspondante
`dvecf = f’dvecx = sum_j (del vec f)/(delx_j)dx_j`
On utilise le nabla, `grad`, appelé aussi le gradien, c'est un vecteur mais on le note sans flèche :
`grad = ((del/(delx_1)), (del/(delx_2))) grad^"t" = (del/(delx_1), del/(delx_2))`
`f’ = grad vec f ^"t" = ( (del/(delx_1)), (del/(delx_2)) ) (f_1,f_2,f_3) = ( ((del f_1)/(del x_1), (del f_1)/(del x_2)), ((del f_2)/(del x_1), (del f_2)/(delx_2)), ((del f_3)/(del x_1), (del f_3)/(delx_2)) )`
`f’ = grad "×" vec f = ( (del/(delx_1)), (del/(delx_2)) )"×"((f_1),(f_2),(f_3))= ( ((del f_1)/(del x_1), (del f_1)/(del x_2)), ((del f_2)/(del x_1), (del f_2)/(delx_2)), ((del f_3)/(del x_1), (del f_3)/(delx_2)) )`
Il existe une autre façon de présenter la dérivée en s'affranchissant des conventions du calcul matriciel, en utilisant les vecteurs de vecteurs, et en utilisant le produit croisé noté par absence de symbole produisant un vecteur de vecteurs décrit dans cet exemple :
`((a),(b))vec x = ((avec x),(bvec x))`
`((a),(b))((x_1),(x_2)) = (( ((ax_1),(ax_2)) ),( ((bx_1),(bx_2))))`
L'expression `grad vec f` désigne un vecteur de vecteurs. Ce n'est donc pas une matrice. La variation `d vec f` s'expriment en prenant le produit scalaire généralisé :
`dvec(f)=grad vec(f)"·"d vec x`
`dvec(f)=( ((del vec f)/(delx_1)),((del vec f)/(delx_2)))"·"((dx_1),(dx_2))`
`d vecf = (del vecf)/(delx_1)dx_1+(del vecf)/(delx_2)dx_2`
La dérivée de `vec f` est représentée par le vecteur de vecteurs `grad vec(f)` au lieu de la matrice `grad^"t" vec(f)` afin de s'affranchire des conventions du produit matriciel.
L'opérateur de différentialisation `d` :
`d = del/(delx_1) dx_1 + (del )/(delx_2)dx_2`
`d = sum_i (del )/(del x_i) dx_i`
Cet opérateur peut s'exprimer en utilisant le calcul matriciel :
`d = (del/(delx),del/(dely))((dx),(dy)) = grad^"t" vec(x)`
Et il peut s'exprimer en utilisant des vecteurs de vecteurs à la place des matrices , s'affranchissant ainsi des conventions du calcul matriciel :
`d = ((del/(delx)),(del/(dely))) "·" ((dx),(dy)) = grad "·" d vec(x)`
`d^2= d(d)`
`d^2= (del/(delx_1)dx_1+del/(delx_2)dx_2)(d)`
`d^2= (del d)/(delx_1)dx_1+(del d)/(delx_2)dx_2`
`d^2= (del (del/(delx_1) dx_1 + (del )/(delx_2)dx_2))/(delx_1)dx_1+(del (del/(delx_1) dx_1 + (del )/(delx_2)dx_2))/(delx_2)dx_2`
`d^2=(del^2)/(delx_1^2)dx_1^ 2 + 2(del^2)/(delx_1 delx_2)dx_1dx_2 + (del^2)/(delx_2^2)dx_2^ 2`
`d^2 = (sum_i (del )/(del x_i) dx_i)^ 2 = sum_i sum_j (del^2)/(del x_idelx_j) dx_idx_j` `d^2 = (dx_1,dx_2)( ((del^2)/(delx_1^ 2), (del^2)/(delx_1delx_2)), ((del^2)/(delx_1delx_2), (del^2)/(delx_2^ 2)))((dx_1),(dx_2))`
`d^2 = (dx_1,dx_2) ( (del/(delx_1)), (del/(delx_2))) ( del/(delx_1), del/(delx_2)) ((dx_1),(dx_2))`
`d^2 = d vec(x)^"t" vec(grad) vec(grad)^"t"dvecx`
Le développement de Taylor de la fonction `vec(x)|->vec(f)(vecx)` s'écrit comme suit :
`vec(f)(vec(x)"+"dvec(x)) = vec f + f’ d vecx + d vec(x)^t f’’ dvec(x)`
`f’ = vec (grad)^ "t" f`
`f’’ = vec (grad)vec (grad)^ "t" f`
La dérivée première `f’` est un tenseur de dimension `3"×"2` qui s'applique à `dvecx` comme suit :
`AAiAAj, f’[i,j] = (delf_i)/(delx_j)`
`AAi, f_i’dvecx = sum_j (delf_i)/(delx_j)dx_j`
La dérivée seconde `f’’` est un tenseur de dimension `3"×"2"×"2` qui s'applique deux fois à `dvecx` comme suit :
`AAiAAjAAk, f’’[i,j,k] = (del^2f_i)/(delx_jdelx_k)`
`AAi, f_i’’dvecx dvecx = sum_j sum_k (del^2f_i)/(delx_jdelx_k)dx_jdx_k`
Il existe une autre façon de présenter la dérivée, en utilisant les vecteurs de vecteurs, le produit scalaire généralisé noté `"·"` et le produit croisé noté par absence de symbole et produisant un vecteur de vecteurs :
`d^ 2vec(f)=d(dvecf)`
`d^2vec(f)=(graddvecf)"·"d vec x`
`d^2vec(f)=(grad(gradvecf)"·" d vec x)"·" d vec x`
Le produit scalaire `"·"` s'évalue de gauche à droite et le produit croisé est prioritaire et s'évalue de droite à gauche, de telle sorte que l'équation précédente s'écrit :
`d^2vec(f)=grad grad vecf"·" d vec x"·" d vec x`
Le développement de Taylor s'écrit :
`vec(f)(vec(x)"+"dvec(x)) = vec f + gradvecf"·"d vecx + grad grad vecf"·" d vec x"·" d vec x + O(dvec x^3)`
La dérivée `n`-ième `f^("("n")")` est un tenseur de dimension `3"×"2^n`
`AAi_0AAi_1AAi_2...AAi_n, f^("("n")")[i_0,i_1,i_2,...,i_n] = (del^nf[i_0])/(delx[i_1]delx[i_2]...delx[i_n])`
Et elle s'applique `n` fois à `dvecx` comme suit :
`AAi_0, df[i_0] = f^("("n")")[i_0]dvecx dvecx ... dvecx = sum_(i_1,i_2,...,i_n)(del^nf[i_0])/(delx[i_1]delx[i_2]...delx[i_n])dx[i_1]dx[i_2]...dx[i_n]`
---- 26 juillet 2021 ----