Le but de ce TP est de réaliser en Java un gestionnaire de formules logiques qui permettra de saisir des formules et de réaliser certaines opérations comme le calcul de leur valeur ou encore leur mise en forme normale.

Vous avez toute liberté pour réaliser les demandes de ce projet du moment que vous respectez les contraintes suivantes:

• Le travail sera obligatoirement réalisé en groupe de 3 étudiants. Les groupes ne comprenant pas 3 étudiants ne seront pas évalués.
• Le projet doit être réalisé en Java
• La représentation des données et les algorithmes demandés doivent être complètement implantés et, sauf mention contraire, ne doivent pas déléguer leur traitement à une librairie.

Le résultat du TP sera évalué par une rapide présentation des fonctionnalités à l'enseignant et par une étude du code a postériori.

Utilisation d'outils d'aide par l'IA

L'utilisation d'outils d'aide d'IA (ChatGPT, Copilot, Grok, ...) sera intégrée à la notation de la façon suivante:

• Un travail rendu sans aucune aide d'IA sera noté sur une base de 100%
• Un travail réalisé avec l'aide d'IA et déclaré comme tel sera noté sur une base de 70%
• Un travail rendu, réalisé avec l'aide de l'IA sans que cela soit explicitement déclaré sera noté sur une base de 50%

1. Représentation de formules propositionnelles

Implanter en Java une représentation de formules propositionnelles. Cette représentation doit permettre les fonctionnalités détaillées dans les points ci-dessous.

1.1. Représentation (2pt)

Votre bibliothèque doit proposer au moins:

• une classe ou interface Formula permettant de représenter un formule propositionnelle
• une classe ou interface Var permettant de représenter une variable propositionnelle
• une classe ou interface VariableSet qui permettra de lister de façon unique toutes les variables présentent dans la formule étudiée
• une classe ou interface Interpretation permettant d'associer à chaque variable du VariableSet une valeur booléenne

La hiérarchie de classe que vous concevrez pourra être plus complexe que seulement les classes Formula et Var. Penser à la façon de représenter les connecteurs ($\neg{}, \wedge{}, \vee{}, \rightarrow{}$ et $\leftrightarrow{}$) et choisissez une structure sous-jacente adaptée (Arbre, Graphe, Tableaux, ....)

1.2. Instanciation de Formule (2pt)

Il doit être possible pour un développeur utilisant vos classes de créer n'importe quelle formule propositionnelle à partir de votre API de façon programmatique.

Exemple

L'instruction:

Formule f = equiv(and(or(not(var("a")), var("b")), imp(var("c"), var("d"))), or(var("a"), var("d")));

permet de créer programmatiquement la formule $(((\neg{}a\vee{}b)\wedge{}(c\rightarrow{}d))\leftrightarrow{}(a\vee{}d))$

1.3. Affichage d'une formule (1 pt)

bibliothèque doit permettre d'afficher une instance de Formula sur la console en utilisant une notation textuelle des opérateurs tels que:

• $\neg{}A$ sera affiché !A
• $A\wedge{}B$ sera affiché A & B
• $A\vee{}B$ sera affiché A | B
• $A\rightarrow{}B$ sera affiché A -> B
• $B\leftrightarrow{}B$ sera affiché A <-> B

Exemple

Les instructions:

Formula f = equiv(and(or(not(var("a")), var("b")), imp(var("c"), var("d"))), or(var("a"), var("d")));
System.out.println("F: "+f);

doivent afficher:

F: (((!a | b) & (c -> d)) <-> (a | d))

1.4. Valeur d'une formule (1 pt)

La classe/interface Formula doit proposer une méthode public boolean value(Interpretation i) qui calcule la valeur de la formule pour l'interprétation i. A vous de proposer des implantations de VariableSet et d'Interprétation qui permet ce fonctionnement.

1.5. Interprétations d'une formule (1 pt)

Une instance de la classe/interface VariableSet doit contenir une fonction public List<Interpretation> getInterpretations() qui permet de créer la liste de toutes les interprétations possibles à partir des variables contenues dans l'instance de VariableSet.

2. Formes normales

Cette partie du travail est axée sur les formes normales des formules de la logique propositionnelle.

2.1. Forme Normale simple (2 pt)

La classe/interface Formula doit proposer une méthode Formula toNormalForm() qui retourne une nouvelle instance de Formula représentant la forme normale de l'instance courante.

2.2. Forme Normale Conjonctive (3 pt)

La classe/interface de Formula doit proposer une méthode Formula toCNF() qui retourne une nouvelle instance de Formula représentant la forme normale conjonctive (CNF) de l'instance courante.

2.3. Forme Normale Disjonctive (3 pt)

La classe/interface de Formula doit proposer une méthode Formula toDNF() qui retourne une nouvelle instance de Formula représentant la forme normale disjonctive (DNF) de l'instance courante.

3. Entrées / sorties

Cette partie est dédiée aux entrées / sorties pour les formules propositionnelles.

3.1. Affichage en HTML (1 pt)

bibliothèque doit permettre de récupérer, à partir d'une instance f de Formula, une chaine de caractère de type String représentant f en HTML. Pour rappel:

• $\neg{}$ correspond à l'entité HTML &not;
• $\wedge{}$ correspond à l'entité HTML &wedge;
  
• $\vee{}$ correspond à l'entité HTML &vee;
  
• $\rightarrow{}$ correspond à l'entité HTML &rightarrow;
  
• $\leftrightarrow{}$ correspond à l'entité HTML &leftrightarrow;
  

3.2. Lecture d'une formule en LaTeX (4 pt)

La bibliothèque doit permettre d'instancier une Formula à partir d'une notation LaTeX. Cela peut être réalisé par exemple à l'aide d'une méthode Formula readFromLatex(String latex) qui prend en paramètre une chaine de caractère représentant une formule écrite en LaTeX et retourne la formule correspondante comme une instance de Formula.

Les notations LaTeX pour les formules propositionnelles sont:

• $A\neg{}B$ correspond à la commande LaTeX A\neg{}B ou A\neg B
• $A\wedge{}B$ correspond à la commande LaTeX A\wedge{}B ou A\wedge B
  
• $A\vee{}B$ correspond à la commande LaTeX A\vee{}B ou A\vee B
  
• $A\rightarrow{}B$ correspond à la commande LaTeX A\rightarrow{}B ou A\rightarrow B
  
• $A\leftrightarrow{}B$ correspond à la commande LaTeX A\leftrightarrow{}B ou A\leftrightarrow B

Exemple

Les expressions latex:

(((\neg{}a\vee{}b)\wedge{}(c\rightarrow{}d))\leftrightarrow{}(a\vee{}d))

ou

(((\neg a\vee b)\wedge (c \rightarrow d))\leftrightarrow (a\vee d))

correspondent à la formule $(((\neg{}a\vee{}b)\wedge{}(c\rightarrow{}d))\leftrightarrow{}(a\vee{}d))$