{
  "chapter": {
    "id": "logique-booleenne",
    "level": "premiere",
    "theme": "Représentation des données",
    "title": "Logique booléenne et fonctions logiques",
    "description": "Opérateurs logiques (ET, OU, NON, XOR, NAND), tables de vérité,\npropriétés algébriques de l'algèbre de Boole, lois de De Morgan,\nsimplification d'expressions et lien avec la programmation Python.",
    "parties": [
      {
        "id": "operateurs",
        "title": "Opérateurs et expressions"
      },
      {
        "id": "tables",
        "title": "Tables de vérité"
      },
      {
        "id": "proprietes",
        "title": "Propriétés et simplification"
      }
    ],
    "prerequisites": [],
    "references": []
  },
  "questions": [
    {
      "id": "q01",
      "difficulty": 1,
      "skills": [
        "definition"
      ],
      "title": "Comportement de l'opérateur OU",
      "partie": "operateurs",
      "statement": "Quelle est la valeur de sortie d'un opérateur OU inclusif ($a + b$)\nsi l'entrée $a$ vaut $1$ et l'entrée $b$ vaut $1$ ?",
      "options": [
        {
          "text": "La sortie vaut $2$",
          "correct": false,
          "feedback": "Erreur : confusion avec une addition arithmétique. La logique\nbooléenne ne manipule que les valeurs $0$ et $1$, jamais $2$.\n"
        },
        {
          "text": "La sortie vaut $0$",
          "correct": false,
          "feedback": "Erreur : confusion avec le OU exclusif (XOR), qui vaut $0$\nlorsque les deux entrées sont identiques. Avec le OU inclusif,\ndès qu'au moins une entrée vaut $1$, la sortie vaut $1$.\n"
        },
        {
          "text": "La sortie est indéterminée",
          "correct": false,
          "feedback": "Erreur : la sortie d'une fonction logique est toujours\ndéterminée par sa table de vérité, sans ambiguïté.\n"
        },
        {
          "text": "La sortie vaut $1$",
          "correct": true,
          "feedback": "Bonne réponse : le OU inclusif renvoie $1$ dès qu'au moins\nune entrée vaut $1$. Sa table de vérité ne contient un $0$\nque pour la combinaison $(0, 0)$.\n"
        }
      ],
      "explanation": "Le OU inclusif est défini par la table de vérité :\n$(0,0)\\to 0$, $(0,1)\\to 1$, $(1,0)\\to 1$, $(1,1)\\to 1$.\nIl s'oppose au OU exclusif (XOR) qui renvoie $0$ pour $(1,1)$."
    },
    {
      "id": "q02",
      "difficulty": 1,
      "skills": [
        "table-verite",
        "denombrement"
      ],
      "title": "Structure des tables de vérité",
      "partie": "tables",
      "statement": "Combien de lignes comporte la table de vérité d'une fonction\nlogique possédant $4$ variables d'entrée ?",
      "options": [
        {
          "text": "Elle comporte $12$ lignes",
          "correct": false,
          "feedback": "Erreur : confusion avec $4 \\times 3$ (produit) au lieu de\n$2^{4}$ (puissance). Le bon raisonnement est combinatoire :\nchaque variable peut prendre $2$ valeurs indépendamment.\n"
        },
        {
          "text": "Elle comporte $16$ lignes",
          "correct": true,
          "feedback": "Bonne réponse : $2^{4} = 16$ combinaisons possibles pour\nquatre variables binaires.\n"
        },
        {
          "text": "Elle comporte $8$ lignes",
          "correct": false,
          "feedback": "Erreur : c'est le nombre de lignes pour $3$ variables ($2^{3}$).\nAvec $4$ variables, il faut calculer $2^{4}$.\n"
        },
        {
          "text": "Elle comporte $4$ lignes",
          "correct": false,
          "feedback": "Erreur : confusion entre le nombre de variables et le nombre\nde combinaisons. Avec $n$ variables, on a $2^n$ combinaisons,\npas $n$.\n"
        }
      ],
      "explanation": "Avec $n$ variables booléennes, chacune peut valoir $0$ ou $1$\nindépendamment des autres, donc la table de vérité contient\n$2^n$ lignes. Pour $n = 4$, on obtient $2^{4} = 16$.",
      "variants": [
        {
          "statement": "Combien de lignes comporte la table de vérité d'une fonction\nlogique possédant $4$ variables d'entrée ?",
          "options": [
            {
              "text": "Elle comporte $12$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion avec $4 \\times 3$ (produit) au lieu de\n$2^{4}$ (puissance). Le bon raisonnement est combinatoire :\nchaque variable peut prendre $2$ valeurs indépendamment.\n"
            },
            {
              "text": "Elle comporte $16$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : $2^{4} = 16$ combinaisons possibles pour\nquatre variables binaires.\n"
            },
            {
              "text": "Elle comporte $8$ lignes",
              "correct": false,
              "feedback": "Erreur : c'est le nombre de lignes pour $3$ variables ($2^{3}$).\nAvec $4$ variables, il faut calculer $2^{4}$.\n"
            },
            {
              "text": "Elle comporte $4$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion entre le nombre de variables et le nombre\nde combinaisons. Avec $n$ variables, on a $2^n$ combinaisons,\npas $n$.\n"
            }
          ],
          "explanation": "Avec $n$ variables booléennes, chacune peut valoir $0$ ou $1$\nindépendamment des autres, donc la table de vérité contient\n$2^n$ lignes. Pour $n = 4$, on obtient $2^{4} = 16$."
        },
        {
          "statement": "Combien de lignes comporte la table de vérité d'une fonction\nlogique possédant $3$ variables d'entrée ?",
          "options": [
            {
              "text": "Elle comporte $9$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion avec $3 \\times 3$ (produit) au lieu de\n$2^{3}$ (puissance). Le bon raisonnement est combinatoire :\nchaque variable peut prendre $2$ valeurs indépendamment.\n"
            },
            {
              "text": "Elle comporte $8$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : $2^{3} = 8$ combinaisons possibles pour\ntrois variables binaires.\n"
            },
            {
              "text": "Elle comporte $4$ lignes",
              "correct": false,
              "feedback": "Erreur : c'est le nombre de lignes pour $2$ variables ($2^{2}$).\nAvec $3$ variables, il faut calculer $2^{3}$.\n"
            },
            {
              "text": "Elle comporte $3$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion entre le nombre de variables et le nombre\nde combinaisons. Avec $n$ variables, on a $2^n$ combinaisons,\npas $n$.\n"
            }
          ],
          "explanation": "Avec $n$ variables booléennes, chacune peut valoir $0$ ou $1$\nindépendamment des autres, donc la table de vérité contient\n$2^n$ lignes. Pour $n = 3$, on obtient $2^{3} = 8$."
        },
        {
          "statement": "Combien de lignes comporte la table de vérité d'une fonction\nlogique possédant $5$ variables d'entrée ?",
          "options": [
            {
              "text": "Elle comporte $15$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion avec $5 \\times 3$ (produit) au lieu de\n$2^{5}$ (puissance). Le bon raisonnement est combinatoire :\nchaque variable peut prendre $2$ valeurs indépendamment.\n"
            },
            {
              "text": "Elle comporte $32$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : $2^{5} = 32$ combinaisons possibles pour\ncinq variables binaires.\n"
            },
            {
              "text": "Elle comporte $16$ lignes",
              "correct": false,
              "feedback": "Erreur : c'est le nombre de lignes pour $4$ variables ($2^{4}$).\nAvec $5$ variables, il faut calculer $2^{5}$.\n"
            },
            {
              "text": "Elle comporte $5$ lignes",
              "correct": false,
              "feedback": "Erreur : confusion entre le nombre de variables et le nombre\nde combinaisons. Avec $n$ variables, on a $2^n$ combinaisons,\npas $n$.\n"
            }
          ],
          "explanation": "Avec $n$ variables booléennes, chacune peut valoir $0$ ou $1$\nindépendamment des autres, donc la table de vérité contient\n$2^n$ lignes. Pour $n = 5$, on obtient $2^{5} = 32$."
        }
      ]
    },
    {
      "id": "q03",
      "difficulty": 1,
      "skills": [
        "python",
        "syntaxe"
      ],
      "title": "Syntaxe de programmation",
      "partie": "operateurs",
      "statement": "Quel mot-clé Python correspond à l'opérateur de négation\nlogique (NON) ?",
      "options": [
        {
          "text": "Le mot-clé `inv`",
          "correct": false,
          "feedback": "Erreur : `inv` n'existe pas en Python comme mot-clé de négation.\n"
        },
        {
          "text": "Le mot-clé `not`",
          "correct": true,
          "feedback": "Bonne réponse : Python utilise les mots-clés en toutes\nlettres : `not`, `and` et `or`.\n"
        },
        {
          "text": "Le mot-clé `negative`",
          "correct": false,
          "feedback": "Erreur : `negative` n'est pas un mot-clé Python.\nLe mot-clé est `not`.\n"
        },
        {
          "text": "Le symbole `!`",
          "correct": false,
          "feedback": "Erreur : c'est la syntaxe du C, du C++, de Java ou de\nJavaScript, pas celle de Python.\n"
        }
      ],
      "explanation": "Python privilégie une syntaxe en mots anglais lisibles : `not`,\n`and` et `or`."
    },
    {
      "id": "q04",
      "difficulty": 1,
      "skills": [
        "propriete"
      ],
      "title": "Étude de l'élément absorbant",
      "partie": "proprietes",
      "statement": "D'après les propriétés du ET logique ($\\cdot$), que vaut\nsystématiquement l'expression $a \\cdot 0$ ?",
      "options": [
        {
          "text": "Elle vaut $a$",
          "correct": false,
          "feedback": "Erreur : confusion avec l'élément neutre. C'est $a \\cdot 1$\nqui vaut $a$ ; avec $0$ comme second opérande, le résultat\nest forcément $0$ (élément absorbant).\n"
        },
        {
          "text": "Elle vaut $0$",
          "correct": true,
          "feedback": "Bonne réponse : $0$ est l'élément absorbant du ET logique.\nQuelle que soit la valeur de $a$, le produit $a \\cdot 0$ vaut $0$.\n"
        },
        {
          "text": "Elle vaut $\\overline{a}$",
          "correct": false,
          "feedback": "Erreur : il n'y a aucune négation dans l'expression. Le ET\navec $0$ donne toujours $0$, pas le complémentaire de $a$.\n"
        },
        {
          "text": "Elle vaut $1$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec le OU logique. Pour le ET,\nla sortie ne vaut $1$ que si toutes les entrées valent $1$.\n"
        }
      ],
      "explanation": "Dans l'algèbre de Boole, $0$ est l'élément absorbant du ET et\nl'élément neutre du OU. Symétriquement, $1$ est l'élément\nneutre du ET et l'élément absorbant du OU."
    },
    {
      "id": "q05",
      "difficulty": 2,
      "skills": [
        "propriete",
        "identification"
      ],
      "title": "Principes fondamentaux",
      "partie": "proprietes",
      "statement": "Laquelle de ces égalités exprime qu'une variable booléenne $a$ et sa\nnégation $\\overline{a}$ ne peuvent jamais être **fausses** en même\ntemps ?",
      "options": [
        {
          "text": "$a \\cdot 1 = a$",
          "correct": false,
          "feedback": "Erreur : $a \\cdot 1 = a$ dit que $1$ est l'élément neutre du ET.\nElle ne fait pas intervenir $\\overline{a}$.\n"
        },
        {
          "text": "$\\overline{\\overline{a}} = a$",
          "correct": false,
          "feedback": "Erreur : $\\overline{\\overline{a}} = a$ dit que nier deux fois\nredonne la valeur de départ. Elle ne compare pas $a$ et\n$\\overline{a}$.\n"
        },
        {
          "text": "$a \\cdot \\overline{a} = 0$",
          "correct": false,
          "feedback": "Erreur : $a \\cdot \\overline{a} = 0$ exprime que $a$ et\n$\\overline{a}$ ne peuvent pas être **vraies** en même temps, et non\nqu'elles ne peuvent pas être fausses ensemble.\n"
        },
        {
          "text": "$a + \\overline{a} = 1$",
          "correct": true,
          "feedback": "Bonne réponse : $a + \\overline{a}$ ne vaudrait $0$ que si $a$ et\n$\\overline{a}$ valaient toutes deux $0$, ce qui est impossible. Le\nOU vaut donc toujours $1$.\n"
        }
      ],
      "explanation": "Une variable booléenne est soit vraie, soit fausse : l'une des deux\nvaleurs $a$ ou $\\overline{a}$ vaut $1$, d'où $a + \\overline{a} = 1$.\nDe même, elles ne valent jamais $1$ ensemble, d'où\n$a \\cdot \\overline{a} = 0$."
    },
    {
      "id": "q06",
      "difficulty": 2,
      "skills": [
        "propriete",
        "demorgan"
      ],
      "title": "Transformation d'expressions",
      "partie": "proprietes",
      "statement": "Quelle est la seconde loi de De Morgan, relative au\ncomplément d'un produit ($\\overline{a \\cdot b}$) ?",
      "options": [
        {
          "text": "$\\overline{a \\cdot b} = a + b$",
          "correct": false,
          "feedback": "Erreur : on a bien transformé le ET en OU, mais on a\noublié de complémenter chaque variable.\n"
        },
        {
          "text": "$\\overline{a + b} = \\overline{a} \\cdot \\overline{b}$",
          "correct": false,
          "feedback": "Erreur : c'est la première loi de De Morgan (complément\nd'une somme), pas la seconde demandée.\n"
        },
        {
          "text": "$\\overline{a \\cdot b} = \\overline{a} \\cdot \\overline{b}$",
          "correct": false,
          "feedback": "Erreur : on a bien complémenté chaque variable, mais on a\noublié de changer l'opérateur. De Morgan transforme un\nproduit en somme et réciproquement.\n"
        },
        {
          "text": "$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$",
          "correct": true,
          "feedback": "Bonne réponse : on complémente chaque variable et on\nremplace le ET par un OU. C'est bien la seconde loi de\nDe Morgan.\n"
        }
      ],
      "explanation": "Les lois de De Morgan permettent de transformer le complément\nd'une opération binaire :\n$\\overline{a + b} = \\overline{a} \\cdot \\overline{b}$ et\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$.\nMémo : « on inverse chaque variable et on échange les opérateurs »."
    },
    {
      "id": "q07",
      "difficulty": 2,
      "skills": [
        "simplification"
      ],
      "title": "Simplification algébrique",
      "partie": "proprietes",
      "statement": "Que vaut l'expression simplifiée $a + a \\cdot b$ d'après les\nlois d'absorption ?",
      "options": [
        {
          "text": "Elle vaut $1$",
          "correct": false,
          "feedback": "Erreur : si $a = 0$ et $b = 0$, l'expression vaut $0$,\ndonc elle ne peut pas être identiquement égale à $1$.\n"
        },
        {
          "text": "Elle vaut $b$",
          "correct": false,
          "feedback": "Erreur : oubli de la variable dominante. Si $a = 1$,\nl'expression vaut $1$ même quand $b = 0$ : elle ne peut\ndonc pas se réduire à $b$.\n"
        },
        {
          "text": "Elle vaut $a + b$",
          "correct": false,
          "feedback": "Erreur : c'est la simplification d'une autre absorption,\n$a + \\overline{a} \\cdot b = a + b$. Ici, le facteur est $b$\n(sans complément), donc la simplification est plus forte.\n"
        },
        {
          "text": "Elle vaut $a$",
          "correct": true,
          "feedback": "Bonne réponse : on factorise par $a$ pour obtenir\n$a \\cdot (1 + b) = a \\cdot 1 = a$. La présence de $b$\nn'apporte rien quand $a$ est déjà vrai.\n"
        }
      ],
      "explanation": "Loi d'absorption : $a + a \\cdot b = a \\cdot (1 + b) = a \\cdot 1 = a$.\nSa duale s'écrit $a \\cdot (a + b) = a$. À distinguer de\n$a + \\overline{a} \\cdot b = a + b$ qui est une autre identité."
    },
    {
      "id": "q08",
      "difficulty": 2,
      "skills": [
        "definition",
        "xor"
      ],
      "title": "Étude du OU exclusif",
      "partie": "tables",
      "statement": "Dans quel cas précis la fonction XOR ($a \\oplus b$) renvoie-t-elle\nla valeur $1$ ?",
      "options": [
        {
          "text": "Lorsque les deux entrées sont identiques",
          "correct": false,
          "feedback": "Erreur : c'est exactement le contraire. Le XOR renvoie $0$ (et non\n$1$) lorsque les deux entrées sont identiques.\n"
        },
        {
          "text": "Lorsque exactement une des deux entrées vaut $1$",
          "correct": true,
          "feedback": "Bonne réponse : le XOR détecte la différence entre les\nentrées. Il renvoie $1$ si et seulement si exactement\nune seule des deux entrées vaut $1$.\n"
        },
        {
          "text": "Lorsque les deux entrées valent $1$",
          "correct": false,
          "feedback": "Erreur : pour $(1, 1)$, le XOR renvoie $0$ et non $1$.\nC'est précisément ce qui le différencie du OU inclusif.\n"
        },
        {
          "text": "Lorsque au moins une entrée vaut $0$",
          "correct": false,
          "feedback": "Erreur : pour $(0, 0)$, au moins une entrée vaut $0$\nmais le XOR renvoie $0$, pas $1$. La condition n'est\ndonc pas suffisante.\n"
        }
      ],
      "explanation": "Table de vérité du XOR : $(0,0)\\to 0$, $(0,1)\\to 1$,\n$(1,0)\\to 1$, $(1,1)\\to 0$. C'est l'opérateur de\n« différence » ou « non-équivalence »."
    },
    {
      "id": "q09",
      "difficulty": 3,
      "skills": [
        "evaluation-sequentielle",
        "python",
        "condition"
      ],
      "title": "Tester la première note d'une liste peut-être vide",
      "partie": "operateurs",
      "statement": "La fonction `premiere_reussie(notes)` doit renvoyer `True` si la\nliste `notes` n'est pas vide et que sa première note vaut au moins\n$10$, et `False` dans tous les autres cas, sans jamais provoquer\nd'erreur. Quelle expression faut-il renvoyer ?",
      "options": [
        {
          "text": "`notes[0] >= 10 and len(notes) > 0`",
          "correct": false,
          "feedback": "Erreur : l'ordre compte. `notes[0]` est évalué en premier, et pour\nla liste vide il provoque une `IndexError` avant que la longueur\nsoit testée.\n"
        },
        {
          "text": "`len(notes) > 0 and notes[0] >= 10`",
          "correct": true,
          "feedback": "Bonne réponse : le `and` est évalué de gauche à droite et s'arrête\ndès que la première condition est fausse. Pour `[]`,\n`len(notes) > 0` vaut `False` et `notes[0]` n'est jamais lu : la\nfonction renvoie `False` sans erreur.\n"
        },
        {
          "text": "`len(notes) == 0 and notes[0] >= 10`",
          "correct": false,
          "feedback": "Erreur : pour `[]`, la première condition est vraie, donc Python\névalue `notes[0]` et provoque une `IndexError`. Pour `[12]`,\nl'expression vaut `False` au lieu de `True`.\n"
        },
        {
          "text": "`len(notes) > 0 or notes[0] >= 10`",
          "correct": false,
          "feedback": "Erreur : avec `or`, la seconde condition est évaluée quand la\npremière est fausse, donc justement pour la liste vide :\n`notes[0]` provoque une `IndexError`. Pour `[8]`, l'expression\nvaut `True` à tort.\n"
        }
      ],
      "explanation": "Les opérateurs `and` et `or` sont séquentiels : `a and b` n'évalue\npas `b` si `a` est faux, `a or b` n'évalue pas `b` si `a` est vrai.\nOn place donc en premier la condition qui protège la seconde."
    },
    {
      "id": "q11",
      "difficulty": 1,
      "skills": [
        "definition",
        "ou"
      ],
      "title": "Comportement du OU avec deux entrées à $0$",
      "partie": "operateurs",
      "statement": "Quelle est la valeur de l'expression $a + b$ lorsque $a = 0$ et $b = 0$ ?",
      "options": [
        {
          "text": "Elle vaut $2$",
          "correct": false,
          "feedback": "Erreur : confusion avec une addition arithmétique. La logique\nbooléenne ne manipule que les valeurs $0$ et $1$.\n"
        },
        {
          "text": "Elle vaut $0$",
          "correct": true,
          "feedback": "Bonne réponse : le OU vaut $0$ uniquement quand toutes ses\nentrées valent $0$. C'est le seul cas qui donne $0$ pour le\nOU inclusif.\n"
        },
        {
          "text": "Elle vaut $1$",
          "correct": false,
          "feedback": "Erreur : confusion possible avec l'élément absorbant du OU\n($a + 1 = 1$). Avec deux entrées à $0$, la sortie vaut $0$.\n"
        },
        {
          "text": "Elle est indéterminée",
          "correct": false,
          "feedback": "Erreur : la sortie d'une fonction logique est entièrement\ndéterminée par sa table de vérité.\n"
        }
      ],
      "explanation": "Le OU inclusif vaut $0$ uniquement pour la combinaison $(0, 0)$.\nPour toutes les autres combinaisons, au moins une entrée vaut $1$\net la sortie vaut $1$."
    },
    {
      "id": "q12",
      "difficulty": 1,
      "skills": [
        "propriete",
        "idempotence"
      ],
      "title": "Loi d'idempotence du ET",
      "partie": "proprietes",
      "statement": "D'après la propriété d'idempotence, à quoi est égale l'expression\n$a \\cdot a$ ?",
      "options": [
        {
          "text": "Elle vaut $a$",
          "correct": true,
          "feedback": "Bonne réponse : c'est la loi d'idempotence du ET. Le ET d'un\nbooléen avec lui-même donne ce booléen.\n"
        },
        {
          "text": "Elle vaut $0$",
          "correct": false,
          "feedback": "Erreur : c'est $a \\cdot \\overline{a}$ qui vaut $0$ (principe\nde non-contradiction), pas $a \\cdot a$.\n"
        },
        {
          "text": "Elle vaut $a^2$",
          "correct": false,
          "feedback": "Erreur : confusion avec l'arithmétique. En algèbre de Boole,\n$1 \\cdot 1 = 1$ et $0 \\cdot 0 = 0$, donc le résultat est\nsimplement $a$.\n"
        },
        {
          "text": "Elle vaut $\\overline{a}$",
          "correct": false,
          "feedback": "Erreur : il n'y a pas de complémentation dans l'expression.\n"
        }
      ],
      "explanation": "L'idempotence est valable pour les deux opérateurs :\n$a \\cdot a = a$ et $a + a = a$. C'est une particularité de\nl'algèbre de Boole que l'on n'a pas en arithmétique classique."
    },
    {
      "id": "q13",
      "difficulty": 1,
      "skills": [
        "propriete",
        "element-neutre"
      ],
      "title": "Élément neutre du OU",
      "partie": "proprietes",
      "statement": "Que vaut systématiquement l'expression $a + 0$ ?",
      "options": [
        {
          "text": "Elle vaut $a$",
          "correct": true,
          "feedback": "Bonne réponse : $0$ est l'élément neutre du OU. Ajouter $0$\nne change pas la valeur de $a$.\n"
        },
        {
          "text": "Elle vaut $1$",
          "correct": false,
          "feedback": "Erreur : c'est $a + 1$ qui vaut $1$ (élément absorbant du OU).\n"
        },
        {
          "text": "Elle vaut $0$",
          "correct": false,
          "feedback": "Erreur : confusion avec l'élément absorbant du ET ($a \\cdot 0 = 0$).\nPour le OU, $0$ est l'élément neutre, pas absorbant.\n"
        },
        {
          "text": "Elle vaut $\\overline{a}$",
          "correct": false,
          "feedback": "Erreur : il n'y a pas de complémentation dans l'expression.\n"
        }
      ],
      "explanation": "Mémo : pour le OU, $0$ est neutre et $1$ est absorbant. Pour le\nET, c'est l'inverse : $1$ est neutre et $0$ est absorbant."
    },
    {
      "id": "q14",
      "difficulty": 1,
      "skills": [
        "definition",
        "nor"
      ],
      "title": "Évaluation de la fonction NOR",
      "partie": "tables",
      "statement": "La fonction NOR (NON-OU) est définie par $\\overline{a + b}$.\nQuelle est sa valeur pour $a = 0$ et $b = 0$ ?",
      "options": [
        {
          "text": "Elle est indéterminée",
          "correct": false,
          "feedback": "Erreur : la NOR a une table de vérité parfaitement définie.\n"
        },
        {
          "text": "Elle vaut $\\overline{a}$",
          "correct": false,
          "feedback": "Erreur : la NOR ne dépend pas que de $a$ ; elle dépend des\ndeux entrées.\n"
        },
        {
          "text": "Elle vaut $0$",
          "correct": false,
          "feedback": "Erreur : oubli de la négation finale. $a + b = 0$ pour $(0, 0)$,\ndonc $\\overline{a + b} = \\overline{0} = 1$.\n"
        },
        {
          "text": "Elle vaut $1$",
          "correct": true,
          "feedback": "Bonne réponse : $0 + 0 = 0$, et $\\overline{0} = 1$. La NOR vaut\n$1$ uniquement pour cette combinaison.\n"
        }
      ],
      "explanation": "La NOR ne vaut $1$ que pour $(0, 0)$ et vaut $0$ pour toutes les\nautres combinaisons. Comme la NAND, elle est universelle :\ntout circuit logique peut être réalisé avec uniquement des NOR."
    },
    {
      "id": "q15",
      "difficulty": 1,
      "skills": [
        "python",
        "comparaison"
      ],
      "title": "Comparaison et affectation en Python",
      "partie": "operateurs",
      "statement": "Quel symbole utilise-t-on en Python pour tester l'égalité de deux\nvaleurs ?",
      "options": [
        {
          "text": "Le symbole `===`",
          "correct": false,
          "feedback": "Erreur : `===` n'existe pas en Python (on le rencontre en\nJavaScript). Écrire `a === b` provoque une erreur de syntaxe.\n"
        },
        {
          "text": "Le symbole `=`",
          "correct": false,
          "feedback": "Erreur : `=` est l'opérateur d'affectation, pas de comparaison.\nC'est l'erreur classique en Python : `a = 5` affecte $5$ à $a$,\nalors que `a == 5` teste si $a$ vaut $5$.\n"
        },
        {
          "text": "Le symbole `==`",
          "correct": true,
          "feedback": "Bonne réponse : `==` est le test d'égalité. Il renvoie un\nbooléen (`True` ou `False`).\n"
        },
        {
          "text": "Le symbole `!=`",
          "correct": false,
          "feedback": "Erreur : `!=` teste la différence (l'opposé de `==`).\n"
        }
      ],
      "explanation": "Python utilise `=` pour affecter et `==` pour comparer. Confondre\nles deux est une source classique de bugs : `if a = 5:` produit\nune erreur de syntaxe (à dessein, pour éviter les confusions\ninvolontaires)."
    },
    {
      "id": "q17",
      "difficulty": 2,
      "skills": [
        "propriete",
        "demorgan"
      ],
      "title": "Première loi de De Morgan",
      "partie": "proprietes",
      "statement": "Quelle est la première loi de De Morgan, relative au complément\nd'une somme ($\\overline{a + b}$) ?",
      "options": [
        {
          "text": "$\\overline{a + b} = \\overline{a} + \\overline{b}$",
          "correct": false,
          "feedback": "Erreur : on a complémenté chaque variable, mais on a oublié de\nchanger l'opérateur. De Morgan transforme une somme en produit\n(et inversement).\n"
        },
        {
          "text": "$\\overline{a + b} = a + b$",
          "correct": false,
          "feedback": "Erreur : aucune transformation appliquée. Le complément d'une\nexpression n'est pas l'expression elle-même.\n"
        },
        {
          "text": "$\\overline{a + b} = \\overline{a} \\cdot \\overline{b}$",
          "correct": true,
          "feedback": "Bonne réponse : « ne pas (A ou B) » revient à « ne pas A ET\nne pas B ». On complémente chaque variable et on échange les\nopérateurs.\n"
        },
        {
          "text": "$\\overline{a + b} = a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : on a bien échangé l'opérateur ($+$ devient $\\cdot$),\nmais on a oublié de complémenter chaque variable.\n"
        }
      ],
      "explanation": "Les deux lois de De Morgan permettent de transformer le complément\nd'une opération binaire :\n$\\overline{a + b} = \\overline{a} \\cdot \\overline{b}$ et\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$.\nMémo : « on complémente chaque variable et on échange les\nopérateurs »."
    },
    {
      "id": "q18",
      "difficulty": 2,
      "skills": [
        "propriete",
        "distributivite"
      ],
      "title": "Distributivité du ET sur le OU",
      "partie": "proprietes",
      "statement": "Quelle est la forme développée de l'expression $a \\cdot (b + c)$ ?",
      "options": [
        {
          "text": "$a \\cdot b \\cdot c$",
          "correct": false,
          "feedback": "Erreur : confusion entre distributivité et associativité. La\ndistributivité du ET sur le OU produit une somme de produits.\n"
        },
        {
          "text": "$a \\cdot b + a \\cdot c$",
          "correct": true,
          "feedback": "Bonne réponse : exactement comme la distributivité de la\nmultiplication sur l'addition en arithmétique, $a(b+c) = ab+ac$.\n"
        },
        {
          "text": "$(a + b) \\cdot (a + c)$",
          "correct": false,
          "feedback": "Erreur : c'est la forme donnée par la distributivité\n**duale**, celle du OU sur le ET :\n$a + (b \\cdot c) = (a + b) \\cdot (a + c)$. Ici l'opérateur\nextérieur est un ET. Pour $a = 1$ et $b = c = 0$,\nl'expression proposée vaut $1$ alors que $a \\cdot (b + c)$\nvaut $0$.\n"
        },
        {
          "text": "$a \\cdot b + c$",
          "correct": false,
          "feedback": "Erreur : oubli du facteur $a$ devant le second terme. La\ndistributivité s'applique à chaque terme entre parenthèses.\n"
        }
      ],
      "explanation": "$a \\cdot (b + c) = a \\cdot b + a \\cdot c$. L'algèbre de Boole\npossède aussi la distributivité duale, sans équivalent en\narithmétique : $a + (b \\cdot c) = (a + b) \\cdot (a + c)$."
    },
    {
      "id": "q19",
      "difficulty": 2,
      "skills": [
        "propriete",
        "complementarite"
      ],
      "title": "Principe de non-contradiction",
      "partie": "proprietes",
      "statement": "Que vaut systématiquement l'expression $a \\cdot \\overline{a}$ ?",
      "options": [
        {
          "text": "$\\overline{a}$",
          "correct": false,
          "feedback": "Erreur : le produit $a \\cdot \\overline{a}$ vaut toujours $0$,\nquelle que soit la valeur de $a$. Il ne peut donc pas valoir\n$\\overline{a}$, qui dépend de $a$.\n"
        },
        {
          "text": "$0$",
          "correct": true,
          "feedback": "Bonne réponse : c'est le principe de non-contradiction. Une\nvariable et son complément ne peuvent jamais valoir $1$\nsimultanément, donc leur ET vaut toujours $0$.\n"
        },
        {
          "text": "$a$",
          "correct": false,
          "feedback": "Erreur : si $a = 1$, alors $\\overline{a} = 0$ et le produit\nvaut $0$, pas $1$. Le résultat ne peut donc pas être $a$.\n"
        },
        {
          "text": "$1$",
          "correct": false,
          "feedback": "Erreur : confusion avec le tiers exclu, qui s'écrit\n$a + \\overline{a} = 1$ (avec un OU, pas un ET).\n"
        }
      ],
      "explanation": "Le principe de non-contradiction $a \\cdot \\overline{a} = 0$ et le\ntiers exclu $a + \\overline{a} = 1$ sont les deux propriétés duales\nde complémentarité en algèbre de Boole."
    },
    {
      "id": "q20",
      "difficulty": 2,
      "skills": [
        "xor",
        "expression"
      ],
      "title": "Expression algébrique du OU exclusif",
      "partie": "tables",
      "statement": "À quelle expression algébrique correspond la fonction XOR\n($a \\oplus b$), exprimée à l'aide des opérateurs fondamentaux ET,\nOU et NON ?",
      "options": [
        {
          "text": "$a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : c'est la définition du ET, qui ne vaut $1$ que pour\n$(1, 1)$. Le XOR vaut justement $0$ dans ce cas.\n"
        },
        {
          "text": "$\\overline{a} \\cdot \\overline{b} + a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : cette expression vaut $1$ quand les deux entrées sont\n**égales**, $(0, 0)$ ou $(1, 1)$, alors que le XOR vaut $1$ quand\nelles diffèrent. C'est le contraire du XOR.\n"
        },
        {
          "text": "$\\overline{a} \\cdot b + a \\cdot \\overline{b} + a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : c'est une écriture du OU **inclusif**, qui garde le terme\n$a \\cdot b$ (ligne $(1, 1)$ de la table). Le XOR vaut justement $0$\nsur cette ligne : ce troisième terme est de trop.\n"
        },
        {
          "text": "$\\overline{a} \\cdot b + a \\cdot \\overline{b}$",
          "correct": true,
          "feedback": "Bonne réponse : le XOR vaut $1$ quand exactement une entrée\nvaut $1$ : soit « $a$ faux et $b$ vrai » ($\\overline{a} \\cdot b$),\nsoit « $a$ vrai et $b$ faux » ($a \\cdot \\overline{b}$).\n"
        }
      ],
      "explanation": "L'expression $\\overline{a} \\cdot b + a \\cdot \\overline{b}$ se lit\ndirectement sur la table de vérité : on prend les lignes où le\nrésultat vaut $1$ (ici $(0, 1)$ et $(1, 0)$), on écrit chacune comme\nun produit des variables ou de leurs compléments, puis on additionne\nces produits."
    },
    {
      "id": "q21",
      "difficulty": 2,
      "skills": [
        "de-morgan",
        "python"
      ],
      "title": "Simplification d'une condition Python",
      "partie": "operateurs",
      "statement": "D'après les lois de De Morgan, quelle est la forme **la plus\nsimplifiée** équivalente à l'expression `not (x > 0 and y > 0)` ?",
      "options": [
        {
          "text": "`not x > 0 or not y > 0`",
          "correct": false,
          "feedback": "Erreur : cette écriture est bien équivalente, mais elle\nn'est pas simplifiée. En Python, `not` est moins prioritaire\nque la comparaison, donc `not x > 0` signifie `not (x > 0)`,\nsoit `x <= 0` : il restait à effectuer cette simplification.\n"
        },
        {
          "text": "`x > 0 or y > 0`",
          "correct": false,
          "feedback": "Erreur : on a juste retiré le `not` et changé `and` en `or`,\nsans complémenter les comparaisons. Pour appliquer De Morgan,\nil faut **complémenter chaque condition**.\n"
        },
        {
          "text": "`x <= 0 and y <= 0`",
          "correct": false,
          "feedback": "Erreur : on a bien complémenté chaque comparaison, mais on a\noublié d'échanger `and` et `or`. De Morgan transforme un ET\nen OU et inversement.\n"
        },
        {
          "text": "`x <= 0 or y <= 0`",
          "correct": true,
          "feedback": "Bonne réponse : par la 2ème loi de De Morgan,\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$, donc\n`not (A and B) = (not A) or (not B)`. La négation de `> 0`\nest `<= 0`.\n"
        }
      ],
      "explanation": "Cette équivalence est très utile pour rendre les conditions\nPython plus lisibles : on évite ainsi les négations imbriquées\nqui obligent à un effort mental supplémentaire à la lecture.",
      "variants": [
        {
          "statement": "D'après les lois de De Morgan, quelle est la forme **la plus\nsimplifiée** équivalente à l'expression `not (x > 0 and y > 0)` ?",
          "options": [
            {
              "text": "`not x > 0 or not y > 0`",
              "correct": false,
              "feedback": "Erreur : cette écriture est bien équivalente, mais elle\nn'est pas simplifiée. En Python, `not` est moins prioritaire\nque la comparaison, donc `not x > 0` signifie `not (x > 0)`,\nsoit `x <= 0` : il restait à effectuer cette simplification.\n"
            },
            {
              "text": "`x > 0 or y > 0`",
              "correct": false,
              "feedback": "Erreur : on a juste retiré le `not` et changé `and` en `or`,\nsans complémenter les comparaisons. Pour appliquer De Morgan,\nil faut **complémenter chaque condition**.\n"
            },
            {
              "text": "`x <= 0 and y <= 0`",
              "correct": false,
              "feedback": "Erreur : on a bien complémenté chaque comparaison, mais on a\noublié d'échanger `and` et `or`. De Morgan transforme un ET\nen OU et inversement.\n"
            },
            {
              "text": "`x <= 0 or y <= 0`",
              "correct": true,
              "feedback": "Bonne réponse : par la 2ème loi de De Morgan,\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$, donc\n`not (A and B) = (not A) or (not B)`. La négation de `> 0`\nest `<= 0`.\n"
            }
          ],
          "explanation": "Cette équivalence est très utile pour rendre les conditions\nPython plus lisibles : on évite ainsi les négations imbriquées\nqui obligent à un effort mental supplémentaire à la lecture."
        },
        {
          "statement": "D'après les lois de De Morgan, quelle est la forme **la plus\nsimplifiée** équivalente à l'expression `not (x > 5 and y > 2)` ?",
          "options": [
            {
              "text": "`not x > 5 or not y > 2`",
              "correct": false,
              "feedback": "Erreur : cette écriture est bien équivalente, mais elle\nn'est pas simplifiée. En Python, `not` est moins prioritaire\nque la comparaison, donc `not x > 5` signifie `not (x > 5)`,\nsoit `x <= 5` : il restait à effectuer cette simplification.\n"
            },
            {
              "text": "`x > 5 or y > 2`",
              "correct": false,
              "feedback": "Erreur : on a juste retiré le `not` et changé `and` en `or`,\nsans complémenter les comparaisons. Pour appliquer De Morgan,\nil faut **complémenter chaque condition**.\n"
            },
            {
              "text": "`x <= 5 and y <= 2`",
              "correct": false,
              "feedback": "Erreur : on a bien complémenté chaque comparaison, mais on a\noublié d'échanger `and` et `or`. De Morgan transforme un ET\nen OU et inversement.\n"
            },
            {
              "text": "`x <= 5 or y <= 2`",
              "correct": true,
              "feedback": "Bonne réponse : par la 2ème loi de De Morgan,\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$, donc\n`not (A and B) = (not A) or (not B)`. La négation de `> 5`\nest `<= 5`.\n"
            }
          ],
          "explanation": "Cette équivalence est très utile pour rendre les conditions\nPython plus lisibles : on évite ainsi les négations imbriquées\nqui obligent à un effort mental supplémentaire à la lecture."
        },
        {
          "statement": "D'après les lois de De Morgan, quelle est la forme **la plus\nsimplifiée** équivalente à l'expression `not (x > 10 and y > 3)` ?",
          "options": [
            {
              "text": "`not x > 10 or not y > 3`",
              "correct": false,
              "feedback": "Erreur : cette écriture est bien équivalente, mais elle\nn'est pas simplifiée. En Python, `not` est moins prioritaire\nque la comparaison, donc `not x > 10` signifie `not (x > 10)`,\nsoit `x <= 10` : il restait à effectuer cette simplification.\n"
            },
            {
              "text": "`x > 10 or y > 3`",
              "correct": false,
              "feedback": "Erreur : on a juste retiré le `not` et changé `and` en `or`,\nsans complémenter les comparaisons. Pour appliquer De Morgan,\nil faut **complémenter chaque condition**.\n"
            },
            {
              "text": "`x <= 10 and y <= 3`",
              "correct": false,
              "feedback": "Erreur : on a bien complémenté chaque comparaison, mais on a\noublié d'échanger `and` et `or`. De Morgan transforme un ET\nen OU et inversement.\n"
            },
            {
              "text": "`x <= 10 or y <= 3`",
              "correct": true,
              "feedback": "Bonne réponse : par la 2ème loi de De Morgan,\n$\\overline{a \\cdot b} = \\overline{a} + \\overline{b}$, donc\n`not (A and B) = (not A) or (not B)`. La négation de `> 10`\nest `<= 10`.\n"
            }
          ],
          "explanation": "Cette équivalence est très utile pour rendre les conditions\nPython plus lisibles : on évite ainsi les négations imbriquées\nqui obligent à un effort mental supplémentaire à la lecture."
        }
      ]
    },
    {
      "id": "q22",
      "difficulty": 2,
      "skills": [
        "simplification",
        "absorption"
      ],
      "title": "Loi d'absorption duale",
      "partie": "proprietes",
      "statement": "D'après les lois d'absorption, à quoi est égale l'expression\n$a \\cdot (a + b)$ ?",
      "options": [
        {
          "text": "$a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : si $a = 1$ et $b = 0$, l'expression vaut $1$ alors\nque $a \\cdot b = 0$. Donc l'égalité ne tient pas.\n"
        },
        {
          "text": "$b$",
          "correct": false,
          "feedback": "Erreur : la variable $a$ ne peut pas disparaître. Si $a = 0$,\nl'expression vaut $0$ quelle que soit la valeur de $b$.\n"
        },
        {
          "text": "$a$",
          "correct": true,
          "feedback": "Bonne réponse : c'est la duale de $a + a \\cdot b = a$. On peut\nla prouver en développant : $a \\cdot (a + b) = a \\cdot a + a \\cdot b = a + a \\cdot b = a$.\n"
        },
        {
          "text": "$a + b$",
          "correct": false,
          "feedback": "Erreur : oubli de la dominance de $a$. Si $a = 0$,\nl'expression vaut $0$, ce qui n'est pas le cas de $a + b$\nquand $b = 1$.\n"
        }
      ],
      "explanation": "Les deux lois d'absorption sont duales :\n$a + a \\cdot b = a$ et $a \\cdot (a + b) = a$.\nDans les deux cas, la variable « extérieure » domine et absorbe\nla sous-expression dans laquelle elle apparaît."
    },
    {
      "id": "q23",
      "difficulty": 3,
      "skills": [
        "nand",
        "construction",
        "table-de-verite"
      ],
      "title": "Construction de la fonction NON avec des NAND",
      "partie": "tables",
      "statement": "On note $a \\uparrow b = \\overline{a \\cdot b}$ la fonction NON-ET\n(NAND). Quelle expression, utilisant uniquement cette fonction et la\nvariable $a$, permet d'obtenir $\\overline{a}$ ?",
      "options": [
        {
          "text": "$a \\uparrow \\overline{a}$",
          "correct": false,
          "feedback": "Erreur : cette expression suppose que l'on dispose déjà de\n$\\overline{a}$, qui est précisément ce que l'on cherche à\nconstruire. C'est un raisonnement circulaire.\n"
        },
        {
          "text": "$a + \\overline{a}$",
          "correct": false,
          "feedback": "Erreur : cette expression utilise les opérateurs OU et NON, pas\nuniquement la fonction $\\uparrow$. De plus, elle vaut toujours $1$,\nquelle que soit la valeur de $a$.\n"
        },
        {
          "text": "$a \\uparrow a$",
          "correct": true,
          "feedback": "Bonne réponse : $a \\uparrow a = \\overline{a \\cdot a} = \\overline{a}$,\ncar $a \\cdot a = a$. En reliant les deux entrées d'une porte NON-ET,\non obtient une porte NON.\n"
        },
        {
          "text": "$\\overline{a \\uparrow a}$",
          "correct": false,
          "feedback": "Erreur : on ajoute une négation supplémentaire, qui annule la\nprécédente. Cela donne $\\overline{\\overline{a}} = a$, et non\n$\\overline{a}$.\n"
        }
      ],
      "explanation": "On applique la définition : $a \\uparrow a = \\overline{a \\cdot a}$, et\ncomme $a \\cdot a = a$, on obtient $\\overline{a}$. On le vérifie sur\nla table : pour $a = 0$, $\\overline{0 \\cdot 0} = 1$ ; pour $a = 1$,\n$\\overline{1 \\cdot 1} = 0$."
    },
    {
      "id": "q24",
      "difficulty": 3,
      "skills": [
        "analyse",
        "synthese",
        "table"
      ],
      "title": "Synthèse à partir d'une table de vérité",
      "partie": "tables",
      "statement": "Une fonction logique $f(a, b)$ a la table de vérité suivante :\n$f(0, 0) = 0$, $f(0, 1) = 1$, $f(1, 0) = 0$, $f(1, 1) = 1$.\nQuelle est l'expression la plus simple de $f$ ?",
      "options": [
        {
          "text": "$f = a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : pour $(0, 1)$, on a $a \\cdot b = 0$ alors que $f = 1$.\nLa fonction ET ne convient pas.\n"
        },
        {
          "text": "$f = a \\oplus b$",
          "correct": false,
          "feedback": "Erreur : pour $(1, 1)$, on a $a \\oplus b = 0$ alors que $f = 1$.\nLe XOR ne convient pas.\n"
        },
        {
          "text": "$f = b$",
          "correct": true,
          "feedback": "Bonne réponse : la sortie est égale à $b$ dans toutes les\ncombinaisons, indépendamment de $a$. La fonction est\ndégénérée : elle ne dépend en réalité que de $b$.\n"
        },
        {
          "text": "$f = a + b$",
          "correct": false,
          "feedback": "Erreur : pour $(1, 0)$, on a $a + b = 1$ alors que $f = 0$.\nLa fonction OU ne convient pas.\n"
        }
      ],
      "explanation": "Lire systématiquement la table : ici $f$ vaut $0$ quand $b = 0$\net $f$ vaut $1$ quand $b = 1$, quelle que soit la valeur de $a$.\nL'expression minimale est donc $f = b$. C'est un piège classique :\navant de chercher une combinaison complexe, vérifier si la sortie\nne dépend pas en réalité d'une seule entrée."
    },
    {
      "id": "q25",
      "difficulty": 3,
      "skills": [
        "synthese",
        "modelisation"
      ],
      "title": "Traduire un énoncé en expression booléenne",
      "partie": "proprietes",
      "statement": "Un capteur de sécurité doit déclencher une alarme uniquement\nlorsque la porte est ouverte (variable $p$ valant $1$) **et**\nqu'aucun badge autorisé n'est détecté (variable $a$ valant $0$,\n$a$ valant $1$ signifiant qu'un badge autorisé est présent).\nQuelle expression booléenne décrit la sortie de l'alarme ?",
      "options": [
        {
          "text": "$p \\cdot \\overline{a}$",
          "correct": true,
          "feedback": "Bonne réponse : l'alarme se déclenche quand les deux\nconditions sont réunies simultanément (porte ouverte\nET pas de badge), d'où le ET logique. La condition\n« pas de badge » se traduit par $\\overline{a}$\n(négation de la présence d'un badge autorisé).\n"
        },
        {
          "text": "$p \\cdot a$",
          "correct": false,
          "feedback": "Erreur : cette expression déclenche l'alarme quand\nla porte est ouverte **et** qu'un badge autorisé est\nprésent, c'est-à-dire dans une situation parfaitement\nnormale.\n"
        },
        {
          "text": "$p + a$",
          "correct": false,
          "feedback": "Erreur : le OU ne convient pas. Avec cette\nexpression, l'alarme se déclenche dès que la porte\nest ouverte, même si un badge autorisé est détecté.\n"
        },
        {
          "text": "$\\overline{p} \\cdot \\overline{a}$",
          "correct": false,
          "feedback": "Erreur : cette expression vaut $1$ quand la porte est\nfermée et qu'aucun badge n'est détecté, c'est-à-dire\nen l'absence totale d'activité, ce qui est l'inverse\ndu comportement souhaité.\n"
        }
      ],
      "explanation": "Traduire un énoncé en logique demande deux étapes : isoler\nles variables binaires (ici $p$ et $a$) et identifier\nl'opérateur qui relie les conditions (ET, OU, négation).\nBien repérer les négations dans le langage naturel\n(« aucun », « pas de », « sauf si ») évite la moitié des\nerreurs classiques."
    },
    {
      "id": "q26",
      "difficulty": 3,
      "skills": [
        "synthese",
        "simplification",
        "absorption"
      ],
      "title": "Simplifier une expression",
      "partie": "proprietes",
      "statement": "Quelle est la forme la plus simple de l'expression\n$a \\cdot (a + b) + a \\cdot \\overline{b}$ ?",
      "options": [
        {
          "text": "$a$",
          "correct": true,
          "feedback": "Bonne réponse : on développe et l'on simplifie.\n$a \\cdot (a + b) = a$ par absorption ; il reste\n$a + a \\cdot \\overline{b}$, qui se simplifie à\nson tour en $a$ par la même loi d'absorption.\nL'expression vaut donc simplement $a$, quelle que\nsoit la valeur de $b$.\n"
        },
        {
          "text": "$a + b$",
          "correct": false,
          "feedback": "Erreur : cette expression vaut $1$ pour $(0, 1)$,\nalors que l'expression initiale vaut $0$. Une\nsimplification se vérifie toujours en testant les\n$2^n$ combinaisons.\n"
        },
        {
          "text": "$a \\cdot b$",
          "correct": false,
          "feedback": "Erreur : cette expression vaut $0$ pour $(1, 0)$,\nalors que l'expression initiale vaut $1$ (car\n$a \\cdot \\overline{b} = 1$).\n"
        },
        {
          "text": "$\\overline{b}$",
          "correct": false,
          "feedback": "Erreur : cette expression ne dépend pas de $a$\nalors que la valeur de l'expression initiale en\ndépend (pour $a = 0$, elle vaut toujours $0$\nquelle que soit la valeur de $b$).\n"
        }
      ],
      "explanation": "La loi d'absorption ($a + a \\cdot b = a$ et\n$a \\cdot (a + b) = a$) est l'une des plus efficaces\npour simplifier rapidement. Quand un résultat de\nsimplification surprend, la vérification par table de\nvérité (quatre lignes pour deux variables) tranche\nsans ambiguïté."
    },
    {
      "id": "q27",
      "difficulty": 1,
      "skills": [
        "and",
        "not",
        "evaluation"
      ],
      "title": "Évaluer une expression avec et et non",
      "partie": "operateurs",
      "statement": "Que vaut l'expression `a and not b` lorsque `a` vaut `True` et `b`\nvaut `False` ?",
      "options": [
        {
          "text": "`True`",
          "correct": true,
          "feedback": "Bonne réponse : `not b` vaut l'inverse de `False`, et `and` n'est\nvrai que si ses deux opérandes le sont.\n"
        },
        {
          "text": "`False`",
          "correct": false,
          "feedback": "Erreur : évalue d'abord `not b`, puis combine avec `a` par un\n`and`.\n"
        },
        {
          "text": "`True and False`",
          "correct": false,
          "feedback": "Erreur : une expression booléenne s'évalue en `True` ou\n`False`.\n"
        },
        {
          "text": "Une erreur, `not` ne pouvant suivre `and`",
          "correct": false,
          "feedback": "Erreur : `not` s'applique à `b` avant le `and`, l'écriture est\nvalide.\n"
        }
      ],
      "explanation": "`not` est évalué avant `and`, lui-même avant `or`. Des parenthèses\nrendent l'ordre explicite quand on hésite.",
      "variants": [
        {
          "statement": "Que vaut l'expression `a and not b` lorsque `a` vaut `True` et `b`\nvaut `False` ?",
          "options": [
            {
              "text": "`True`",
              "correct": true,
              "feedback": "Bonne réponse : `not b` vaut l'inverse de `False`, et `and` n'est\nvrai que si ses deux opérandes le sont.\n"
            },
            {
              "text": "`False`",
              "correct": false,
              "feedback": "Erreur : évalue d'abord `not b`, puis combine avec `a` par un\n`and`.\n"
            },
            {
              "text": "`True and False`",
              "correct": false,
              "feedback": "Erreur : une expression booléenne s'évalue en `True` ou\n`False`.\n"
            },
            {
              "text": "Une erreur, `not` ne pouvant suivre `and`",
              "correct": false,
              "feedback": "Erreur : `not` s'applique à `b` avant le `and`, l'écriture est\nvalide.\n"
            }
          ],
          "explanation": "`not` est évalué avant `and`, lui-même avant `or`. Des parenthèses\nrendent l'ordre explicite quand on hésite."
        },
        {
          "statement": "Que vaut l'expression `a and not b` lorsque `a` vaut `False` et `b`\nvaut `True` ?",
          "options": [
            {
              "text": "`False`",
              "correct": true,
              "feedback": "Bonne réponse : `not b` vaut l'inverse de `True`, et `and` n'est\nvrai que si ses deux opérandes le sont.\n"
            },
            {
              "text": "`True`",
              "correct": false,
              "feedback": "Erreur : évalue d'abord `not b`, puis combine avec `a` par un\n`and`.\n"
            },
            {
              "text": "`False and True`",
              "correct": false,
              "feedback": "Erreur : une expression booléenne s'évalue en `True` ou\n`False`.\n"
            },
            {
              "text": "Une erreur, `not` ne pouvant suivre `and`",
              "correct": false,
              "feedback": "Erreur : `not` s'applique à `b` avant le `and`, l'écriture est\nvalide.\n"
            }
          ],
          "explanation": "`not` est évalué avant `and`, lui-même avant `or`. Des parenthèses\nrendent l'ordre explicite quand on hésite."
        }
      ]
    },
    {
      "id": "q28",
      "difficulty": 2,
      "skills": [
        "and",
        "evaluation-paresseuse",
        "division"
      ],
      "title": "Une division évitée par le et",
      "partie": "operateurs",
      "statement": "Que vaut `x != 0 and 10 / x > 2` lorsque `x` vaut `0` ?",
      "options": [
        {
          "text": "`False`, la seconde comparaison n'étant pas évaluée",
          "correct": true,
          "feedback": "Bonne réponse : `x != 0` est faux, donc le résultat du `and`\nest connu. Python n'évalue pas `10 / x`, et la division par\nzéro n'a pas lieu.\n"
        },
        {
          "text": "Une erreur de division par zéro, `10 / x` étant calculé",
          "correct": false,
          "feedback": "Erreur : Python évalue `and` de gauche à droite et s'arrête dès\nque le résultat est certain.\n"
        },
        {
          "text": "`True`, car `10 / 0` est considéré comme infini",
          "correct": false,
          "feedback": "Erreur : la division n'est jamais calculée, et `x != 0` est de\ntoute façon faux.\n"
        },
        {
          "text": "`0`, le résultat de la première comparaison",
          "correct": false,
          "feedback": "Erreur : une expression avec `and` renvoie un booléen.\n"
        }
      ],
      "explanation": "L'évaluation paresseuse de `and` et `or` permet d'écrire une\ncondition de garde avant une opération risquée."
    },
    {
      "id": "q29",
      "difficulty": 2,
      "skills": [
        "or",
        "comparaison",
        "evaluation"
      ],
      "title": "Un ou entre deux tests",
      "partie": "operateurs",
      "statement": "Que vaut `n % 2 == 0 or n > 10` lorsque `n` vaut `7` ?",
      "options": [
        {
          "text": "`False`",
          "correct": true,
          "feedback": "Bonne réponse : `or` est vrai dès qu'une des deux comparaisons\nl'est. Pour 7, regarde la parité puis la comparaison à 10.\n"
        },
        {
          "text": "`True`",
          "correct": false,
          "feedback": "Erreur : évalue séparément `7 % 2 == 0` et `7 > 10`, puis\napplique la règle du `or`.\n"
        },
        {
          "text": "`7`",
          "correct": false,
          "feedback": "Erreur : le résultat d'un `or` entre comparaisons est un\nbooléen.\n"
        },
        {
          "text": "Une erreur, `%` ne pouvant être mêlé à `or`",
          "correct": false,
          "feedback": "Erreur : les comparaisons sont évaluées d'abord, le `or`\ncombine ensuite leurs résultats.\n"
        }
      ],
      "explanation": "Les opérateurs arithmétiques et de comparaison sont évalués avant\nles opérateurs booléens.",
      "variants": [
        {
          "statement": "Que vaut `n % 2 == 0 or n > 10` lorsque `n` vaut `7` ?",
          "options": [
            {
              "text": "`False`",
              "correct": true,
              "feedback": "Bonne réponse : `or` est vrai dès qu'une des deux comparaisons\nl'est. Pour 7, regarde la parité puis la comparaison à 10.\n"
            },
            {
              "text": "`True`",
              "correct": false,
              "feedback": "Erreur : évalue séparément `7 % 2 == 0` et `7 > 10`, puis\napplique la règle du `or`.\n"
            },
            {
              "text": "`7`",
              "correct": false,
              "feedback": "Erreur : le résultat d'un `or` entre comparaisons est un\nbooléen.\n"
            },
            {
              "text": "Une erreur, `%` ne pouvant être mêlé à `or`",
              "correct": false,
              "feedback": "Erreur : les comparaisons sont évaluées d'abord, le `or`\ncombine ensuite leurs résultats.\n"
            }
          ],
          "explanation": "Les opérateurs arithmétiques et de comparaison sont évalués avant\nles opérateurs booléens."
        },
        {
          "statement": "Que vaut `n % 2 == 0 or n > 10` lorsque `n` vaut `8` ?",
          "options": [
            {
              "text": "`True`",
              "correct": true,
              "feedback": "Bonne réponse : `or` est vrai dès qu'une des deux comparaisons\nl'est. Pour 8, regarde la parité puis la comparaison à 10.\n"
            },
            {
              "text": "`False`",
              "correct": false,
              "feedback": "Erreur : évalue séparément `8 % 2 == 0` et `8 > 10`, puis\napplique la règle du `or`.\n"
            },
            {
              "text": "`8`",
              "correct": false,
              "feedback": "Erreur : le résultat d'un `or` entre comparaisons est un\nbooléen.\n"
            },
            {
              "text": "Une erreur, `%` ne pouvant être mêlé à `or`",
              "correct": false,
              "feedback": "Erreur : les comparaisons sont évaluées d'abord, le `or`\ncombine ensuite leurs résultats.\n"
            }
          ],
          "explanation": "Les opérateurs arithmétiques et de comparaison sont évalués avant\nles opérateurs booléens."
        }
      ]
    },
    {
      "id": "q30",
      "difficulty": 3,
      "skills": [
        "priorite",
        "not",
        "or"
      ],
      "title": "La priorité de not devant or",
      "partie": "operateurs",
      "statement": "Que vaut `not a or b` lorsque `a` et `b` valent tous deux `True` ?",
      "options": [
        {
          "text": "`True`, l'expression se lisant `(not a) or b`",
          "correct": true,
          "feedback": "Bonne réponse : `not` est prioritaire sur `or`. `not a` vaut\n`False`, puis `False or True` vaut `True`.\n"
        },
        {
          "text": "`False`, l'expression se lisant `not (a or b)`",
          "correct": false,
          "feedback": "Erreur : sans parenthèses, `not` ne porte que sur `a`.\n"
        },
        {
          "text": "Une erreur de syntaxe, `not` ne pouvant précéder `or`",
          "correct": false,
          "feedback": "Erreur : l'expression est valide, seule sa lecture demande de\nconnaître les priorités.\n"
        },
        {
          "text": "`a`, le `not` et le `or` s'annulant",
          "correct": false,
          "feedback": "Erreur : l'expression s'évalue en un booléen, ici `True`.\n"
        }
      ],
      "explanation": "Ordre de priorité : `not`, puis `and`, puis `or`. En cas de doute,\nles parenthèses évitent toute ambiguïté."
    },
    {
      "id": "q31",
      "difficulty": 1,
      "skills": [
        "booleen",
        "type",
        "comparaison"
      ],
      "title": "Le type d'une comparaison",
      "partie": "operateurs",
      "statement": "Que renvoie `type(3 > 2)` ?",
      "options": [
        {
          "text": "`<class 'bool'>`",
          "correct": true,
          "feedback": "Bonne réponse : une comparaison produit un booléen, `True` ou\n`False`, du type `bool`.\n"
        },
        {
          "text": "`<class 'int'>`",
          "correct": false,
          "feedback": "Erreur : les opérandes sont des entiers, mais le résultat de la\ncomparaison ne l'est pas.\n"
        },
        {
          "text": "`<class 'str'>`",
          "correct": false,
          "feedback": "Erreur : `True` sans guillemets n'est pas une chaîne.\n"
        },
        {
          "text": "Une erreur, `type` ne s'appliquant pas à une comparaison",
          "correct": false,
          "feedback": "Erreur : `type` accepte toute valeur, y compris le résultat\nd'une comparaison.\n"
        }
      ],
      "explanation": "`bool` est un type à deux valeurs. Toute condition d'un `if` ou\nd'un `while` est de ce type."
    },
    {
      "id": "q32",
      "difficulty": 1,
      "skills": [
        "table-de-verite",
        "denombrement"
      ],
      "title": "Le nombre de lignes d'une table",
      "partie": "tables",
      "statement": "Combien de lignes compte la table de vérité d'une expression à\ntrois variables booléennes ?",
      "options": [
        {
          "text": "$8$",
          "correct": true,
          "feedback": "Bonne réponse : chaque variable prend deux valeurs, et les\ncombinaisons se multiplient : $2^{3} = 8$.\n"
        },
        {
          "text": "$6$",
          "correct": false,
          "feedback": "Erreur : les valeurs se combinent, elles ne s'additionnent pas.\n"
        },
        {
          "text": "$9$",
          "correct": false,
          "feedback": "Erreur : le nombre de combinaisons est une puissance de deux,\npas un carré.\n"
        },
        {
          "text": "$3$",
          "correct": false,
          "feedback": "Erreur : $3$ est le nombre de colonnes d'entrée, pas le nombre\nde lignes.\n"
        }
      ],
      "explanation": "Une table de vérité énumère toutes les combinaisons des entrées :\n$2^n$ lignes pour $n$ variables.",
      "variants": [
        {
          "statement": "Combien de lignes compte la table de vérité d'une expression à\ntrois variables booléennes ?",
          "options": [
            {
              "text": "$8$",
              "correct": true,
              "feedback": "Bonne réponse : chaque variable prend deux valeurs, et les\ncombinaisons se multiplient : $2^{3} = 8$.\n"
            },
            {
              "text": "$6$",
              "correct": false,
              "feedback": "Erreur : les valeurs se combinent, elles ne s'additionnent pas.\n"
            },
            {
              "text": "$9$",
              "correct": false,
              "feedback": "Erreur : le nombre de combinaisons est une puissance de deux,\npas un carré.\n"
            },
            {
              "text": "$3$",
              "correct": false,
              "feedback": "Erreur : $3$ est le nombre de colonnes d'entrée, pas le nombre\nde lignes.\n"
            }
          ],
          "explanation": "Une table de vérité énumère toutes les combinaisons des entrées :\n$2^n$ lignes pour $n$ variables."
        },
        {
          "statement": "Combien de lignes compte la table de vérité d'une expression à\ncinq variables booléennes ?",
          "options": [
            {
              "text": "$32$",
              "correct": true,
              "feedback": "Bonne réponse : chaque variable prend deux valeurs, et les\ncombinaisons se multiplient : $2^{5} = 32$.\n"
            },
            {
              "text": "$10$",
              "correct": false,
              "feedback": "Erreur : les valeurs se combinent, elles ne s'additionnent pas.\n"
            },
            {
              "text": "$25$",
              "correct": false,
              "feedback": "Erreur : le nombre de combinaisons est une puissance de deux,\npas un carré.\n"
            },
            {
              "text": "$5$",
              "correct": false,
              "feedback": "Erreur : $5$ est le nombre de colonnes d'entrée, pas le nombre\nde lignes.\n"
            }
          ],
          "explanation": "Une table de vérité énumère toutes les combinaisons des entrées :\n$2^n$ lignes pour $n$ variables."
        },
        {
          "statement": "Combien de lignes compte la table de vérité d'une expression à\nsix variables booléennes ?",
          "options": [
            {
              "text": "$64$",
              "correct": true,
              "feedback": "Bonne réponse : chaque variable prend deux valeurs, et les\ncombinaisons se multiplient : $2^{6} = 64$.\n"
            },
            {
              "text": "$12$",
              "correct": false,
              "feedback": "Erreur : les valeurs se combinent, elles ne s'additionnent pas.\n"
            },
            {
              "text": "$36$",
              "correct": false,
              "feedback": "Erreur : le nombre de combinaisons est une puissance de deux,\npas un carré.\n"
            },
            {
              "text": "$6$",
              "correct": false,
              "feedback": "Erreur : $6$ est le nombre de colonnes d'entrée, pas le nombre\nde lignes.\n"
            }
          ],
          "explanation": "Une table de vérité énumère toutes les combinaisons des entrées :\n$2^n$ lignes pour $n$ variables."
        }
      ]
    },
    {
      "id": "q33",
      "difficulty": 2,
      "skills": [
        "table-de-verite",
        "lecture",
        "expression"
      ],
      "title": "Retrouver l'expression d'une table",
      "partie": "tables",
      "statement": "Une expression `e` de deux variables a la table suivante :\n`a=0, b=0 → 0` ; `a=0, b=1 → 0` ; `a=1, b=0 → 1` ; `a=1, b=1 → 0`.\nQuelle est cette expression ?",
      "options": [
        {
          "text": "`a and not b`",
          "correct": true,
          "feedback": "Bonne réponse : la seule ligne vraie est celle où `a` vaut 1 et\n`b` vaut 0, ce que traduit `a and not b`.\n"
        },
        {
          "text": "`a or not b`",
          "correct": false,
          "feedback": "Erreur : cette expression serait vraie aussi pour `a=0, b=0` et\n`a=1, b=1`.\n"
        },
        {
          "text": "`not a and b`",
          "correct": false,
          "feedback": "Erreur : cette expression est vraie pour `a=0, b=1`, pas pour\n`a=1, b=0`.\n"
        },
        {
          "text": "`a and b`",
          "correct": false,
          "feedback": "Erreur : `a and b` n'est vrai que sur la dernière ligne.\n"
        }
      ],
      "explanation": "Pour lire une table, on repère les lignes vraies : une seule ligne\nvraie se traduit par un `and` des variables, niées quand elles\nvalent 0."
    },
    {
      "id": "q34",
      "difficulty": 2,
      "skills": [
        "table-de-verite",
        "denombrement",
        "operateurs"
      ],
      "title": "Compter les lignes vraies",
      "partie": "tables",
      "statement": "Dans la table de vérité à deux variables `a` et `b`, sur combien\nde lignes l'expression `a or b` vaut-elle 1 ?",
      "options": [
        {
          "text": "$3$ lignes",
          "correct": true,
          "feedback": "Bonne réponse : parmi les quatre combinaisons de `a` et `b`,\n`a or b` est vraie sur 3 d'entre elles.\n"
        },
        {
          "text": "$1$ lignes",
          "correct": false,
          "feedback": "Erreur : reprends les quatre combinaisons une par une et évalue\n`a or b` sur chacune.\n"
        },
        {
          "text": "$2$ lignes",
          "correct": false,
          "feedback": "Erreur : compte seulement les lignes où `a or b` vaut 1.\n"
        },
        {
          "text": "$4$ lignes",
          "correct": false,
          "feedback": "Erreur : aucune des expressions usuelles n'est vraie sur les\nquatre lignes.\n"
        }
      ],
      "explanation": "`or` est vrai sur trois lignes sur quatre, `and` sur une seule,\n`not a` sur les deux lignes où `a` vaut 0.",
      "variants": [
        {
          "statement": "Dans la table de vérité à deux variables `a` et `b`, sur combien\nde lignes l'expression `a or b` vaut-elle 1 ?",
          "options": [
            {
              "text": "$3$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : parmi les quatre combinaisons de `a` et `b`,\n`a or b` est vraie sur 3 d'entre elles.\n"
            },
            {
              "text": "$1$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les quatre combinaisons une par une et évalue\n`a or b` sur chacune.\n"
            },
            {
              "text": "$2$ lignes",
              "correct": false,
              "feedback": "Erreur : compte seulement les lignes où `a or b` vaut 1.\n"
            },
            {
              "text": "$4$ lignes",
              "correct": false,
              "feedback": "Erreur : aucune des expressions usuelles n'est vraie sur les\nquatre lignes.\n"
            }
          ],
          "explanation": "`or` est vrai sur trois lignes sur quatre, `and` sur une seule,\n`not a` sur les deux lignes où `a` vaut 0."
        },
        {
          "statement": "Dans la table de vérité à deux variables `a` et `b`, sur combien\nde lignes l'expression `a and b` vaut-elle 1 ?",
          "options": [
            {
              "text": "$1$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : parmi les quatre combinaisons de `a` et `b`,\n`a and b` est vraie sur 1 d'entre elles.\n"
            },
            {
              "text": "$3$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les quatre combinaisons une par une et évalue\n`a and b` sur chacune.\n"
            },
            {
              "text": "$2$ lignes",
              "correct": false,
              "feedback": "Erreur : compte seulement les lignes où `a and b` vaut 1.\n"
            },
            {
              "text": "$4$ lignes",
              "correct": false,
              "feedback": "Erreur : aucune des expressions usuelles n'est vraie sur les\nquatre lignes.\n"
            }
          ],
          "explanation": "`or` est vrai sur trois lignes sur quatre, `and` sur une seule,\n`not a` sur les deux lignes où `a` vaut 0."
        },
        {
          "statement": "Dans la table de vérité à deux variables `a` et `b`, sur combien\nde lignes l'expression `not a` vaut-elle 1 ?",
          "options": [
            {
              "text": "$2$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : parmi les quatre combinaisons de `a` et `b`,\n`not a` est vraie sur 2 d'entre elles.\n"
            },
            {
              "text": "$1$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les quatre combinaisons une par une et évalue\n`not a` sur chacune.\n"
            },
            {
              "text": "$3$ lignes",
              "correct": false,
              "feedback": "Erreur : compte seulement les lignes où `not a` vaut 1.\n"
            },
            {
              "text": "$4$ lignes",
              "correct": false,
              "feedback": "Erreur : aucune des expressions usuelles n'est vraie sur les\nquatre lignes.\n"
            }
          ],
          "explanation": "`or` est vrai sur trois lignes sur quatre, `and` sur une seule,\n`not a` sur les deux lignes où `a` vaut 0."
        }
      ]
    },
    {
      "id": "q35",
      "difficulty": 3,
      "skills": [
        "table-de-verite",
        "equivalence",
        "de-morgan"
      ],
      "title": "Deux expressions, une même table",
      "partie": "tables",
      "statement": "Quelle expression a exactement la même table de vérité que\n`not (a and b)` ?",
      "options": [
        {
          "text": "`not a or not b`",
          "correct": true,
          "feedback": "Bonne réponse : les deux expressions sont fausses uniquement\nquand `a` et `b` valent toutes deux 1. C'est la seconde loi de\nDe Morgan.\n"
        },
        {
          "text": "`not a and not b`",
          "correct": false,
          "feedback": "Erreur : cette expression n'est vraie que si `a` et `b` valent\ntoutes deux 0, alors que `not (a and b)` est vraie sur trois\nlignes.\n"
        },
        {
          "text": "`a or b`",
          "correct": false,
          "feedback": "Erreur : `a or b` est fausse pour `a=0, b=0`, là où\n`not (a and b)` est vraie.\n"
        },
        {
          "text": "`not a and b`",
          "correct": false,
          "feedback": "Erreur : pour `a=1, b=0`, `not a and b` vaut 0 et\n`not (a and b)` vaut 1.\n"
        }
      ],
      "explanation": "Deux expressions sont équivalentes si leurs tables coïncident sur\ntoutes les lignes. Les lois de De Morgan sont les équivalences les\nplus utiles pour simplifier une négation."
    },
    {
      "id": "q36",
      "difficulty": 3,
      "skills": [
        "table-de-verite",
        "trois-variables",
        "denombrement"
      ],
      "title": "Lignes vraies à trois variables",
      "partie": "tables",
      "statement": "Dans la table de vérité à trois variables `a`, `b` et `c`, qui\ncompte huit lignes, sur combien de lignes l'expression `a and (b or c)`\nvaut-elle 1 ?",
      "options": [
        {
          "text": "$3$ lignes",
          "correct": true,
          "feedback": "Bonne réponse : en fixant d'abord la valeur de `a`, on compte\nles combinaisons de `b` et `c` qui rendent `a and (b or c)` vraie, soit\n3 lignes au total.\n"
        },
        {
          "text": "$5$ lignes",
          "correct": false,
          "feedback": "Erreur : reprends les huit combinaisons, en séparant les cas\n`a=0` et `a=1`.\n"
        },
        {
          "text": "$2$ lignes",
          "correct": false,
          "feedback": "Erreur : vérifie chaque combinaison de `b` et `c` pour la\nvaleur de `a` qui rend l'expression possible.\n"
        },
        {
          "text": "$8$ lignes",
          "correct": false,
          "feedback": "Erreur : une expression vraie sur les huit lignes serait une\ntautologie, ce qui n'est pas le cas ici.\n"
        }
      ],
      "explanation": "Avec trois variables, fixer l'une d'elles ramène à deux tables de\nquatre lignes, plus faciles à dénombrer.",
      "variants": [
        {
          "statement": "Dans la table de vérité à trois variables `a`, `b` et `c`, qui\ncompte huit lignes, sur combien de lignes l'expression `a and (b or c)`\nvaut-elle 1 ?",
          "options": [
            {
              "text": "$3$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : en fixant d'abord la valeur de `a`, on compte\nles combinaisons de `b` et `c` qui rendent `a and (b or c)` vraie, soit\n3 lignes au total.\n"
            },
            {
              "text": "$5$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les huit combinaisons, en séparant les cas\n`a=0` et `a=1`.\n"
            },
            {
              "text": "$2$ lignes",
              "correct": false,
              "feedback": "Erreur : vérifie chaque combinaison de `b` et `c` pour la\nvaleur de `a` qui rend l'expression possible.\n"
            },
            {
              "text": "$8$ lignes",
              "correct": false,
              "feedback": "Erreur : une expression vraie sur les huit lignes serait une\ntautologie, ce qui n'est pas le cas ici.\n"
            }
          ],
          "explanation": "Avec trois variables, fixer l'une d'elles ramène à deux tables de\nquatre lignes, plus faciles à dénombrer."
        },
        {
          "statement": "Dans la table de vérité à trois variables `a`, `b` et `c`, qui\ncompte huit lignes, sur combien de lignes l'expression `a or (b and c)`\nvaut-elle 1 ?",
          "options": [
            {
              "text": "$5$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : en fixant d'abord la valeur de `a`, on compte\nles combinaisons de `b` et `c` qui rendent `a or (b and c)` vraie, soit\n5 lignes au total.\n"
            },
            {
              "text": "$3$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les huit combinaisons, en séparant les cas\n`a=0` et `a=1`.\n"
            },
            {
              "text": "$6$ lignes",
              "correct": false,
              "feedback": "Erreur : vérifie chaque combinaison de `b` et `c` pour la\nvaleur de `a` qui rend l'expression possible.\n"
            },
            {
              "text": "$8$ lignes",
              "correct": false,
              "feedback": "Erreur : une expression vraie sur les huit lignes serait une\ntautologie, ce qui n'est pas le cas ici.\n"
            }
          ],
          "explanation": "Avec trois variables, fixer l'une d'elles ramène à deux tables de\nquatre lignes, plus faciles à dénombrer."
        },
        {
          "statement": "Dans la table de vérité à trois variables `a`, `b` et `c`, qui\ncompte huit lignes, sur combien de lignes l'expression `not a and b`\nvaut-elle 1 ?",
          "options": [
            {
              "text": "$2$ lignes",
              "correct": true,
              "feedback": "Bonne réponse : en fixant d'abord la valeur de `a`, on compte\nles combinaisons de `b` et `c` qui rendent `not a and b` vraie, soit\n2 lignes au total.\n"
            },
            {
              "text": "$4$ lignes",
              "correct": false,
              "feedback": "Erreur : reprends les huit combinaisons, en séparant les cas\n`a=0` et `a=1`.\n"
            },
            {
              "text": "$3$ lignes",
              "correct": false,
              "feedback": "Erreur : vérifie chaque combinaison de `b` et `c` pour la\nvaleur de `a` qui rend l'expression possible.\n"
            },
            {
              "text": "$8$ lignes",
              "correct": false,
              "feedback": "Erreur : une expression vraie sur les huit lignes serait une\ntautologie, ce qui n'est pas le cas ici.\n"
            }
          ],
          "explanation": "Avec trois variables, fixer l'une d'elles ramène à deux tables de\nquatre lignes, plus faciles à dénombrer."
        }
      ]
    },
    {
      "id": "q37",
      "difficulty": 2,
      "skills": [
        "absorption",
        "simplification"
      ],
      "title": "La loi d'absorption",
      "partie": "proprietes",
      "statement": "À quoi se simplifie l'expression `a or (a and b)` ?",
      "options": [
        {
          "text": "`a`",
          "correct": true,
          "feedback": "Bonne réponse : si `a` est vrai, le `or` l'est ; si `a` est\nfaux, `a and b` l'est aussi. Le résultat ne dépend que de `a`.\n"
        },
        {
          "text": "`a and b`",
          "correct": false,
          "feedback": "Erreur : pour `a=1, b=0`, l'expression vaut 1 alors que\n`a and b` vaut 0.\n"
        },
        {
          "text": "`a or b`",
          "correct": false,
          "feedback": "Erreur : pour `a=0, b=1`, l'expression vaut 0 alors que\n`a or b` vaut 1.\n"
        },
        {
          "text": "`b`",
          "correct": false,
          "feedback": "Erreur : la valeur de `b` n'influence jamais le résultat.\n"
        }
      ],
      "explanation": "Absorption : `a or (a and b)` vaut `a`, et de même\n`a and (a or b)` vaut `a`. Une table de vérité le confirme en\nquatre lignes."
    },
    {
      "id": "q38",
      "difficulty": 1,
      "skills": [
        "not",
        "double-negation"
      ],
      "title": "La double négation",
      "partie": "proprietes",
      "statement": "À quoi est équivalente l'expression `not (not a)` ?",
      "options": [
        {
          "text": "`a`",
          "correct": true,
          "feedback": "Bonne réponse : nier deux fois revient au point de départ,\ncomme « il n'est pas faux que » signifie « il est vrai que ».\n"
        },
        {
          "text": "`not a`",
          "correct": false,
          "feedback": "Erreur : deux négations s'annulent, il n'en reste aucune.\n"
        },
        {
          "text": "`False`",
          "correct": false,
          "feedback": "Erreur : le résultat dépend de `a`, il n'est pas constant.\n"
        },
        {
          "text": "`True`",
          "correct": false,
          "feedback": "Erreur : pour `a` faux, `not (not a)` vaut `False`.\n"
        }
      ],
      "explanation": "La double négation est la plus simple des règles de\nsimplification : `not not a` se réduit à `a`."
    }
  ]
}