¹⁵⁹ views
ubuntu2004

Kernel: SageMath 9.8

Quelques exemples d'algèbre linéaire en SAGE

In [216]:

%display latex

Vecteurs lignes et vecteurs colonnes

In [217]:

M = matrix([[1,2,3],[4,5,6]])
M

Out[217]:

Marche aussi en majuscule:

In [218]:

M = Matrix([[1,2,3],[4,5,6]])
M

Out[218]:

Par défault, SAGE formatte en convention "vecteurs ligne":

In [219]:

l=vector([1,2,3])
l

Out[219]:

In [220]:

M*l

Out[220]:

Un "vecteur colonne" est une matrice à une colonne:

In [223]:

C = matrix([[-3],[2],[-1]])
C

Out[223]:

Formellement, le produit matriciel $L\:C$ est un vecteur à une coordonnée (et oui, SAGE est une machine):

In [194]:

L*C

Out[194]:

Ce n'est pas le produit scalaire $L \cdot C = -2$ . Ce dernier est

In [224]:

(L*C)[0]

Out[224]:

Mais en fait, SAGE fait tout ça automatiquement:

In [225]:

c=vector([-3,2,-1])
c

Out[225]:

In [226]:

l.dot_product(c)

Out[226]:

Une abbreviation concise pour le produit scalaire:

In [227]:

l*c

Out[227]:

In [228]:

l*c == l.dot_product(c)

Out[228]:

SAGE reconnait si on multiplie une matrice avec un vecteur ou un vecteur avec une matrice:

In [229]:

A = matrix([[2,2,1],[0,-1,1]])
A

Out[229]:

In [230]:

u = vector([1,-1,1])
u

Out[230]:

Matrice avec vecteur:

In [231]:

A*u

Out[231]:

In [233]:

v = vector([1,-1])
v

Out[233]:

Vecteur avec matrice:

In [234]:

v*A

Out[234]:

In [235]:

Out[235]:

In [236]:

A.transpose()

Out[236]:

In [237]:

(A.transpose())*v

Out[237]:

In [238]:

B = matrix([[2,2,1],[0,-1,1],[4,7,1]])
B

Out[238]:

In [239]:

A*B

Out[239]:

In [240]:

det(B)

Out[240]:

In [241]:

B^-1

Out[241]:

In [242]:

B*B^-1

Out[242]:

In [243]:

(B^-1)*B

Out[243]:

In [245]:

identity_matrix(20)

Out[245]:

Espaces vectoriels et applis linéaires

Déclarons les "symboles" $x$ , $y$ et $z$ :

In [1]:

var('x','y','z')

Out[1]:

(x, y, z)

In [247]:

x,y,z = var('x,y,z')

In [248]:

Out[248]:

In [249]:

t = x
t

Out[249]:

In [250]:

var('toto')

Out[250]:

In [251]:

x + 1

Out[251]:

In [252]:

x+y

Out[252]:

In [253]:

x + 1 + 3

Out[253]:

In [255]:

expand((x + y)*(2*x - z))

Out[255]:

In [259]:

vector([x,y,z])

Out[259]:

Appli linéaire (convention "vecteur à droite")

Construisons l'appli linéaire $f: \mathbb{R}^3 \rightarrow \mathbb{R}^2$ donnée par $\left( \begin{matrix} x \\ y \\ z \end{matrix} \right) \mapsto \left( \begin{matrix} x - y\\ z - y \end{matrix} \right)$

In [3]:

f(x,y,z) = [x - y, z -y]
f

Out[3]:

(x, y, z) |--> (x - y, -y + z)

In [270]:

F = linear_transformation(SR^3,SR^2,f)
F

Out[270]:

In [265]:

F.matrix(side='right')

Out[265]:

SR est le "domaine de calcul symbolique" (c'est à dire on peut mixer nombres et symboles) qu'on utilise pour faire les calculs en SAGE. Mais moralement on est dans $\mathbb{R}^3$ et $\mathbb{R}^2$ , respectivement.

On peut par exemple créer des vecteurs "symboliques":

In [266]:

vector([x,y,z])

Out[266]:

In [267]:

vector([x+y,x-z,y+z])

Out[267]:

Calculons $f(x+y,x-z,y+z)$ :

In [268]:

F(vector([x+y,x-z,y+z]))

Out[268]:

Noyau

In [272]:

F.kernel()

Out[272]:

In [279]:

F.matrix('left').left_kernel()

Out[279]:

In [280]:

F.matrix('left').right_kernel()

Out[280]:

In [278]:

F.matrix('right').right_kernel()

Out[278]:

In [281]:

F.matrix('right').left_kernel()

Out[281]:

In [284]:

F.kernel().basis()

Out[284]:

In [285]:

dim(F.kernel())

Out[285]:

Base canonique

In [286]:

C3 = (SR^3).basis()
C3

Out[286]:

In [287]:

e1 = C3[0]
e2 = C3[1]
e3 = C3[2]

In [288]:

e1

Out[288]:

In [289]:

F(e1)

Out[289]:

Matrice d'appli linéaire

C'est la matrice de $f$ par rapport aux bases canoniques.

Un peu long pour l'écrire à chaque fois. Mais on peut faire une abbréviation par le biais d'une "fonction Python":

In [290]:

def mat(f):
    return f.matrix(side='right')

In [0]:

In [291]:

mat(F)

Out[291]:

In [292]:

mat(F)*e1

Out[292]:

Rang

In [293]:

F.rank()

Out[293]:

In [294]:

mat(F).rank()

Out[294]:

In [295]:

F.image()

Out[295]:

Les lignes de cette matrice sont les vecteurs de la base de $im(f)$ .

In [296]:

F.image().basis()

Out[296]:

In [297]:

dim(F.image())

Out[297]:

In [298]:

F.rank() == dim(F.image())

Out[298]:

Et oui, c'est la définition du rang...

In [299]:

dim(F.kernel()) + F.rank()

Out[299]:

In [300]:

M = mat(F)
M

Out[300]:

Garanti par le théorème du rang.

In [306]:

F1 = linear_transformation(SR^3,SR^2,M,side='right')
F1

Out[306]:

In [304]:

F == F1

Out[304]:

Composition d'applis linéaires

In [307]:

a,b=var('a,b')
g(a,b) = [a+b,-(a+b),a-b]
G = linear_transformation(SR^2,SR^3,g)
G

Out[307]:

Quand on demande à SAGE d'afficher une appli linéaire, elle donne la matrice avec la convention "à gauche" même si on a construit l'appli explicitement avec la convention "à droite". Bug?...

In [308]:

mat(G)

Out[308]:

In [309]:

h(x,y,z) = [x+z,x+y]
h

Out[309]:

In [310]:

H = linear_transformation(SR^3,SR^2,h)
H

Out[310]:

In [311]:

G*H

Out[311]:

Avec notre convention "à droite" ça donne

In [312]:

mat(G*H)

Out[312]:

In [313]:

mat(G*H) == (G*H).matrix().transpose()

Out[313]: