- À propos des hypothèses dans SymPy
- Définir un symbole positif avec positive=True
- Définir un symbole réel avec real=True
- Définir un symbole entier avec integer=True
- Tester les propriétés d'un symbole
- Comprendre les déductions automatiques de SymPy
- Utiliser les hypothèses pour simplifier des expressions
- Définir plusieurs symboles avec les mêmes hypothèses
- Combiner plusieurs hypothèses
- À retenir !
1. À propos des hypothèses dans SymPy
Lorsque nous créons une variable symbolique avec SymPy, nous pouvons préciser certaines de ses propriétés mathématiques. Ces informations sont appelées des hypothèses.
Par défaut, SymPy ne suppose généralement pas qu'un symbole est positif, réel ou entier. Lorsque ces informations sont importantes, nous pouvons les indiquer au moment de la création du symbole.
Parmi les hypothèses les plus courantes, nous trouvons :
- positive=True : le symbole est strictement positif ;
- real=True : le symbole est réel ;
- integer=True : le symbole est entier.
Le programme suivant crée un symbole x sans aucune hypothèse particulière puis interroge SymPy sur quelques-unes de ses propriétés.
1 2 3 4 5 6 | from sympy import Symbol x = Symbol("x") print(x.is_positive) print(x.is_real) print(x.is_integer) |
Sortie :
1 2 3 | None None None |
La valeur None signifie ici que SymPy ne dispose pas d'informations suffisantes pour répondre par True ou False. Elle ne signifie donc pas que la propriété est fausse.
2. Définir un symbole positif avec positive=True
L'hypothèse positive=True indique à SymPy que le symbole représente une quantité strictement positive.
Le programme suivant crée un symbole x supposé positif.
1 2 3 4 5 6 | from sympy import Symbol x = Symbol("x", positive=True) print(x) print(x.is_positive) |
Sortie :
1 2 | x True |
SymPy sait maintenant que x > 0. Cette information peut être utilisée automatiquement lors de certaines simplifications et déductions.
Une quantité strictement positive est également non nulle et réelle. SymPy peut donc déduire ces propriétés.
1 2 3 4 5 6 7 | from sympy import Symbol x = Symbol("x", positive=True) print("Positif :", x.is_positive) print("Réel :", x.is_real) print("Non nul :", x.is_nonzero) |
Sortie :
1 2 3 | Positif : True Réel : True Non nul : True |
3. Définir un symbole réel avec real=True
L'hypothèse real=True permet d'indiquer qu'un symbole appartient à l'ensemble des nombres réels.
Le programme suivant crée un symbole réel x.
1 2 3 4 5 6 | from sympy import Symbol x = Symbol("x", real=True) print(x.is_real) print(x.is_complex) |
Sortie :
1 2 | True True |
Tout nombre réel étant également un nombre complexe dont la partie imaginaire est nulle, SymPy déduit que x.is_complex est également vrai.
En revanche, savoir que x est réel ne permet pas de savoir s'il est positif ou négatif.
1 2 3 4 5 6 7 | from sympy import Symbol x = Symbol("x", real=True) print("Réel :", x.is_real) print("Positif :", x.is_positive) print("Négatif :", x.is_negative) |
Sortie :
1 2 3 | Réel : True Positif : None Négatif : None |
Le symbole peut être positif, négatif ou nul. SymPy ne possède donc pas assez d'informations pour déterminer son signe.
4. Définir un symbole entier avec integer=True
L'hypothèse integer=True indique qu'un symbole représente un nombre entier.
Le programme suivant crée le symbole entier n.
1 2 3 4 5 6 | from sympy import Symbol n = Symbol("n", integer=True) print(n.is_integer) print(n.is_real) |
Sortie :
1 2 | True True |
SymPy sait qu'un entier est également un nombre réel. Il peut donc déduire automatiquement la seconde propriété.
En revanche, l'hypothèse integer=True ne précise pas si l'entier est positif, négatif ou nul.
1 2 3 4 5 6 7 | from sympy import Symbol n = Symbol("n", integer=True) print("Entier :", n.is_integer) print("Positif :", n.is_positive) print("Négatif :", n.is_negative) |
Sortie :
1 2 3 | Entier : True Positif : None Négatif : None |
5. Tester les propriétés d'un symbole
SymPy fournit de nombreux attributs commençant par is_ permettant d'interroger les propriétés mathématiques d'un objet symbolique.
Parmi les plus courants, nous pouvons citer is_positive, is_negative, is_real, is_integer, is_nonzero, is_even et is_odd.
Le programme suivant crée un entier positif puis examine plusieurs de ses propriétés.
1 2 3 4 5 6 7 8 9 | from sympy import Symbol n = Symbol("n", integer=True, positive=True) print("Entier :", n.is_integer) print("Positif :", n.is_positive) print("Réel :", n.is_real) print("Non nul :", n.is_nonzero) print("Pair :", n.is_even) |
Sortie :
1 2 3 4 5 | Entier : True Positif : True Réel : True Non nul : True Pair : None |
Même si n est un entier positif, SymPy ne peut pas savoir s'il est pair ou impair. La propriété is_even retourne donc None.
Les résultats de ces tests doivent ainsi être interprétés selon trois possibilités : True, False ou None.
6. Comprendre les déductions automatiques de SymPy
Le système d'hypothèses de SymPy est capable de déduire certaines propriétés à partir des informations fournies. Il n'est donc pas nécessaire de préciser toutes les propriétés d'un symbole.
Le programme suivant crée un symbole entier positif. SymPy peut en déduire plusieurs autres propriétés.
1 2 3 4 5 6 7 8 9 | from sympy import Symbol n = Symbol("n", integer=True, positive=True) print("Entier :", n.is_integer) print("Rationnel :", n.is_rational) print("Réel :", n.is_real) print("Complexe :", n.is_complex) print("Non nul :", n.is_nonzero) |
Sortie :
1 2 3 4 5 | Entier : True Rationnel : True Réel : True Complexe : True Non nul : True |
Ces résultats correspondent aux inclusions mathématiques classiques : un entier est rationnel, un rationnel est réel et un réel est complexe.
De même, lorsqu'un symbole est déclaré positif, SymPy sait automatiquement qu'il n'est pas négatif.
1 2 3 4 5 6 7 | from sympy import Symbol x = Symbol("x", positive=True) print(x.is_positive) print(x.is_negative) print(x.is_zero) |
Sortie :
1 2 3 | True False False |
7. Utiliser les hypothèses pour simplifier des expressions
Les hypothèses peuvent modifier la manière dont SymPy simplifie certaines expressions. Une information sur le signe ou la nature d'un symbole permet parfois d'obtenir un résultat plus précis.
Par exemple, pour un nombre réel quelconque x, la racine carrée de x² est égale à la valeur absolue de x. Le programme suivant illustre cette propriété.
1 2 3 4 5 6 | from sympy import Symbol, sqrt x = Symbol("x", real=True) expression = sqrt(x**2) print(expression) |
Sortie :
1 | Abs(x) |
SymPy ne peut pas remplacer sqrt(x**2) par x, car un nombre réel peut être négatif. Il retourne donc Abs(x).
Si nous indiquons que x est positif, SymPy peut simplifier davantage l'expression.
1 2 3 4 5 6 | from sympy import Symbol, sqrt x = Symbol("x", positive=True) expression = sqrt(x**2) print(expression) |
Sortie :
1 | x |
Comme SymPy sait maintenant que x > 0, il peut conclure que |x| = x. Les hypothèses peuvent donc avoir une influence directe sur les transformations symboliques.
8. Définir plusieurs symboles avec les mêmes hypothèses
La fonction symbols() permet de créer plusieurs variables symboliques en leur attribuant simultanément les mêmes hypothèses.
Le programme suivant crée trois variables réelles x, y et z.
1 2 3 4 5 6 7 | from sympy import symbols x, y, z = symbols("x y z", real=True) print(x.is_real) print(y.is_real) print(z.is_real) |
Sortie :
1 2 3 | True True True |
De la même manière, nous pouvons créer plusieurs entiers positifs en une seule instruction.
1 2 3 4 5 6 7 | from sympy import symbols m, n, p = symbols("m n p", integer=True, positive=True) print(m.is_integer, m.is_positive) print(n.is_integer, n.is_positive) print(p.is_integer, p.is_positive) |
Sortie :
1 2 3 | True True True True True True |
Tous les symboles créés par cet appel à symbols() reçoivent ici les mêmes hypothèses.
9. Combiner plusieurs hypothèses
Plusieurs hypothèses peuvent être fournies lors de la création d'un symbole lorsque nous avons besoin de préciser davantage son domaine mathématique.
Le programme suivant crée un symbole n qui représente un entier strictement positif.
1 2 3 4 5 6 7 | from sympy import Symbol n = Symbol("n", integer=True, positive=True) print("Entier :", n.is_integer) print("Positif :", n.is_positive) print("Réel :", n.is_real) |
Sortie :
1 2 3 | Entier : True Positif : True Réel : True |
Il n'est pas nécessaire d'ajouter real=True, puisque SymPy sait déjà qu'un entier est réel.
Nous pouvons également créer deux symboles appartenant à des domaines différents et observer l'effet de leurs hypothèses sur une expression.
1 2 3 4 5 6 7 8 | from sympy import symbols, sqrt x = symbols("x", positive=True) n = symbols("n", integer=True) print(sqrt(x**2)) print(n.is_integer) print(n.is_real) |
Sortie :
1 2 3 | x True True |
Il est préférable de fournir uniquement les hypothèses réellement utiles. SymPy se charge ensuite de nombreuses déductions logiques entre les différentes propriétés.
10. À retenir !
Le système d'hypothèses SymPy permet de fournir des informations mathématiques sur les symboles afin d'améliorer les déductions et certaines simplifications symboliques.
- positive=True indique qu'un symbole est strictement positif.
- real=True indique qu'un symbole appartient aux nombres réels.
- integer=True indique qu'un symbole représente un nombre entier.
- Les hypothèses sont généralement précisées lors de la création du symbole.
- is_positive, is_real et is_integer permettent d'interroger les propriétés d'un symbole.
- Une propriété peut retourner True, False ou None.
- None signifie que SymPy ne dispose pas d'informations suffisantes pour décider.
- SymPy peut déduire automatiquement certaines propriétés à partir des hypothèses fournies.
- Les hypothèses peuvent modifier le résultat de certaines simplifications symboliques.
- La fonction symbols() permet d'attribuer les mêmes hypothèses à plusieurs symboles simultanément.
Le programme suivant rassemble les principales notions étudiées en créant trois symboles ayant des propriétés différentes.
1 2 3 4 5 6 7 8 9 10 11 12 13 | from sympy import symbols, sqrt x = symbols("x", positive=True) y = symbols("y", real=True) n = symbols("n", integer=True) print("x positif :", x.is_positive) print("x réel :", x.is_real) print("sqrt(x**2) =", sqrt(x**2)) print("y réel :", y.is_real) print("y positif :", y.is_positive) print("n entier :", n.is_integer) print("n réel :", n.is_real) |
Sortie :
1 2 3 4 5 6 7 | x positif : True x réel : True sqrt(x**2) = x y réel : True y positif : None n entier : True n réel : True |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
