Séance 9

Contenu

Séance 9#

Objectifs

Expressions symboliques
Fonctions : dérivation, intégration, limites
Sommes, produits et séries

Expressions symboliques#

Avec Sagemath, on peut construire des fonctions comme des expressions symboliques. Ces expressions sont composées de valeurs (par exemple, des entiers), et de variables (au sens mathématique). Les variables pourront ensuite être substituées par des valeurs, ce qui correspond à évaluer la fonction.

Création de variables. Pour créer les variables d’une expression symbolique, on utilise le mot-clef var. La syntaxe est particulière. Pour une variable x :

var('x')

Déclaration d’une expression symbolique. On peut ensuite créer une expression symbolique en fonction de ces variables, à partir des opérateurs usuels (+, *, etc.) ou de certaines fonctions mathématiques déjà implantées dans Sagemath (exp, log, sin, etc.).

var('x')
var('y')

f = x*exp(y) - 1
print(f)
# show(f)

x*e^y - 1

Substitution. L’évaluation d’une fonction correspond à la substitution d’une variable par une valeur, dans l’expression symbolique associée. Pour effectuer cette substitution, on doit bien préciser quelle variable doit être substituée, et par quoi.

Par exemple, si l’on souhaite obtenir l’expression symbolique résultant de la substitution de \(y\) par \(0\) dans \(f\), on entre :

f(y=0)

x - 1

Notons que l’expression obtenue dépend encore de la variable \(x\).

De même :

f(x=1)

e^y - 1

On peut aussi substituer plusieurs variables simultanément :

f(x=0, y=1)

-1

Ou faire une substitution d’une variable par une autre (attention à l’ordre) :

f(y=x)

x*e^x - 1

Développement, factorisation. Certaines méthodes permettent de modifier la forme de l’expression symbolique. Par exemple, expand permet de faire une dévéloppement de toutes les formes factorisées :

f = (x+1)**3 + (x+1)*x + x**2
print(f)
print(f.expand())

(x + 1)^3 + (x + 1)*x + x^2
x^3 + 5*x^2 + 4*x + 1

À l’opposé, la méthode factor() permet de factoriser l’expression :

g = x**3 + 3*x**2 + 2*x
print(g)
print(g.factor())

x^3 + 3*x^2 + 2*x
(x + 2)*(x + 1)*x

Il existe également une méthode full_simplify() qui permet de « simplifier » des expressions, c’est-à-dire d’en réduire le nombre d’éléments, en appliquant certaines règles de calcul. Voici des exemples :

a = (sqrt(2)-1)*(sqrt(2)+1)
print(a)
a = a.full_simplify()
print(a)

(sqrt(2) + 1)*(sqrt(2) - 1)

b = sin(x)**2 + cos(x)**2
print(b)
b = b.full_simplify()
print(b)

cos(x)^2 + sin(x)^2
1

Équations et évaluation logique. Enfin, il est possible de créer des équations, en une ou plusieurs variables, sous la forme d’expressions symboliques.

equation = (x**3 == 3*x**2 - 2*x)
print(equation)

x^3 == 3*x^2 - 2*x

Ces équations peuvent ensuite être résolues, grâce à la méthode solve, qui prend pour paramètre la variable de résolution :

solutions = equation.solve(x)
print(solutions)

[
x == 1,
x == 2,
x == 0
]

On observe que les solutions retournées sont encore exprimées sous la forme d’équations. Si l’on souhaite obtenir les valeurs correspondantes, on peut utiliser les méthodes d’accès rhs() (right-hand side, partie droite de l’équation) ou lhs() (left-hand side, partie gauche).

valeurs = [ sol.rhs() for sol in solutions ]
print(valeurs)

[1, 2, 0]

Un autre exemple :

var('a')
equation = (x**2 == 2*a*x - a**2)
print(equation)

solutions = equation.solve(x)
print(solutions)

valeurs = [ sol.rhs() for sol in solutions ]
print(valeurs)

x^2 == -a^2 + 2*a*x
[
x == a
]
[a]

On peut ensuite vérifier si deux expressions symboliques sont équivalentes. Pour cela, on convertit l’expression en une valeur booléenne :

equation = (cos(2*x) == 2*cos(x)**2 - 1)
print(equation)

b = bool(equation)
print(b)

cos(2*x) == 2*cos(x)^2 - 1
True

