Ajout première séquence

representation_base/seance_4/PYTHON.md

@@ -0,0 +1,163 @@
+# Type Booléen en Python
+
+## Valeur et Type
+
+En Python, les booléens sont `True` et `False`, ils sont du type `bool`
+
+```python
+>>> True
+True
+>>> print(type(True))
+<class 'bool'>
+>>> False
+False
+>>> print(type(False))
+<class 'bool'>
+```
+
+## Comparaison
+
+Les opérateurs de comparaison courants sont identiques à ceux des mathématiques mais ATTENTION, il ne faut pas confondre l’égalité et l’affectation
+
+Python
+
+```python
+>>> variable = 5    # une affectation
+>>> 5 == 8          # une égalité (qui est fausse)
+False
+```
+
+**Le résultat d’une comparaison est toujours un booléen**
+
+## Comparaisons des nombres
+
+| Comparaison       | Symbole | Exemple       | Résultat |
+| ----------------- | ------- | ------------- | -------- |
+| Égalité           | `==`    | `1 + 2 == 3`  | `True`   |
+| Différence        | `!=`    | `1 + 2 != 3`  | `False`  |
+| Supérieur         | `>`     | `4 > 3`       | `True`   |
+| Inférieur         | `<`     | `2.2 < 2 * 3` | `True`   |
+| Supérieur ou égal | `>=`    | `5 >= 6`      | `False`  |
+| Inférieur ou égal | `<=`    | `8 <= 3`      | `False`  |
+
+## Appartenance à une structure
+
+On peut tester qu’un élément appartient à une structure avec le mot clé `in`
+
+```python
+>>> "a"		in "bonjour"        # False
+False
+>>> "bon"	in "bonjour"        # True
+True
+>>> 1     in [2, 3, 4]        # False
+False
+```
+
+# Opérations sur les booléens
+
+Les opérateurs sur les booléens sont de deux types :
+
+- opérateur unaire : prend *un* booléen et en renvoie *un*.
+- opérateur binaire : prend *deux* booléens et en renvoie *un*.
+
+## Opérateur unaire : la négation
+
+### La négation: `not`
+
+C’est le seul opérateur *unaire*, il donne le contraire de ce qu’on lui passe.
+
+```python
+>>> not True    # s'évalue à False
+False
+>>> not False   # s'évalue à True
+True
+```
+
+## Opérateur binaire : le OU, noté `or`
+
+**Il est vrai si l’un des deux booléens est vrai.**
+
+```python
+>>> False or False
+False
+>>> False or True
+True
+>>> True or False
+True
+>>> True or True
+True
+```
+
+## Opérateur binaire : le ET, noté `and`
+
+**Il est vrai si les deux booléens sont vrais.**
+
+```python
+>>> False and False
+False
+>>> False and True
+False
+>>> True and False
+False
+>>> True and True
+True
+```
+
+## Opérateur binaire : le XOR noté `^`
+
+**Il est vrai si EXACTEMENT un des deux booléens est vrai**
+
+```python
+>>> False ^ False
+False
+>>> False ^ True
+True
+>>> True ^ False
+True
+>>> True ^ True
+False
+```
+
+## Python et les booléens
+
+Python permet de comparer n’importe quoi à un booleen.
+
+Par exemple, une chaîne de caractère vide est évaluée à `False`.`
+
+```python
+>>> bool(1)
+True
+>>> bool(0)
+False
+>>> bool("")
+False
+>>> bool("abc")
+True
+>>> bool([])
+False
+>>> bool([1, 2])
+True
+```
+
+- 0 est faux, les autres entiers sont vrais,
+- une structure vide est fausse, les autres sont vraies.
+
+## Complément : `None` et l’identité `is`
+
+Python propose la valeur `None` (rien) qui est fréquement utilisé pour représenter l’absence d’une valeur.
+
+Étant le seul objet du type `NoneType`, on peut tester son *identité* avec `is` :
+
+```python
+>>> 1 is None
+False
+>>> "abc" is None
+False
+>>> None is None
+True
+>>> a = 5
+>>> a is None
+False
+```
+
+On verra plus tard qu’une _fonction_  qui ne se termine par `return ...` renvoie néanmoins `None`.

representation_base/seance_4/README.md

@@ -0,0 +1,243 @@
+# Codage des booléens
+
+## Attendus
+
+| Contenus | Capacités attendues |
+| :--: | :-- |
+| Valeurs booléennes : 0,1. Opérateurs booléens : and, or, not.<br />Expressions booléennes | Dresser la table d’une expression booléenne | 
+
+## Définition
+
+De nombreux dispositifs électroniques, électromécanique, (mécanique, électrique, pneumatique, etc....) fonctionnement en TOUT ou RIEN.
+
+Ceci sous-entend qu'ils peuvent prendre 2 états. 
+
+Exemples : 
+
+- Arrêt / Marche
+- Enclenché / Déclenché
+- Vrai / Faux
+- Ouvert / Fermé
+- Avant / Arrière
+- Conduction / Blocage
+
+Un système présentera un fonctionnement __logique combinatoire__ si l'état à un instant $`t`$ des variables de sortie ne dépend que de l'état des variables d'entrée au même instant $`t`$.
+
+## Variable logique
+
+Une variable logique ne peut prendre que 2 états:
+
+| État Vrai | État Faux |
+| :--: | :--: |
+| Oui | Non |
+| True | False |
+| 1 | 0 |
+| Haut | Bas |
+| High | Low |
+
+Pour ces raisons, il est beaucoup plus avantageux d'employer un système mathématique n'utilisant que 2 valeurs numériques.
+
+Par convention, on utilise les valeurs 0 / 1 pour représenter les états d'une variable logique.
+
+La variable binaire est aussi appelée variable __booléenne__. (De George Boole, mathématicien anglais 1815 - 1864)
+
+## Fonction logique
+
+Une fonction $`S`$ (exemple: allumer une lampe) peut comporter $`n`$ variables logiques.
+Pour chacune de ces combinaisons, la fonction peut prendre une valeur 0 ou 1.
+Nous obtenons $`2^n`$ combinaisons pour ces $`n`$ variables.
+
+### Table de vérité
+
+On représente l'ensemble valeurs d'entrées et sorties par une table de vérité :
+
+- À chaque variable d'entrée correspond une colonne, 
+- À chaque ligne, une valeur d'état possible,
+- Une colonne de sortie contient la valeur de l'état de l'opération.
+
+Exemple : 
+
+```math
+\begin{aligned}
+S = 1 \text{ si} \left\{
+\begin{array}{l}
+ a = 0 \text{ et } b = 1 \\
+ a = 0 \text{ et } b = 0 \\
+ a = 1 \text{ et } b = 0
+ \end{array}
+\right.
+\end{aligned}
+```
+
+| $`a`$ | $`b`$ | $`S`$ |
+| :--: | :--: | :--: |
+| 0 | 1 | 1 |
+| 0 | 0 | 1 |
+| 1 | 1 | 0 |
+| 1 | 1 | 0 |
+| 1 | 0 | 1 |
+
+### Opérateurs logiques
+
+#### Opérateur NON
+
+On associe à une variable binaire quelconque $`a`$ son complément, noté $`\overline{a}`$
+
+```math
+\begin{aligned}
+S = 1 \text{ ssi } a = 0
+\end{aligned}
+```
+
+La table de vérité de l'opérateur NON :
+
+| $`a`$ | $`S = \overline{a}`$ |
+| :--: | :--: |
+| 0 | 1 |
+| 1 | 0 |
+
+#### Opérateur ET
+
+L'état 1 est obtenu lors de l’action simultanée sur les 2 variables $`a`$ et $`b`$. L'opérateur est noté $`\land`$
+
+```math
+\begin{aligned}
+S & = 1 \text{ ssi } a = 1 \text{ et } b = 1 \\
+ & = a \land b
+\end{aligned}
+```
+
+La table de vérité de l'opérateur ET :
+
+| $`a`$ | $`b`$ | $`S = a \land b`$ |
+| :--: | :--: | :--: |
+| 0 | 0 | 0 | 
+| 0 | 1 | 0 |
+| 1 | 0 | 0 |
+| 1 | 1 | 1 |
+
+##### Propriétés
+
+```math
+\begin{aligned}
+ a \land a & = a \\
+ a \land 1 & = a \\
+ a \land \overline{a} & = 0 \\
+ a \land 0 & = 0
+\end{aligned}
+```
+
+#### Opérateur OU
+
+L'état 1 est obtenu lors de l’action simultanée sur l'une des 2 variables ou les 2. L'opérateur est noté $`\lor`$
+
+```math
+\begin{aligned}
+S = 1 \text{ si} \left\{
+\begin{array}{l}
+ a = 0 \text{ ou } b = 1 \\
+ a = 1 \text{ ou } b = 0 \\
+ a = 1 \text{ ou } b = 1
+ \end{array}
+\right.
+\end{aligned}
+```
+
+La table de vérité de l'opérateur OU :
+
+| $`a`$ | $`b`$ | $`S = a \lor b`$ |
+| :--: | :--: | :--: |
+| 0 | 0 | 0 | 
+| 0 | 1 | 1 |
+| 1 | 0 | 1 |
+| 1 | 1 | 1 |
+
+##### Propriétés
+
+```math
+\begin{aligned}
+ a \lor a & = a \\
+ a \lor 1 & = 1 \\
+ a \lor \overline{a} & = 1 \\
+ a \lor 0 & = a
+\end{aligned}
+```
+
+### Algèbre de Boole 
+
+#### Définition
+
+Système algébrique constitué de l'ensemble $`\{0, 1\}`$, muni des 3 opérateurs de base NON, ET, OU.
+
+#### Propriétés
+
+- __Associativité__ : Comme avec les opérations habituelles, certaines parenthèses sont inutiles. Exemple : $`( a \land b ) \land c = a \land (b \land c) = a \land b \land c`$
+- __Commutativité__ : L'ordre est sans importance. Exemple : $`a \land b = b \land a`$
+- __Distributivité__ : Exemple : $`a \lor ( b \land c ) = ( a \lor b ) \land ( a \lor c )`$
+- __Idempotence__ : Exemple : $`a \land a \land a \land \dots \land a = a`$
+
+### Forme canonique
+
+Combinaison des variables de la fonction via les opérateurs de base de l’__algèbre de Boole__.
+
+La fonction $`S`$ définie par :
+
+```math
+\begin{aligned}
+S = 1 \text{ si} \left\{
+\begin{array}{l}
+ a = 0 \text{ et } b = 1 \\
+ a = 0 \text{ et } b = 0 \\
+ a = 1 \text{ et } b = 0
+ \end{array}
+\right.
+\end{aligned}
+```
+
+$`S`$ s'écrit sous sa forme canonique : $`S= (\overline{a} \land b) \lor (\overline{a} \land \overline{b}) \lor (a \land \overline{b})`$
+
+### 
+
+## Exercices
+
+### Établir des tables de vérité
+
+**Travail à effectuer** : Écrire les tables de vérité des expressions booléennes suivantes :
+
+1. $`S(a, b) = \overline{a} \land b`$
+2. $`S(a, b) = b \lor (a \land b)`$
+3. $`S(a, b) = a \land (a \lor b)`$
+4. $`S(a, b, c) = (\overline{a} \land b) \lor (a \land c)`$
+5. Communication = Émetteur ET Récepteur
+6. Décrocher = (Sonnerie ET Décision de répondre) OU décision d'appeler
+7. Bac = Avoir la moyenne OU (NON Avoir la moyenne ET rattrapage)
+
+### Équivalence d'expressions booléennes
+
+1. Montrer que $`(a \land b) = \overline{\overline{a} \lor \overline{b}}`$
+2. Montrer que $`(a \lor b) = \overline{\overline{a} \land \overline{b}}`$
+
+N.B : Deux expressions booléennes sont équivalentes si leurs tables de vérité le sont. 
+
+Autrement dit, si pour toutes les entrées des tables de vérité, l'ensemble des valeurs de sorties de ces mêmes tables sont équivalentes alors les expressions booléennes sont équivalentes.
+
+### Déterminer une expression booléenne
+
+| a | b | ssi(a, b) |
+| :--: | :--: | :--: |
+| 0 | 0 | __1__ |
+| 0 | 1 | __0__ |
+| 1 | 0 | __0__ |
+| 1 | 1 | __1__ |
+
+**Travail à effectuer** : Trouver l'expression booléenne, notée ssi(a, b) à partir de la table de vérité ci-dessus.
+
+### Loi de De Morgan
+
+Les __lois de De Morgan__ sont des identités entre propositions logiques. Elles ont été formulées par le mathématicien britannique Augustus De Morgan (1806-1871).
+
+1. $`\overline{(a \lor b)} = \overline{a} \land \overline{b}`$
+2. $`\overline{(a \land b)} = \overline{a} \lor \overline{b}`$
+
+**Travail à effectuer** : Démontrer ces 2 lois.
+

representation_base/seance_4/exercices/README.md

@@ -0,0 +1,42 @@
+# TD : Logique combinatoire
+
+## Algèbre de Boole
+
+Q1. Simplifier les équations suivantes à l'aide des théorèmes de l'algèbre de Boole : 
+
+1. $`S = (\overline{a} \lor b) \land (a \lor b)`$
+2. $`S = \overline{a} \land b \land \overline{c} \lor \overline{a} \land b \land c \lor a \land b \land \overline{c} \lor a \land b \land c`$
+3. $`S = a \land b \land c \lor b \land c \lor b \land \overline{b}`$
+4. $`S = (a \lor \overline{a} \land b) \land \overline{( a \lor b )} \lor b \land \overline{c} \lor b \land c`$
+
+## Logigrammes
+
+Q2. Établir les logigrammes réalisant les équations suivantes : 
+
+5. $`S = a \lor b \land \overline{c}`$​
+6. $`S = \overline{(\overline{a} \land b \lor c) \land \overline{d}}`$
+7. $`S = a \land (\overline{b} \lor c)`$
+
+Q3. Établir l'équation des sorties S3 et S4 du logigramme suivant :
+
+![Logigramme](./assets/exercice_2_q3.svg)
+
+Q4. Établir la table de vérité de S3 et de S4 en fonction de l'état des variables d'entrée :
+
+Q5. Compléter le chronogramme de la sortie S3 ci-dessous :
+
+![Logigramme](./assets/exercice_2_q5.svg)
+
+## Étude du fonctionnement d'une perçeuse
+
+On considère une perceuse actionnée par un moteur $`M`$. Le moteur ne peut tourner que si l’interrupteur $`C`$ est actionné et si toutes les conditions de sécurité suivantes sont respectées :
+
+- La protection de sécurité $`P`$ est en place
+- Le courant de surcharge $`I`$ n’est pas dépassé
+
+Outre ces conditions normales de fonctionnement, une clé $`K`$ permet de faire tourner le moteur sans aucune condition de sécurité.
+
+Q6. En supposant que chaque variable $`C, P, I`$ et $`K`$ vaut 1 lorsque la condition de fonctionnement est respectée, donner la table de vérité du moteur $`M`$.
+
+Q7. Donner l’équation et le logigramme.
+

representation_base/seance_4/exercices/README_2.md

@@ -0,0 +1,74 @@
+# TD : Logique combinatoire
+
+## Exercice 1
+
+Q1. En utilisant les propriétés de l’algèbre de Boole, simplifier les équations logiques suivantes :
+
+1. $`S = a \land(a \lor \overline{b})`$
+2. $`S = (\overline{a} \lor b) \land (\overline{a} \lor \overline{b})`$
+3. $`S = a \lor (\overline{a} \land \overline{b})`$
+4. $`S = a \land (\overline{a} \lor b)`$
+
+## Exercice 2
+
+Q2. Faire le logigramme des fonctions suivantes en utilisant que des portes logiques à 2 entrées :
+
+1. $`S = a\land b \lor \overline{b} \land c`$
+2. $`S = \overline{(a \lor b) \land c}`$
+3. $`S = \overline{(a \lor \overline{b}) \land (d \lor \overline{c})}`$​
+
+## Exercice 3
+
+Q3. Pour le logigramme suivant, donner l’équation logique de la sortie $`S`$​​ en fonction des entrées $`a, b`$ et $`c`$​​​ :
+
+![Logigramme](./assets/exercice_3.svg)
+
+Q4. Simplifier l’équation logique $`S`$.
+
+Q5. Dessiner le nouveau logigramme simplifié de l’équation logique $`S`$.
+
+## Exercice 4
+
+Q6. Pour le logigramme suivant, donner l’équation logique de la sortie $`T`$ en fonction des entrées $`a, b, c`$ et $`d`$ :
+
+Q7. Simplifier l’équation logique $`T`$.
+
+Q8 : Dessiner le nouveau logigramme simplifié de l’équation logique $`T`$.
+
+## Exercice 5
+
+Q9. À partir de la table de vérité ci-dessous, déterminer l’équation logique $`S`$.
+
+| $`a`$ | $`b`$ | $`c`$ | $`S`$ |
+| :--: | :--: | :--: | :--: |
+| 0 | 0 | 0 | __1__ |
+| 0 | 0 | 1 | __1__ |
+| 0 | 1 | 0 | __1__ |
+| 0 | 1 | 1 | __0__ |
+| 1 | 0 | 0 | __0__ |
+| 1 | 0 | 1 | __0__ |
+| 1 | 1 | 0 | __1__ |
+| 1 | 1 | 1 | __0__ |
+
+Q10. Simplifier l'équation logique $`S`$
+
+Q11. Compléter les chronogrammes ci-dessous.
+
+![Logigramme](./assets/exercice_5.svg)
+
+## Exercice 6
+
+Un parking souterrain est géré grâce à un gardien et à partir de capteurs de détection de véhicules.
+Un capteur $`p`$ dans le sol détectera la présence d'un véhicule à l'entrée du parking ($`p = 1`$).
+Un capteur $`h`$ en hauteur détectera la présence d'un véhicule de plus de 2 mètres ($`h = 1`$). Pour une hauteur supérieure à 2 mètres l'entrée dans le parking est interdite.
+De plus, le gardien du parking aura la possibilité de fermer un contact $`g`$ ($` g = 1`$) si le parking est plein, pour ne pas autoriser l'entrée de véhicules supplémentaires.
+L'autorisation de pénétrer sera visualisée sur un feu bicolore :
+
+- Si le feu est vert la barrière s'ouvrira et le véhicule pourra
+- Si le feu est rouge la barrière restera fermée
+
+Q12. Donnez la table de vérité du système. Pour les combinaisons matériellement impossibles, le feu rouge restera allumé.
+
+Q13. En déduire les équations Logiques de "Vert" et "Rouge". 
+
+Q14. Réalisez le schéma à l’aide de portes logiques

representation_base/seance_4/tp/README.md

@@ -0,0 +1,109 @@
+# Mystère
+
+## Description
+
+L'idée de ce TP est de manipuler les expressions booléennes.
+
+Pour cela, vous allez devoir programmer des fonctions booléennes.
+
+A chaque fonction `mystere` suivante, sont données des doctests.
+Ces doctests correspondent aux valeurs des tables de vérités.
+
+## Consignes
+
+Recopier le bloc de code suivant dans un fichier `mystere.py`
+
+Vous devez écrire le corps de la fonction sous la forme d'une expression booléenne, dont les variables correspondent aux paramètres d'entrée fournis.
+
+```python
+def mystere1(a):
+    '''
+        >>> mystere1(True)
+        False
+        >>> mystere1(False)
+        True
+    '''
+    pass
+
+def mystere2(a, b):
+    '''
+        >>> mystere2(True, True)
+        True
+        >>> mystere2(True, False)
+        True
+        >>> mystere2(False, True)
+        True
+        >>> mystere2(False, False)
+        False
+    '''
+    pass
+
+def mystere3(a, b):
+    '''
+        >>> mystere3(True, True)
+        False
+        >>> mystere3(True, False)
+        True
+        >>> mystere3(False, True)
+        True
+        >>> mystere3(False, False)
+        False
+    '''
+    pass
+
+def mystere4(a, b):
+    '''
+        >>> mystere4(True, True)
+        False
+        >>> mystere4(True, False)
+        False
+        >>> mystere4(False, True)
+        False
+        >>> mystere4(False, False)
+        True
+    '''
+    pass
+
+def mystere5(a, b):
+    '''
+        >>> mystere5(True, True)
+        True
+        >>> mystere5(True, False)
+        False
+        >>> mystere5(False, True)
+        False
+        >>> mystere5(False, False)
+        True
+    '''
+    pass
+
+def mystere6(a, b):
+    '''
+        >>> mystere6(True, True)
+        False
+        >>> mystere6(True, False)
+        True
+        >>> mystere6(False, True)
+        False
+        >>> mystere6(False, False)
+        False
+    '''
+    pass
+
+def mystere7(a, b):
+    '''
+        >>> mystere7(True, True)
+        False
+        >>> mystere7(True, False)
+        True
+        >>> mystere7(False, True)
+        False
+        >>> mystere7(False, False)
+        True
+    '''
+    pass
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod(verbose=False)
+```