1. Description du module sympy.logic
Le module sympy.logic de SymPy est utilisé pour travailler avec la logique symbolique, notamment pour créer et manipuler des expressions booléennes, simplifier des expressions logiques, évaluer des formules booléennes, etc.
Le module sympy.logic de SymPy offre de nombreuses fonctionnalités pour travailler avec la logique symbolique. Voici une liste des principales possibilités offertes par sympy.logic :
- Opérateurs logiques : Le module sympy.logic fournit des opérateurs logiques tels que And, Or, Not, Implies, Equivalent, etc., pour créer des expressions logiques complexes.
- Simplification logique : Vous pouvez simplifier des expressions logiques en utilisant la fonction simplify_logic.
- Évaluation de vérité : Vous pouvez évaluer des expressions logiques en substituant des valeurs de vérité aux symboles à l'aide de la méthode subs.
- Tables de vérité : Vous pouvez générer des tables de véTruthTable.
- Résolution d'équations logiques : Le module propose une fonction solve_logic pour résoudre des équations logiques, c'est-à-dire trouver les valeurs de vérité qui satisfont une expression logique donnée.
- Manipulation de formules CNF et DNF : Vous pouvez convertir des expressions logiques en formes normales conjonctives (CNF) ou disjonctives (DNF) en utilisant les fonctions to_cnf et to_dnf.
- Simplification de clauses : Vous pouvez simplifier des clauses logiques en utilisant la fonction simplify_logic_clauses.
- Création de diagrammes de Karnaugh : Bien que le module sympy.logic ne prenne pas en charge la création de diagrammes de Karnaugh directement, vous pouvez extraire des termes simplifiés à partir d'une expression logique et les utiliser pour créer manuellement un diagramme de Karnaugh.
- Conversion vers des expressions LaTeX : Vous pouvez convertir des expressions logiques en code LaTeX pour les intégrer dans des documents.
- Manipulation avancée de logique symbolique : sympy.logic prend en charge la manipulation avancée de logique symbolique, y compris la substitution conditionnelle, la simplification conditionnelle, etc.
2. Création de variables booléennes
Créer une variable booléenne
Pour créer une variable booléenne, vous pouvez utiliser la fonction symbols et spécifier bool=True comme suit :
|
1 2 3 |
from sympy import symbols # Créer une variable booléenne nommée 'A' A = symbols('A', bool=True) |
Explication:
- symbols('A', bool=True) : La fonction symbols est utilisée pour créer un objet symbolique, dans ce cas, nommé "A".
- L'argument bool=True : spécifie que "A" doit être une variable booléenne, c'est-à-dire qu'elle ne peut prendre que deux valeurs : True (vrai) ou False (faux).
Accéder à la valeur de la variable booléenne
Vous pouvez accéder à la valeur de la variable booléenne en utilisant la fonction de substitution de sympy subs() en spécifiant la valeur de vérité que vous souhaitez pour la variable :
|
1 2 3 |
# Affecter la valeur True à la variable booléenne A valeur_de_verite = True resultat = A.subs({A: valeur_de_verite}) |
Exemple complet
|
1 2 3 4 5 6 7 8 9 10 11 |
import sympy as sp # Créer une variable booléenne nommée 'A' A = sp.symbols('A', bool=True) # Affecter la valeur True à la variable booléenne A valeur_de_verite = True resultat = A.subs({A: valeur_de_verite}) # Afficher le résultat print(resultat) #Affiche: True |
3. Opérations sur les variables booléenne avec sympy.logic
Afin de pouvoir combiner entre les variables booléennes, sympy.logic nous offre des opérateurs logique spécifiques: And, Or et Not qui peuvent être utilisés pour créer des expressions logiques en combinant des propositions logiques. Voici une description de chacun de ces opérateurs :
- And (ET) : L'opérateur And permet de créer une expression logique qui est vraie (True) si toutes les propositions logiques données sont vraies.
- Or (OU) : L'opérateur Or permet de créer une expression logique qui est vraie (True) si au moins l'une des propositions logiques données est vraie.
- Not (NON) : L'opérateur Not permet de créer une expression logique qui est vraie (True) si la proposition logique donnée est fausse, et vice versa.
3.1 Syntaxe ( Conjonction Et (And))
|
1 2 |
from sympy.logic.boolalg import And expression_et = And(proposition1, proposition2, ...) |
Exemple (Conjonction Et ( And)
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sympy import symbols from sympy.logic.boolalg import And A, B = symbols('A B', bool=True) # attribuer des valeurs à A et B A = A.subs({A: True}) B = B.subs({B: False}) expression_et = And(A, B) # L'expression est vraie si A et B sont vraies. print(expression_et) # Affiche: False |
3.2 Syntaxe de la disjonction OU ( Or)
|
1 2 |
from sympy.logic.boolalg import Or expression_ou = Or(proposition1, proposition2, ...) |
Exemple ( disjonction OU ( Or) )
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from sympy import symbols from sympy.logic.boolalg import Or A, B = symbols('A B' , bool=True) # attribuer des valeurs à A et B A = A.subs({A: True}) B = B.subs({B: False}) expression_ou = Or(A, B) # L'expression est vraie si l'une des variable A ou B est vraie. print(expression_ou) # Affiche: True |
3.2 Syntaxe de la négation Non ( Not)
|
1 2 |
from sympy.logic.boolalg import Not expression_non = Not(proposition) |
Exemple ( Négation Non (Not))
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from sympy import symbols from sympy.logic.boolalg import Not A, B = symbols('A B' , bool=True) # attribuer des valeurs à A et B A = A.subs({A: True}) B = B.subs({B: False}) expression_Not_A = Not(A) expression_Not_B = Not(B) # L'expression est vraie si l'une des variable A ou B est vraie. print(expression_Not_A) # Affiche: False print(expression_Not_B) # Affiche: True |
4. Opérateur implication
4.1 Rappel mathématique
Définition
L'implication logique mathématique est une opération binaire entre deux proposition mathématiques A et B ( variables booléennes A et B) définie par : (Not A) Or B , notée A ⇒ B à lire "A implique B" qui est fausse seulement si la proposition A est vraie et la proposition B est fausse (on dit que le vraie n'implique jamais le faux). L'implication est vraie dans tous les autres cas.
Voici la table de vérité d'une implication :
| A | B | A ⇒ B | |
| Valeur | True | True | True |
| Valeur | False | False | True |
| Valeur | False | True | True |
| Valeur | True | False | False |
Syntaxe
|
1 2 3 4 5 |
# création de symboles A, B = sp.symbols('A B', bool=True) # Création de l'implication: A ⇒ B implication = Implies(A, B) |
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import sympy as sp from sympy.logic import Implies # Définir des symboles A, B, C= sp.symbols('A B C', bool=True) # Attribution des valeurs booléennes A = A.subs({A: True}) B = B.subs({B: True}) C = C.subs({C: False}) print("A ⇒ B : " , Implies(A, B)) # A ⇒ B : True print("A ⇒ C : " , Implies(A, C)) # A ⇒ C : False |
5. Table de vérité d'une expression logique
Pour générer la table de vérité d'une expression logique, sympy.logic nous offre la fonction truth_table()
Exemple (Table de vérité de la conjonction Et (And))
|
1 2 3 4 5 6 7 8 9 10 11 |
from sympy import symbols from sympy.logic.boolalg import truth_table , And A, B = symbols('A B', bool=True) expr = And(A, B) table = truth_table(expr, [A, B]) # Afficher la table de vérité print(list(table)) # output: [([0, 0], False), ([0, 1], False), ([1, 0], False), ([1, 1], True)] |
Exemple (table de vérité d'une implication)
|
1 2 3 4 5 6 7 8 9 |
from sympy.logic.boolalg import truth_table , Implies , Not from sympy import symbols A, B = symbols('A B', bool=True) expr = Implies(A , B) table = truth_table(expr, [A, B]) print(list(table)) # output: [([0, 0], True), ([0, 1], True), ([1, 0], False), ([1, 1], True)] |
6. Simplification d'une expression logique
Le module sympy.logic nous offre aussi la possibilité de simplifier les expressions logiques qui est une opération exremement utile lors des calculs compliqués des prédicats. A cet effet sympy.logic nous offre la fonction spécifique simplify_logic()
Exemple
|
1 2 3 4 5 6 7 8 9 |
from sympy import symbols from sympy.logic.boolalg import And, Or, Not, Implies, Equivalent, simplify_logic A, B, C = symbols('A B C', bool=True) #expression = Or(And(A, B), And(Not(A), Not(B))) expression = And(Or(A , B) , Not(B)) simplified_expr = simplify_logic(expression) print(simplified_expr) # output : A & ~B |
Younes Derfoufi
CRMEF OUJDA