Remarque. Il est possible de restreindre une variable à un certain domaine de définition, grâce au mot-clef assume. Cela peut être utile pour la résolution d’équations, pour la simplification, et on le verra par la suite, pour le calcul d’expressions symboliques plus générales. Donnons ici un exemple :

var('t')
f = e**t

equation = (f > 1)
b = bool(equation)
print(b)

assume(t > 0)
c = bool(equation)
print(c)

False
True

Fonctions#

Les expressions symboliques vont nous permettre de représenter certaines fonctions mathématiques, d’une ou de plusieurs variables, et de les manipuler comme telles.

Calcul élémentaire#

Opérations élémentaires. On peut ainsi appliquer des opérations usuelles sur les fonctions (addition, multiplication, … et même composition !)

var('x')
var('y')
f = x*exp(y) - 1
g = 2*x + log(x)
print(f + g)
print(f*g)
print(f/g)
print(f(y=g))

x*e^y + 2*x + log(x) - 1
(x*e^y - 1)*(2*x + log(x))
(x*e^y - 1)/(2*x + log(x))
x*e^(2*x + log(x)) - 1

Dérivation et intégration#

Dérivation. On peut vouloir dériver des fonctions par rapport à l’une de leurs variables. Pour cela, on peut utiliser la fonction diff() :

Le premier argument de diff est l’expression symbolique.
Ensuite, on ajoute la variable selon laquelle la dérivation doit être faite.
Enfin, de manière optionnelle, l’ordre de dérivation.

Avec une variable, sur la fonction \(g : x \mapsto 2x + {\rm ln}(x)\) :

g = 2*x + log(x)
g_prime = diff(g, x)
g_seconde = diff(g, x, 2)

print(g_prime)
print(g_seconde)

1/x + 2
-1/x^2

Avec 2 variables :

var('x')
var('y')
f = x*exp(y) - 1

dfx = diff(f, x)
dfy = diff(f, y)
print(dfx)
print(dfy)

e^y
x*e^y

Primitives. Pour calculer une primitive d’une fonction, on utilise la fonction integral. Comme pour diff, le premier argument est la fonction dont on veut trouver une primitive, et le second est la variable.

g = x*exp(x)
u = integral(g, x)
print(u)

(x - 1)*e^x

Intégrales. Pour calculer une intégrale, on utilise la même syntaxe en ajoutant les bornes d’intégration :

integral(sin(x), x, 0, pi)

Remarque importante. Certaines fonctions n’ont pas de primitives/intégrales connues. On vous renvoie alors l’expression symbolique associée

f = sqrt(ln(x**2))
integral(f, x)

// Giac share root-directory:/usr/share/giac/
// Giac share root-directory:/usr/share/giac/
Added 0 synonyms

integrate(sqrt(log(x^2)), x)

D’autres passent par des fonctions « spéciales » :

f = exp(-x**2)
print(f)
print(integral(f, x))
# erf?

e^(-x^2)
1/2*sqrt(pi)*erf(x)

Remarque avancée. On peut même placer une variable dans les bornes, mais il faut faire comprendre à Sagemath que cette variable ne peut pas prendre n’importe quelle valeur.

assume(y>0)
integral(cos(x), x, -y, y)

2*sin(y)

Calcul de limites#

Sagemath permet de calcul de limites. Pour cela, on peut utiliser la fonction limit. Le premier argument est l’expression symbolique. Le second est de la forme x=a, où x est la variable et a la valeur vers laquelle on souhaite tendre.

Par exemple, pour

\[ \lim_{t \to a} \frac{1}{1-t} \]

avec différentes valeurs de \(a\).

var('t')
h = 1/(1-t)

Si \(a = 0\) (point de continuité) :

limit(h, t=0)

Si \(a = 1\) (point de divergence) :

limit(h, t=1)

Infinity

On peut préciser si on veut la limite à gauche ou à droite :

print("À droite :", limit(h, t=1, dir="+"))
print("À gauche :", limit(h, t=1, dir="-"))

À droite : -Infinity
À gauche : +Infinity

Sagemath calcule enfin les limites à l’infini :

print(limit(h, t=+infinity))
print(limit(h, t=+oo))

0
0

Sommes et séries#

Sommes partielles (finies). La fonction sum() permet de sommer les éléments d’une liste :

L = [1, 8, 1/3]
print(sum(L))

