TP 3 : Résolution
Judicaël Courant 2018-w45-4
Le but de cet exercice est de réaliser un outil permettant de tester la satisfiabilité de formules en forme normale conjonctive.
À permutation près et suppression des clauses en doublon, une formule en forme normale conjonc- tive peut être représentée comme un simple ensemble de clauses. Dans la suite, on s’intéressera donc à des ensembles de clauses qu’on représentera en Caml par des listes (tout en s’autorisant à tout moment à réordonner les listes, l’ordre relatif des éléments ne nous intéressant pas). On dira qu’un ensemble ou une liste de clauses est satisfiable si leur conjonction l’est.
Étant donné une variableaet une clauseC=`1∨. . .∨`n, on dit queaapparaît positivementdans Csiaest l’un des`i et queaapparaît négativement dansC si¬aest l’un des`i. On noterapos(C) l’ensemble des atomes apparaissant positivement dansCetneg(C)l’ensemble de ceux y apparaissant négativement.
On généralise cette notion aux ensembles de clauses (ou aux formes normales conjonctives si l’on préfère) : on dit qu’un atome apparaît positivement (négativement) dans un ensemble de clausesEs’il apparaît positivement (resp. négativement) dans l’une de ces clauses et on notepos(E)(resp.neg(E)) l’ensemble des atomes apparaissant positivement (resp. négativement) dansE.
À permutation près des littéraux et suppression des éventuels doublons, une clauseCest détermi- née de façon unique par la donnée du couple(pos(C),neg(C)). Plus précisément, sia1, . . . ,ap sont les éléments depos(C)etb1, . . . ,bqsont ceux deneg(C), on a
C ≡(b1∧. . .∧bq)⇒(a1∨. . .∨ap)
Cela nous conduit à représenter les clauses comme des couples d’ensembles d’atomes. Ainsi, dans le fichierresolution.mltéléchargeable sur le site du cours, on trouvera :
hresolution.mli≡
type atome == string;;
type clause = {
p : atome list; (* atomes apparaissant positivement *) n : atome list; (* atomes apparaissant négativement *) };;
type clauses = { liste : clause list; };;
On rappelle qu’on peut utiliser la bibliothèque Caml et notamment le modulelist.
Pour éviter les doublons, on mettra toujours les atomes dans le même ordre dans les clauses et on supprimera tout doublon. Pour cela, on utilisera les fonctions suivantes :
hresolution.mli+≡
let trie l = sort__sort (fun x y -> x <= y) l;;
(* enleve les valeurs identiques successives d’une liste Précondition : l est triée (peu importe pour quel ordre).
*)
let rec enleve_doublons l = match l with
| [] -> []
| [x] -> [x]
| x :: y :: r -> if x = y then enleve_doublons (y::r) else x::enleve_doublons (y::r)
;;
(* met sous forme canonique un ensemble. Pour cela, le trie puis enlève les doublons: *)
let ensemble l = enleve_doublons (trie l);;
(* construit une clause en s’assurant que celle-ci est bien sous forme canonique. *)
let cons_clause p n = { p = ensemble p; n = ensemble n; };;
(* met sous forme canonique une clause qui aurait été mal construite *) let canonise_clause { p = p; n = n; } = cons_clause p n;;
(* construit un ensemble de clauses en s’assurant que chaque clause est bien sous forme canonique et que l’ensemble est bien lui-même trié, sans doublon. *)
let cons_clauses cl = { liste = (ensemble (map canonise_clause cl)) };;
Judicaël Courant - 2018-w45-4 2/5 Document sous licence Art Libre (http://artlibre.org)
Par la suite, on s’interdit de construire directement (avec la syntaxe{ liste = ... }) des élé- ments de typeclauses: on utilisera la fonctioncons_clauses : clause list -> clausespour cela. De même, on s’interdit de construire directement des éléments de typeclause: on utilisera la fonctioncons_clause : atome list -> atome list -> clausepour cela.
On utilisera les fonctions suivantes pour afficher des clauses : hresolution.mli+≡
let print_atomes l =
do_list (fun a -> print_string " "; print_string a) l;;
let print_clause c = print_string "(conj";
print_atomes c.p;
print_string ") => (disj";
print_atomes c.n;
print_string ")\n"
;;
let print_clauses cl =
do_list (fun c -> print_clause c) cl.liste;
print_string "\n"
;;
1 Implantation
Q0 Écrire une fonctionest_tautologie : clause -> booldisant si une clause est une tauto- logie (on commencera par voir à quelle condition c’est le cas).
Q1 Écrire une fonctionsupprime_clauses_tautologiques : clauses -> clausessuppri- mant les clauses tautologiques d’une forme normale conjonctive. Après application de cette opération à une fncφ, obtient-on une fnc équisatisfiable àφ?
Étant donné deux clausesC1etC2et un atomeaapparaissant positivement dansC1et négative- ment dansC2, on appellerésolvant deC1etC2par coupure avecala clauseC3définie par
pos(C3) = (pos(C1)\ {a})∪pos(C2) neg(C3) = (neg(C2)\ {a})∪neg(C1)
Q2Montrer que si une interprétation satisfaitC1etC2, alors elle satisfait son résolvantres(C1, C2, a).
Étant donné un atomeaet un ensembleE de clauses ne comportant aucune tautologie, on peut partitionner cet ensemble en trois ensemblesP,NetOrespectivement celui des clauses oùaapparaît de façon positive, celui des clauses oùaapparaît de façon négative et celui des clauses oùan’apparaît pas.
L’ensembleobtenu à partir deEpar un pas de résolution suraest l’ensembleE0 défini par E0 =O∪ {res(C1, C2, a)|(C1, C2)∈P ×N }
Q3 Montrer que l’atomean’apparaît pas dansE0.
Q4Montrer queEest équisatisfiable àE0. On pourra montrer tout d’abord que la satisfiabilité de Eentraîne celle deE0, puis que si on dispose d’une interprétationρ des variables deE0 la satisfai- sant, l’une des deux interprétationsρ0 etρ1 obtenues en étendantρà la variableaen lui donnant respectivement la valeur0et la valeur1doit satisfaireE.
Q5 Écrire une fonctionpartionne_clauses : atome -> clauses -> clauses * clauses
* clausesdont l’application à un atomeaet à l’ensembleEretourne le triplet(P, N, O).
Q6 Écrire une fonction resolution : atome -> clauses -> clausescalculant l’ensemble des clauses obtenu à partir d’un ensemble de clausesE par un pas de résolution sur un atomea.
Q7 Écrire une fonctionsatisfiable : clauses -> booltestant la satisfiabilité d’un ensemble de clausesEen suivant l’algorithme suivant :
1. supprimer les clauses tautologiques deE;
2. si l’ensemble restant est vide, c’est terminé : l’ensemble des clauses est satisfiable ;
3. s’il n’est pas vide, considérer sa première clause ; s’il s’agit de la clause vide, alors c’est terminé : Eest insatisfiable ;
4. sinon, prendre un atome apparaissant dans cette clause et effectuer un pas de résolution sur cet atome ;
5. recommencer.
Q8Justifier que cet algorithme termine.
Q9Justifier brièvement sa correction.
Judicaël Courant - 2018-w45-4 4/5 Document sous licence Art Libre (http://artlibre.org)
2 Application
On considère un club privé écossais possédant des règles très strictes : 1. Tout membre non écossais porte des chaussettes rouges ;
2. Tout membre porte un kilt ou ne porte pas des chaussettes rouges ; 3. Les membres mariés ne sortent pas le dimanche ;
4. Un membre sort le dimanche si et seulement si il est écossais.
5. Tout membre qui porte un kilt est marié et écossais.
6. Tout membre écossais porte un kilt.
Q10 Représenter chacune des règles par une formule du calcul propositionnel, en utilisant une variableEpour le fait qu’un membre est écossais,Rle fait qu’il porte des chaussettes rouges,K le fait qu’il porte un kilt,M le fait qu’il est marié,Dle fait qu’il sort le dimanche.
Q11 Donnez, pour chacune de ces règles, une formule en forme normale conjonctive qui lui est équivalente.
Q12Utilisez le programme que vous avez écrit précédemment pour tester si les conditions données sont satisfiables.
