algebreBoole.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Algèbre de Boole (partie 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### un peu d'histoire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'algèbre de Boole, ou calcul booléen, est la partie des mathématiques qui s'intéresse aux opérations et aux fonctions sur les variables logiques. Elle fut inventée par le mathématicien britannique George Boole (1815-1864).<br>\n",
    "Les opérations sont définies dans un ensemble qui ne contient que deux éléments notés 0 et 1 \\[ou Vrai en Faux en logique ; ou bien Ouvert et Fermé en électronique] <br>\n",
    "En 1938, Claude Shannon(1916 - 2001),ingénieur et mathématicien américain,  explique comment construire des machines à relais en utilisant l'algèbre de Boole pour décrire l'état des relais (1 : fermé, 0 : ouvert).<br>\n",
    "Ce sont ces états que l'on trouvait dans la machine de Turing (mathématicien et cryptologue britannique, 1912-1954) présentée par M. Raynaud (https://www.machinedeturing.org) en milieu d'année."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### une activité de logique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On dispose de trois formes en bois : un disque, un carré et un triangle. <br>\n",
    "On sait que l’une des formes est rouge, une autre bleue, et une autre jaune.<br>\n",
    "Voici trois affirmations qui concernent ces pièces :\n",
    "<ul>\n",
    "    <li>Si le carré est bleu alors le disque est jaune.</li>\n",
    "    <li>Si le carré est jaune alors le disque est rouge.</li>\n",
    "    <li>Si le disque n’est pas bleu alors le triangle est jaune.</li>\n",
    "</ul>\n",
    "Quelle est la couleur de chaque pièce ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Les opérations fondamentales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les ***fonctions booléennes*** sont des fonctions qui prennent en arguments un ou plusieurs booléens (0 ou 1) et retournent un booléen. <br>\n",
    "Comme les fonctions réelles, elles peuvent s'écrire de façon symbolique par contre elles ne peuvent pas se représenter par une courbe. <br> \n",
    "Cependant, comme les booléens sont en nombre fini, on peut étudier tous les cas possibles et ainsi représenter les résultats des fonctions booléennes dans des ***tables de vérité*** .<br>\n",
    "On va s'intéresser ici aux fonctions de base appelées aussi ***opérations fondamentales***.  \n",
    "En Python les booléens sont notés **False** et **True** mais aussi 0 et 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La négation : fonction *non*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction *non* transforme 0 en 1 et 1 en 0.<br>\n",
    "Sa table de vérité est :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "| *x* | *non*(*x*) |\n",
    "|:---:|:----------:|\n",
    "| 0 | 1|\n",
    "|1 | 0 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, la fonction se note ***not***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(not False)\n",
    "print(not True)\n",
    "print(not 0)\n",
    "print(not 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*exemple :* traduction de l'activité précédente en code Python "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de l'ensemble des cas possibles\n",
    "possibles=[\n",
    "    {\"disque\":\"rouge\", \"carré\":\"bleu\",  \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"rouge\", \"carré\":\"jaune\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"rouge\", \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"jaune\", \"triangle\":\"rouge\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"rouge\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"bleu\",  \"triangle\":\"rouge\"}\n",
    "]\n",
    "\n",
    "for cas in possibles :\n",
    "    Ok = True\n",
    "    if cas[\"carré\"] == \"bleu\" : # si le carré est bleu\n",
    "        if not cas[\"disque\"] == \"jaune\" : # mais le disque n'est pas jaune\n",
    "            Ok = False\n",
    "    if cas[\"carré\"] == \"jaune\" : # si le carré est jaune\n",
    "        if not cas[\"disque\"] == \"rouge\" :# mais le disque n'est pas rouge\n",
    "            Ok = False\n",
    "    if not cas[\"disque\"] == \"bleu\" :# si le disque n'est pas bleu\n",
    "        if not cas[\"triangle\"] == \"jaune\" :# mais le triangle n'est pas jaune\n",
    "            Ok = False\n",
    "    if Ok :\n",
    "        print(cas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remarque :* en code Python, la négation de == est !="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=3\n",
    "print(not a==2)\n",
    "print(a!=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La conjonction : fonction *et*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le booléen *x et y* est égal à 1 si et seulement si *x* est égal à 1 **et** *y* est égal à 1.  \n",
    "Sa table de vérité est :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| *x* | *y* | *et*(*x*,*y*) |\n",
    "|:---:|:---:|:----------:|\n",
    "| 0 |0|0|\n",
    "|0 | 1 |0|\n",
    "| 1 |0|0|\n",
    "|1 | 1 |1|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, la fonction se note ***and***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(False and False)\n",
    "print(False and True)\n",
    "print(True and False )\n",
    "print(True and True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*exemple :*  nouvelle traduction de l'activité précécente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de l'ensemble des cas possibles\n",
    "possibles=[\n",
    "    {\"disque\":\"rouge\", \"carré\":\"bleu\",  \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"rouge\", \"carré\":\"jaune\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"rouge\", \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"jaune\", \"triangle\":\"rouge\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"rouge\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"bleu\",  \"triangle\":\"rouge\"}\n",
    "]\n",
    "\n",
    "for cas in possibles :\n",
    "    Ok = True\n",
    "    if cas[\"carré\"] == \"bleu\" and cas[\"disque\"] != \"jaune\" : \n",
    "            Ok = False\n",
    "    if cas[\"carré\"] == \"jaune\" and cas[\"disque\"] != \"rouge\" :\n",
    "            Ok = False\n",
    "    if cas[\"disque\"] != \"bleu\" and cas[\"triangle\"] != \"jaune\" :\n",
    "            Ok = False\n",
    "    if Ok :\n",
    "        print(cas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La disjonction : fonction *ou*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le booléen *x ou y* est égal à 1 si et seulement si *x* est égal à 1 **ou** *y* est égal à 1.  \n",
    "*Remarque*  : c'est un ***ou inclusif*** c'est à dire qu'on peut avoir *x* égal à 1 ou *y* égal à 1 ou les deux égaux à 1.  \n",
    "Sa table de vérité est :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| *x* | *y* | *ou*(*x*,*y*) |\n",
    "|:---:|:---:|:----------:|\n",
    "| 0 |0|0|\n",
    "|0 | 1 |1|\n",
    "| 1 |0|1|\n",
    "|1 | 1 |1|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python, la fonction se note ***or***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(False or False)\n",
    "print(False or True)\n",
    "print(True or False )\n",
    "print(True or True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Remarque* :  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not (True or False) == (not True) and (not False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*exemple :* dernière traduction de l'activité de départ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création de l'ensemble des cas possibles\n",
    "possibles=[\n",
    "    {\"disque\":\"rouge\", \"carré\":\"bleu\",  \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"rouge\", \"carré\":\"jaune\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"rouge\", \"triangle\":\"jaune\"},\n",
    "    {\"disque\":\"bleu\",  \"carré\":\"jaune\", \"triangle\":\"rouge\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"rouge\", \"triangle\":\"bleu\"},\n",
    "    {\"disque\":\"jaune\", \"carré\":\"bleu\",  \"triangle\":\"rouge\"}\n",
    "]\n",
    "\n",
    "for cas in possibles :\n",
    "    Ok = True\n",
    "    if (cas[\"carré\"] == \"bleu\" and cas[\"disque\"] != \"jaune\") or (cas[\"carré\"] == \"jaune\" and cas[\"disque\"] != \"rouge\") or (cas[\"disque\"] != \"bleu\" and cas[\"triangle\"] != \"jaune\") :\n",
    "            Ok = False\n",
    "    if Ok :\n",
    "        print(cas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>application</u> : dresser la table de vérité de l'expression suivante <br>   **( a ou b ) et c**     \n",
    "où a, b et c sont des booléens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Les fonctions composées"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(dans le prochain notebook)"
   ]
  }
 ],
 "metadata": {
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}