28/3

Ici, on va l’uiliser pour faire des calculs symboliques. Par exemple, on peut effectuer la somme des termes d’une suite. Pour cela, on déclare une variable n et une fonction de n (ici, \(f(n) = n^2\)).

var('n')
f = n**2

Puis, si l’on souhaite calculer la somme des termes de \(f(0)\) à \(f(4)\), la syntaxe est la suivante :

somme = sum(f, n, 0, 4)
print(somme)

On note que le premier argument est l’expression symbolique à évaluer et à sommer. Le second est la variable. Puis, on donne la première et la dernière valeur que doit prendre la variable.

On peut également somme jusqu’à un entier non-déterminé représenté par une autre variable (ici \(m\)) :

var('m')
somme = sum(f, n, 0, m)
print(somme)
# show(somme)

1/3*m^3 + 1/2*m^2 + 1/6*m

Puis, en factorisant l’expression, on reconnaît la formule de sommation

\[ \sum_{n=1}^m n^2 = \frac{m(m+1)(2m+1)}{6} \]

print(factor(somme))

1/6*(2*m + 1)*(m + 1)*m

Séries. Sagemath permet également de calcul de somme infinies : les séries. Par exemple, pour la série géométrique, les sommes partielles (jusque \(m\)) sont :

var('n')
var('m')
f = 2**(-n)

somme_geo = sum(f, n, 0, m)
print(somme_geo)
# show(somme_geo)

(2^(m + 1) - 1)/2^m

Et on peut en prendre la limite :

limit(somme_geo, m=oo)

Il y a une syntaxe plus directe pour calculer cette série :

sum(f, n, 0, oo)

On peut même calculer la série dans un cadre plus général (\(x\) quelconque au lieu de \(1/2\)). Il faut simplement préciser les conditions qui permettent à la série de converger.

var('x')
assume(abs(x)<1)

f = x**n
sum(f, n, 0, +oo)

-1/(x - 1)

Affichage 3D#

Pour l’affichage 3D, il y a la fonction plot3d :

var('x y')  # ici, je déclare mes variables x et y (la syntaxe est très spéciale...)
plot3d(x**2 + y**2, [-2, 2], [-2, 2], opacity=0.8)

P = plot3d(sqrt(8*(x**2 + y**2)), [-10, 10], [-10, 10], opacity=0.5, frame=False)
Q = plot3d(x + 0.5*y + 12, [-10, 10], [-10, 10], opacity=0.5, frame=False, color="red")
P+Q

Récapitulatif des instructions à connaître#

Tableau récapitulatif des instructions à connaître pour les expressions symboliques :

Méthode, fonction, instruction	Description
`var('x')`	Crée un symbole `x` (qui peut être vu comme une variable mathématique)
`+`, `-`, ``, `/`, `*`	Opérations arithmétiques élémentaires
`f(x=4)`	Substitue `x` par `4` dans l’expression symbolique `f` (évalue \(f\) en \(4\))
`f.expand()`	Développe l’expression symbolique `f`
`f.factor()`	Factorise l’expression symbolique `f`
`f.full_simplify()`	Simplifie l’expression symbolique `f`
`f == g`	Crée l’équation correspondant à l’égalité entre les expressions `f` et `g`
`eq.solve(x)`	Résout selon `x` l’équation `eq`
`eq.rhs()` et `eq.lhs()`	Membre de droite et membre de gauche d’une équation `eq`

Tableau récapitulatif des instructions à connaître pour les fonctions (définies commes des expressions symboliques) :

Méthode, fonction, instruction	Description
`diff(f, x, n)`	Fonction `f` dérivée `n` fois selon la variable `x`
`integral(f, x)`	Primitive de `f` selon la variable `x`
`integral(f, x, a, b)`	Intégrale entre `a` et `b` de `f` selon la variable `x` : \(\int_a^b f(x)dx\)
`limit(f, x=a)`	Limite de `f` lorsque `x` tend vers `a`
`limit(f, x=a, dir="+")`	Limite de `f` lorsque `x` tend vers `a` par valeurs supérieures (`dir="-"` pour les valeurs inférieures)
`infinity` ou `oo`	Symbole infini
`sum(L)`	Somme des termes d’une liste
`sum(f, n, a, b)`	Calcul de \(\sum_{n=a}^b f(n)\)