Chapitre 5 : Les booléens.

Introduction :

L'origine des booléens se trouve en 1847. Georges Boole propose une algèbre basé sur deux élements, 0 et 1 (ou vrai et faux).

Les booléens en informatique sont un type de donnée simple qui peut prendre deux valeurs : vrai ou faux.

Ils sont essentiels pour contrôler la logique et les flux de décision dans les programmes.

Les opérations entre valeurs booléennes sont souvent représentées à l'aide de tables de vérité, qui montrent les résultats de combinaisons comme ET, OU et NON pour toutes les entrées possibles.

1. Définition:

A copier dans le cahier.

Un booléen n'a que deux valeurs possibles : VRAI(True) ou FAUX(False).

Il peut être associé aux nombres 0 et 1.

2. Définition:

Dans l'algèbre de Boole, il y a trois opérations fondamentales :

"ou" (aussi appelé disjonction). On la note aussi \(+\) ou | ou \(\vee\);
"et" (aussi appelé conjonction). On la note aussi \( \times \) ou & ou \(\wedge\);
"non" (aussi appelé negation). On la note aussi \(-\) ou ~ ou \(\neg\).

Ce sont des fonctions que l'on appelle "fonction logique".

3. Tables de vérité:

On peut résumer une fonction logique à l'aide d'une table de vérité.

Il faut énumérer toutes les possibilités d'entrées et regarder les sorties possibles.

4. Exercice :

A faire dans le cahier.

Compléter les tables de vérité suivantes:

La fonction "ou"
\(x\)	\(y\)	\(x \text{ or } y\)
F	F
F	V
V	F
V	V

La fonction "et"
\(x\)	\(y\)	\(x \text{ and } y\)
F	F
F	V
V	F
V	V

La fonction "non"
\(x\)	\( not(x) \)
F
V

5. Exercice :

A faire dans le cahier.

Compléter la table de vérité suivante

\(x\)	\(y\)	\(z\)
F	F	F
F	F	V
F	V	F
F	V	V
V	F	F
V	F	V
V	V	F
V	V	V

6. Exercice :

A faire dans le cahier.

Compléter la table de vérité suivante

\(x\)	\(y\)	\(z\)
F	F	F
F	F	V
F	V	F
F	V	V
V	F	F
V	F	V
V	V	F
V	V	V

7. Exercice : Simplification logique

À faire dans le cahier.

On considère le programme suivant :

def test_bool(a,b,c):
    return not(a) or ((b and c) or a)

Simplifier l'écriture de ce code à l'aide d'une table de vérité.

Écrire ensuite une fonction simplifie qui doit toujours renvoyer le même booléen que test_bool aurait renvoyé pour les mêmes arguments a, b, c.

def simplifie(a,b,c): return ...

Tests :

Affichage :

Console:

>>>

8. OU exclusif :

A faire dans le cahier.

Etablir la table de vérité de l'expression (x and not(y)) or (not(x) and y ).

Cette fonction est appelé "xor" ou "ou exclusif" .

9. Distributivité :

A faire dans le cahier.

On veut savoir si la distributivité marche avec les booléens.

Soit \(a\), \(b\) et \(c\) des booléens

Etablir la table de vérité de \(a \times (b+c) \).
Etablir la table de vérité de \(a \times b + a \times c \).
Conclure si l'égalité \(a \times (b+c) = a \times b + a \times c \) est vraie ou non.

10. Exercice :

A faire dans le cahier.

Que valent les expressions suivantes?

```
(3 > 2) or (7 == 9)
```
```
not (3 > 12)
```
```
(3 > 2) and (7 == 9)
```
```
not ( (12 > 3) and (8 == 4 + 4))
```
```
(5 <= 5) and (10 != 2 * 5)
```
```
not (7 < 3) or (4 >= 4)
```
```
(2 + 3 == 5) and not (6 < 2)
```
```
not( (10 > 1) or (3 == 8) )
```
```
(4 != 4) or ( (3 < 9) and (2 >= 1) )
```
```
(7 >= 7) and not(5 > 10)
```
```
not( (2 == 2) and (3 != 3) )
```
```
(1 < 0) or not(4 <= 4)
```
```
(8 > 3) and (2 < 1 or 5 == 5)
```

not( (9 < 2) or (3 >= 1 and 6 == 3 * 2) )

```
(0 == 0) or (1 == 2 and not(3 < 7))
```
```
not( not(5 > 2) )
```
```
(4 + 1 > 2 * 3) or (10 / 2 == 5)
```
```
(3**2 == 9) and not(8 % 2 != 0)
```
```
not( (1 != 1) or (2 == 2 and 3 < 1) )
```
```
(7 > 1) and ( (2 > 9) or not(4 < 2) )
```