{"cells":[{"metadata":{},"cell_type":"markdown","source":"![En tête general](https://raw.githubusercontent.com/PythonLycee/PyLyc/master/img/En_tete_general.png)\n\n\n© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.
\nLes activités partagées sur Capytale sont sous licence Creative Commons.\n\n Pour exécuter une saisie Python, sélectionner la cellule et valider avec SHIFT+Entrée.\n"},{"metadata":{},"cell_type":"markdown","source":"

\n Portes logiques et expressions booléennes (corrigé)\n

\n Activité sur les booléens n°1 \n

"},{"metadata":{},"cell_type":"markdown","source":"### Sommaire\n\n1. Portes logiques et booléens
\n2. Circuits combinatoires
\n3. Complément : un outil
\n"},{"metadata":{},"cell_type":"markdown","source":"

\n1. Portes logiques et booléens "},{"metadata":{},"cell_type":"markdown","source":"Le codage d'une information ou sa circulation se font à l'aide de courant électrique.
Deux tensions sont possibles : 1 (haute) et 0 (basse), qui correspondent respectivement aux valeurs booléennes True et False.

\nUne porte logique reçoit un ou plusieurs signaux en entrée et renvoie un signal en sortie selon une règle préétablie.
\n\n\n \n \n

Portes logiques élémentaires
Nom Porte \"et\"Porte \"ou\"Porte \"non\"
Représentation\n
RègleLa porte \"et\" renvoie True en sortie si et seulement si les deux entrées valent True.La porte \"ou\" renvoie True en sortie si et seulement si au moins une des deux entrées vaut True.La porte \"non\" renvoie True en sortie si et seulement si l'entrée vaut False.
Syntaxe Pythonandornot
"},{"metadata":{},"cell_type":"markdown","source":"1.1. Dresser la table de vérité d'une porte logique consiste à recenser les valeurs obtenues en sortie en fonction des valeurs reçues en entrée.
\n$\\quad\\;\\;$Recopier et compléter la table de vérité de la porte logique \"et\" ci-dessous :\n\n
Porte logique \"et\"
e1e2s
00
01
10
11
"},{"metadata":{},"cell_type":"markdown","source":"1.2. Exécuter la cellule Python suivante, puis modifier/compléter pour vérifier l'ensemble de la table de vérité réalisée en 1.1."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Exécuter/modifier cette cellule\n\ne1 = True\ne2 = True\n\ns = e1 and e2\n\ns","execution_count":1,"outputs":[{"output_type":"execute_result","execution_count":1,"data":{"text/plain":"True"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"[ ((e1,e2),e1 and e2) for e1 in [False,True] for e2 in [False,True] ]","execution_count":2,"outputs":[{"output_type":"execute_result","execution_count":2,"data":{"text/plain":"[((False, False), False), ((False, True), False), ((True, False), False), ((True, True), True)]"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"1.3. Dresser et compléter les tables de vérité des portes logiques \"ou\" et \"non\".\n"},{"metadata":{},"cell_type":"markdown","source":"1.4. Effectuer des saisies Python pour vérifier ces tables de vérité."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Effectuer ici les saisies Python\n\n#TABLE OU\n[ ((e1,e2),e1 or e2) for e1 in [False,True] for e2 in [False,True] ]","execution_count":3,"outputs":[{"output_type":"execute_result","execution_count":3,"data":{"text/plain":"[((False, False), False), ((False, True), True), ((True, False), True), ((True, True), True)]"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"#TABLE NON\n[ (e1, not e1 ) for e1 in [False,True] ]","execution_count":4,"outputs":[{"output_type":"execute_result","execution_count":4,"data":{"text/plain":"[(False, True), (True, False)]"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"

\n2. Circuits combinatoires"},{"metadata":{},"cell_type":"markdown","source":"Les circuits combinatoires sont construits à partir de portes logiques élémentaires, qui sont en quelque sorte les briques élémentaires ces circuits.
"},{"metadata":{},"cell_type":"markdown","source":"2.1. On considère le circuit combinatoire noté Circuit1, donné ci-dessous. Dresser sa table de vérité.
\n$\\quad\\;\\;$(on peut inclure des colonnes pour indiquer des valeurs intermédiaires)\n\n\n"},{"metadata":{},"cell_type":"markdown","source":"2.2. Écrire une fonction Python Circuit1, qui :\n\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Écrire ici la fonction Circuit1\n\ndef Circuit1(e1,e2):\n return not e1 and e2","execution_count":5,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"2.3. La fonction Python Table_verite donnée ci-dessous renvoie la table de vérité d'un circuit combinatoire donné par une fonction Python.
\n$\\quad\\;\\;$Exécuter les cellules suivantes pour vérifier les résultats de la question 2.1."},{"metadata":{"trusted":true},"cell_type":"code","source":"from itertools import product\nfrom inspect import signature\n\ndef Table_verite(fonction_booleenne):\n \"\"\"\n renvoie la table d'une fonction booléenne sous forme d'un dictionnaire\n À chaque tuple des valeurs booléennes en entrée est associé la(les) sortie(s) correspondante(s)\n \"\"\"\n #récupération du nombre d'arguments de la fonction booleenne\n nbre_arguments = len (signature(fonction_booleenne).parameters) \n \n #initialisation de la table\n Table={}\n \n #remplissage de la table : à chaque séquence de booléens possible...\n for liste_bool in product( *([[False,True] for j in range(nbre_arguments)] )):\n #...on fait correspondre le résultat de la fonction booléenne\n Table[liste_bool] = fonction_booleenne(*liste_bool)\n \n #renvoie la table\n return Table\n","execution_count":6,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Exécuter cet appel à la fonction Table_verite\nTable_verite(Circuit1)","execution_count":7,"outputs":[{"output_type":"execute_result","execution_count":7,"data":{"text/plain":"{(False, False): False, (False, True): True, (True, False): False, (True, True): False}"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"2.4. Pour chacun des circuits combinatoires donnés ci-dessous:\n\n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Utiliser ces zones Python pour définir les fonctions et effectuer les appels à Table_verite\ndef Circuit2(e1,e2):\n return not (e1 or e2)\n\nTable_verite(Circuit2)","execution_count":8,"outputs":[{"output_type":"execute_result","execution_count":8,"data":{"text/plain":"{(False, False): True, (False, True): False, (True, False): False, (True, True): False}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def Circuit3(e1):\n return not not e1\n\nTable_verite(Circuit3)","execution_count":9,"outputs":[{"output_type":"execute_result","execution_count":9,"data":{"text/plain":"{(False,): False, (True,): True}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def Circuit4(e1,e2):\n return not e1 or e2\n\nTable_verite(Circuit4)","execution_count":10,"outputs":[{"output_type":"execute_result","execution_count":10,"data":{"text/plain":"{(False, False): True, (False, True): True, (True, False): False, (True, True): True}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def Circuit5(e1,e2,e3):\n return e1 or e2 , e2 and e3\n\nTable_verite(Circuit5)","execution_count":11,"outputs":[{"output_type":"execute_result","execution_count":11,"data":{"text/plain":"{(False, False, False): (False, False), (False, False, True): (False, False), (False, True, False): (True, False), (False, True, True): (True, True), (True, False, False): (True, False), (True, False, True): (True, False), (True, True, False): (True, False), (True, True, True): (True, True)}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def Circuit6(e1,e2,e3):\n return (e1 or e2) and e3\n\nTable_verite(Circuit6)","execution_count":12,"outputs":[{"output_type":"execute_result","execution_count":12,"data":{"text/plain":"{(False, False, False): False, (False, False, True): False, (False, True, False): False, (False, True, True): True, (True, False, False): False, (True, False, True): True, (True, True, False): False, (True, True, True): True}"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"2.5. On considère le circuit combinatoire ci-dessous :\n\n\n\n\n$\\quad\\;\\;$a. Dresser sa table de vérité. Vérifier à l'aide de saisies Python.
\n$\\quad\\;\\;$b. À quelle porte logique ce circuit correspond-t-il ?
\n$\\quad\\;\\;$c. Proposer un circuit combinatoire qui réalise la fonction \"ou\" en utilisant uniquement des portes logiques élémentaires \"et\" et \"non\".
\n \n"},{"metadata":{"trusted":true},"cell_type":"code","source":"#Utiliser cette cellule pour la vérification de la question 2.5.a\n\n\n# On retrouve la porte ET\n\ndef Circuit7(e1,e2):\n return not (not e1 or not e2)\n\nTable_verite(Circuit7)","execution_count":19,"outputs":[{"output_type":"execute_result","execution_count":19,"data":{"text/plain":"{(False, False): False, (False, True): False, (True, False): False, (True, True): True}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Cette fonction réalise le OU\n\ndef Circuit8(e1,e2):\n return not (not e1 and not e2)\n\nTable_verite(Circuit8)","execution_count":20,"outputs":[{"output_type":"execute_result","execution_count":20,"data":{"text/plain":"{(False, False): False, (False, True): True, (True, False): True, (True, True): True}"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"2.6. On considère la porte \" x-ou \" (\"x-or\" , \"ou exclusif\") décrite ci-dessous :\n
\n
Nom Porte \"x-ou\"
Représentation
RègleLa porte \"x-ou\" renvoie True si et seulement si une et une seule de ses entrées vaut True
Syntaxe Python^
\n

\n\n$\\quad\\;\\;$a. Dresser la table de vérité de cette porte \" x-ou \".
\n$\\quad\\;\\;$b. Proposer une construction de cette porte logique uniquement à l'aide de portes \"et\", \"ou\" et \"non\".
\n$\\quad\\;\\;$c. La syntaxe Python $\\;$^$\\;$ permet de réaliser ce test logique entre deux booléens.
\n$\\quad\\quad\\;$ Retrouver les résultats de la question 2.6.a à l'aide de saisies Python.
\n\n "},{"metadata":{"trusted":true},"cell_type":"code","source":"#Cette fonction réalise le xor\n\ndef xor(e1,e2):\n return (e1 and not e2) or (not e1 and e2) # alternative : (e1 or e2) and not (e1 and e2)\n\nTable_verite(xor)","execution_count":21,"outputs":[{"output_type":"execute_result","execution_count":21,"data":{"text/plain":"{(False, False): False, (False, True): True, (True, False): True, (True, True): False}"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Utiliser cette cellule pour la question 2.6.c\n\ndef xor_bis(e1,e2):\n return e1^e2\n\nTable_verite(xor_bis)","execution_count":22,"outputs":[{"output_type":"execute_result","execution_count":22,"data":{"text/plain":"{(False, False): False, (False, True): True, (True, False): True, (True, True): False}"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"![George_Boole](https://raw.githubusercontent.com/PythonLycee/PyLyc/master/img/Boole.jpg) \n\n
George Boole (1815-1864) est à l'origine de l'algèbre binaire, dite booléenne, n'acceptant que deux valeurs : 0 et 1.
"},{"metadata":{},"cell_type":"markdown","source":"

\n3. Complément : un outil"},{"metadata":{},"cell_type":"markdown","source":"Dresser directement la table de vérité d'une expression sous forme str.

\nLa fonction Table_description donnée ci-dessous permet d'obtenir la table de vérité d'une expression booléenne donnée directement sous forme de chaîne de caractère. Un exemple d'utilisation est fourni.
\nAttention : Pour éviter les bugs à la conversion, utiliser de préférence des variables nommées e1,e2,...\n "},{"metadata":{"trusted":true},"cell_type":"code","source":"from itertools import product\n\ndef Table_description(liste_variables,operation_booleenne):\n \"\"\"\n Fonction qui renvoie la table de vérité sous forme d'un dictionnaire \n liste_variables = [\"e1\",\"e2\",...] liste des noms de variables utilisés\n operation_booleene = \"chaine de caractère (str) décrivant l'opération booléenne considérée\"\n \"\"\"\n try:\n #remplacement dans la chaîne de caractère des noms de variable par la syntaxe qui donnera la valeur de la variable\n for k in range(len(liste_variables)):\n operation_booleenne = operation_booleenne.replace(liste_variables[k],\"valeur_var[\"+str(k)+\"]\")\n\n #initialisation de la table\n Table={}\n\n #remplissage de la table : à chaque liste de booléens possible...\n for valeur_var in product( *([[False,True] for j in range(len(liste_variables))] )):\n \n #...on fait correspondre le résultat de la fonction booléenne\n Table[valeur_var] = eval( operation_booleenne ) \n \n #renvoie la table\n return Table\n \n except:\n return \"saisie invalide\"\n","execution_count":17,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Exemple : Les variables se nomment e1,e2,e3 et l'expression évaluée est (e1 or e2) and e3\n\nTable_description( [\"e1\",\"e2\",\"e3\"] , \"(e1 or e2) and e3\" )","execution_count":18,"outputs":[{"output_type":"execute_result","execution_count":18,"data":{"text/plain":"{(False, False, False): False, (False, False, True): False, (False, True, False): False, (False, True, True): True, (True, False, False): False, (True, False, True): True, (True, True, False): False, (True, True, True): True}"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.
\nLes activités partagées sur Capytale sont sous licence Creative Commons.\n"}],"metadata":{"celltoolbar":"Raw Cell Format","kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.10"}},"nbformat":4,"nbformat_minor":2}