La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Programmation Logique2002 Programmation en Logique FI 3 - 2002 Cours Narendra Jussien TP Romuald Debruyne / Narendra Jussien.

Présentations similaires


Présentation au sujet: "Programmation Logique2002 Programmation en Logique FI 3 - 2002 Cours Narendra Jussien TP Romuald Debruyne / Narendra Jussien."— Transcription de la présentation:

1 Programmation Logique2002 Programmation en Logique FI Cours Narendra Jussien TP Romuald Debruyne / Narendra Jussien

2 Programmation LogiqueNJ /127 Organisation du module n Enseignement l Cours/TD 50% l TP sur machine50% Langage support PROLOG n Évaluations l Micro-évaluation (TD noté) l Contrôle continu (envoi du code à chaque fin de TP) l TP noté en fin de module

3 Programmation Logique2002 Introduction

4 Programmation LogiqueNJ /127 Classes de langage l séquencement des calculs spécifié –contrôle total du flot dexécution l objets du langage diversifiés –syntaxe riche (lourde :-) ) l exemples : Pascal, C, C+, C++, Java, … n Langages impératifs n Langages fonctionnels l tout est fonction –syntaxe dépouillée –base mathématique forte : -calcul l contrôle délégué à linterprète –utilisation intensive de la récursivité l exemples : Lisp, Scheme, Haskell, …

5 Programmation LogiqueNJ /127 Une nouvelle classe n PROgrammation en LOGique l tout est logique –syntaxe simple et dépouillée –base théorique : calcul des prédicats l encore plus de contrôle donné à la machine –récursion –non déterminisme l exemple : Prolog

6 Programmation LogiqueNJ /127 Historique n 1930Calcul des prédicats (J. Herbrand) n 1965Principe de résolution (J. A. Robinson) n 1970Utiliser la logique comme langage de programmation clauses de HornR. Kowalski Q-systèmesA. Colmerauer n 1972Premier interprète PROLOG (A. Colmerauer et P. Roussel) Université dAix-Marseille n 1977Premier compilateur PROLOG (D. H. D. Warren) Université dÉdimbourg n 1980Projet japonais de 5e génération n 1990PROLOG évolue vers la Programmation par Contraintes

7 Programmation LogiqueNJ /127 Plan du cours n Bases théoriques (rappels de logique formelle) l Calcul propositionnel l Calcul des prédicats n Le langage PROLOG n PROLOG avancé

8 Programmation LogiqueNJ /127 En TP, vous apprendrez à... n Utiliser PROLOG (premières séances) n Réaliser un système expert complet n Résoudre automatiquement des énigmes logiques exprimées en langage naturel

9 Programmation Logique2002 Rappels de Logique 1. Calcul propositionnel 2. Calcul des prédicats

10 Programmation LogiqueNJ / Calcul propositionnel n Comment écrire les formules ? l Aspects syntaxiques n Comment déterminer la valeur de vérité dune formule ? l Aspects sémantiques n Comment démontrer de nouveaux résultats ? l Aspects déductifs

11 Programmation LogiqueNJ /127 Syntaxe dune formule n Données l un ensemble P de variables propositionnelles P = { p, q, r, … } énoncés élémentaires l un ensemble C de connecteurs C = {,,,, } n Formules l p est une formule si p P l (H) est une formule si H est une formule l (H) (K) est une formule si H et K sont des formules et si C n Règles de suppression des parenthèses Calcul propositionnel

12 Programmation LogiqueNJ /127 Sémantique dune formule n Logique bi-valuée l faux (0) l vrai (1) n Notion dinterprétation l donner une valeur de vérité à une variable l extension à un opérateur l extension à une formule Calcul propositionnel

13 Programmation LogiqueNJ /127 Tables de vérité : opérateurs p Calcul propositionnel

14 Programmation LogiqueNJ /127 Formules particulières n Tautologies : formules toujours vraies l La table de vérité ne contient que des 1 l exemple : p p p ( p) (p p) Calcul propositionnel

15 Programmation LogiqueNJ /127 ? p q ¬ p ¬ q p q ¬ ( p q ) (¬ p ¬ q) F Calcul propositionnel

16 Programmation LogiqueNJ /127 Catégories de formules n Tautologies : formules toujours vraies n Formules inconsistantes l formules toujours fausses l la table de vérité ne contient que des 0 l exemple : p p n Formules consistantes l formules non toujours fausses Calcul propositionnel

17 Programmation LogiqueNJ /127 Formules particulières n Formules tautologiquement équivalentes l les tables de vérité sont les mêmes l Condition nécessaire et suffisante : (F) (H) est une tautologie (F) (H) Calcul propositionnel

18 Programmation LogiqueNJ /127 lois de De Morgan n Propriétés de et l associativité l distributivité (dans les 2 sens) l éléments neutres (0 pour et 1 pour ) l éléments absorbants (1 pour et 0 pour ) Quelques équivalences utiles Calcul propositionnel

19 Programmation LogiqueNJ /127 Formes normales n But avoir une représentation uniforme des formules du calcul propositionnel l limiter le nombre de connecteurs différents utilisés l limiter lallure des formules rencontrées Calcul propositionnel

20 Programmation LogiqueNJ /127 Formes normales Une formule F est dite sous forme normale disjonctive ssi F est une disjonction de conjonctions de variables propositionnelles et de leur négation Toute formule du calcul propositionnel est tautologiquement équivalente à une formule sous forme normale disjonctive Une formule F est dite sous forme normale conjonctive ssi F est une conjonction de disjonctions de variables propositionnelles et de leur négation Toute formule du calcul propositionnel est tautologiquement équivalente à une formule sous forme normale conjonctive Calcul propositionnel

21 Programmation Logique2002 Aspects déductifs n notion de conséquence logique n notion de démonstration n notion de règles de déduction Calcul propositionnel

22 Programmation LogiqueNJ /127 Conséquence logique n Soit A = {F 1, …, F n } un ensemble de n formules A G ssi (F 1 … F n ) G n Notion de réfutation l démonstration par labsurde A G ssi F 1 … F n G est inconsistante Calcul propositionnel

23 Programmation LogiqueNJ /127 Système formel n Données l un ensemble V de symboles l un ensemble F de formules (F V * ) l un ensemble A daxiomes (A F) l un ensemble fini de règles de déduction n Une démonstration dans un système formel S est une suite dénoncés A 1, … A n telle que : l pour tout i, A i est un axiome de S ou une conséquence des énoncés précédents par application dune des règles de déduction n Un théorème de S est le dernier énoncé dune démonstration Calcul propositionnel

24 Programmation LogiqueNJ /127 Énoncé déductible n Soit J un ensemble de formules n Un énoncé A est dit déductible sous les hypothèses J (noté J A) ssi l il existe une suite finie A 1, …, A n dénoncés telle que –A n = A –pour tout i l A i est un axiome l ou A i J l ou A i découle dénoncés précédents par application dune règle dinférence Calcul propositionnel

25 Programmation LogiqueNJ /127 Quelques règles de déduction classiques n modus ponens l p, p q q n modus tollens l p q, q p n syllogisme l p q, q r p r Calcul propositionnel

26 Programmation LogiqueNJ /127 Propriétés dun système formel n Un système formel est correct ssi si A alors A l tout ce qui est démontrable est vrai n Un système formel est complet ssi si A alors A l tout ce qui est vrai est démontrable Calcul propositionnel

27 Programmation LogiqueNJ /127 n Principe de résolution (Robinson) l Définitions –littéral positif ou négatif –une clause est une disjonction de littéraux –la résolvante de C 1 = l C 1 et de C 2 = l C 2 est C 1 C 2 l Principe de résolution l C 1, l C 2 réso C 1 C 2 –le principe de résolution est valide –le principe de résolution généralise les autres règles Une autre règle dinférence Calcul propositionnel

28 Programmation LogiqueNJ /127 Validité du principe de résolution n Il faut montrer que : l C 1, l C 2 C 1 C 2 ie(l C 1 ) ( l C 2 ) (C 1 C 2 ) n Il suffit de montrer que si (l C 1 ) ( l C 2 ) vrai alors (C 1 C 2 ) nest pas faux n Deux cas se présentent l l est vrai –nécessairement C 2 vrai et donc (C 1 C 2 ) aussi l l est vrai –nécessairement C 1 vrai et donc (C 1 C 2 ) aussi Calcul propositionnel

29 Programmation LogiqueNJ /127 Propriétés du calcul propositionnel n Le calcul propositionnel muni du principe de résolution est correct et complet n Un ensemble S de clauses est insatisfaisable ssi S reso n Démonstration : par labsurde (réfutation) S C ssi S {C} reso On peut toujours se ramener à une forme normale conjonctive (forme clausale) Rappel Calcul propositionnel

30 Programmation LogiqueNJ /127 Ce quil faut retenir n Intérêt dune forme normale n Conséquence logique vs démonstration n Principe de résolution n Preuve par réfutation Calcul propositionnel

31 Programmation LogiqueNJ / Calcul des prédicats n Comment écrire les formules ? l Aspects syntaxiques n Comment déterminer la valeur de vérité dune formule ? l Aspects sémantiques n Comment démontrer de nouveaux résultats ? l Aspects déductifs

32 Programmation LogiqueNJ /127 Limites du calcul propositionnel n Modéliser l Les chandelles sont faites pour éclairer l Quelques chandelles éclairent très mal l Quelques objets qui sont faits pour éclairer le font très mal Calcul des prédicats

33 Programmation LogiqueNJ /127 Une modélisation l Les chandelles sont faites pour éclairer l Quelques chandelles éclairent très mal l Quelques objets qui sont faits pour éclairer le font très mal Calcul des prédicats

34 Programmation LogiqueNJ /127 Syntaxe n des connecteurs (,,, et ) n des quantificateurs ( et ) n des variables (x,y, …) n des relations (prédicats) (R, S, éclaire, …) n des symboles de fonctions (f, g, …) l les fonctions darité 0 sont appelées des constantes Calcul des prédicats

35 Programmation LogiqueNJ /127 Vocabulaire n Les termes l les variables et les constantes sont des termes l f(t 1, …, t n ) est un terme si –les t i sont des termes –f est un symbole de fonction darité n n Les atomes l R(t 1, …, t n ) est un atome si –les t i sont des termes –R est un symbole de relation darité n Calcul des prédicats

36 Programmation LogiqueNJ /127 Formules n Un atome est une formule n Si F et G sont des formules et x une variable, alors les expressions suivantes sont des formules l(F) l (F) (G) et (F) (G) lx (F) et x (G) Calcul des prédicats

37 Programmation LogiqueNJ /127 Occurrence dune variable n Une occurrence dune variable x dans une formule F est un endroit où x apparaît dans F sans être immédiatement précédée par ou n Une occurrence libre de x dans F est définie : Calcul des prédicats

38 Programmation LogiqueNJ /127 Occurrence libre n Si F est un atome, toutes les occurrences de x sont libres n Si F = (G), les occurrences libres de x sont celles de G n Si F = (G) (H), les occurrences libres de x sont celles de G et celles de H n Si F = y(G) ou F = y(H) avec x distinct de y, les occurrences libres de x sont celles de G et celles de H n Si F = x(G) ou F = x(H), aucune occurrence de x dans F n est libre Calcul des prédicats

39 Programmation LogiqueNJ /127 Caractéristiques des variables n Une variable est dite libre dans une formule F si elle a au moins une occurrence libre (sinon on dit quelle est liée) n Une formule nayant pas de variable libre est dite close Calcul des prédicats

40 Programmation Logique2002 Aspects sémantiques n Formules universellement valides n Le théorème de Herbrand n Principe de résolution adapté au calcul des prédicats Calcul des prédicats

41 Programmation LogiqueNJ /127 Vers la notion de modèle n Soit L le langage du calcul des prédicats l une interprétation de L cest la donnée de : –un ensemble E non vide appelé ensemble de base –pour chaque symbole de prédicat R darité n, dun sous- ensemble R de E n –pour chaque symbole de fonction f darité n, dune application f de E n vers E (y compris pour les constantes) l on peut alors calculer la valeur de tout terme clos (cest un élément de E) l on peut donc associer une valeur de vérité à tout atome et donc par extension à toute formule close Calcul des prédicats

42 Programmation LogiqueNJ /127 Exemple dinterprétation nxyz (P(x,y) Q(y,z) R(x,z)) nxy ( (M(x,y) P(x,y) Q(x,y)) n M(a,b) P(c,b) P(d,a) P(e,c) n E = n P = n a = anne b = bernard c = charles d = didier e= éric est le père de M = est la mère de Q = est un parent de R = est le grand-père de { anne, bernard, …} Calcul des prédicats

43 Programmation LogiqueNJ /127 Modèle n Soit M une interprétation de L l soit F une formule close. M est un modèle de F ssi la valeur de vérité de F dans M est 1 M F l soit F(x 1, …, x k ) une formule quelconque –F est dite universellement valide ssix 1 …x k F(x 1, …, x k ) est satisfaite dans toutes les interprétations de L – F est dite insatisfaisable ssi il existe une interprétation pour laquellex 1 …x k F(x 1, …, x k ) est satisfaite Calcul des prédicats

44 Programmation LogiqueNJ /127 Preuve et démonstration n Comment prouver une formule du calcul des prédicats ? l Prouver quelle est vraie –passer en revue toutes les interprétations ! l Prouver quelle est fausse –trouver une interprétation qui invalide la formule Calcul des prédicats

45 Programmation LogiqueNJ /127 Toutes les interprétations ? n Une représentation utile des formules l forme clausale n Un théorème qui simplifie la vie l théorème de Herbrand n Principe de résolution pour le calcul des prédicats l vers une automatisation des démonstrations Calcul des prédicats

46 Programmation LogiqueNJ /127 Transformation de formule n Forme normale prénexe l quantificateurs en tête de la formule l formule sous forme normale conjonctive n Forme standard de Skolem l formule sous forme normale prénexe l quantificateurs existentiels précédant quantificateurs universels Tout formule du calcul des prédicats est équivalente à une formule sous forme standard de Skolem Calcul des prédicats

47 Programmation LogiqueNJ /127 Mise sous forme prénexe n Éliminer les connecteurs et n Transporter les devant les atomes l en utilisant ( F F) et les lois de De Morgan n Transporter les quantificateurs en tête de la formule n Ne pas hésiter à renommer les variables Calcul des prédicats

48 Programmation LogiqueNJ /127 Transport des quantificateurs si H ne contient aucune occurrence de x Calcul des prédicats

49 Programmation LogiqueNJ /127 Inversion de et de Skolemisation n Lorsquon a n on remplace y par une fonction g qui à x associe y Skolemisation = expliciter limplicite Calcul des prédicats

50 Programmation LogiqueNJ /127 Une représentation utile des formules Forme clausale n On part de la forme standard de Skolem n On utilise les clauses avec : l les variables quantifiées universellement conservées l les fonctions de Skolem conservées l les variables quantifiées existentiellement remplacées par des constantes l les variables renommées dune clause à lautre Calcul des prédicats

51 Programmation LogiqueNJ /127 Univers de Herbrand n Soit S un ensemble de clauses l Soit H 0 lensemble des symboles de constantes ayant au moins une occurrence dans S. On pose : pour f n fonction darité n de S et t j éléments de H i-1 l H = lim i H i est appelé univers de Herbrand l On appelle instance de base dune clause C toute clause obtenue en remplaçant les variables de C par des éléments de H Calcul des prédicats

52 Programmation LogiqueNJ /127 Théorème de Herbrand n Théorème Un ensemble S de clauses est insatisfaisable si et seulement si il existe un ensemble S dinstances de base insatisfaisable n Corollaire Un ensemble de clauses est satisfaisable si et seulement si tout ensemble fini dinstances de base est satisfaisable Calcul des prédicats

53 Programmation LogiqueNJ /127 A quoi ça sert ? Validation de raisonnement n On cherche à valider le raisonnement suivant l Un dragon est heureux si tous ses enfants peuvent voler l Les dragons verts peuvent voler l Un dragon est vert sil a au moins un parent vert ou rose l Donc les dragons verts sont heureux Calcul des prédicats

54 Programmation LogiqueNJ /127 Résolution du problème n Démarche générale l Modéliser le problème (les prémisses et la conclusion) l Démonstration par labsurde, on montre que P1 P2 P3 C est insatisfaisable –mettre la formule sous forme clausale –utiliser le théorème de Herbrand n Notations l h(x) : x est heureux l p(x,y) : x est parent de y l vo(x) : x vole (peut voler) l ve(x) : x est vert l r(x) : x est rose Calcul des prédicats

55 Programmation LogiqueNJ /127 Résolution du problème (suite) P1 un dragon est heureux si tous ses enfants peuvent voler P2 les dragons verts peuvent voler P3 un dragon est vert sil a au moins un parent vert ou rose C les dragons verts sont heureux les A sont B A B h(x) x(y, p(x,y)vo(y)) négation Calcul des prédicats

56 Programmation LogiqueNJ /127 Forme clausale Calcul des prédicats

57 Programmation LogiqueNJ /127 Validation du raisonnement n Univers de Herbrand l H 0 = {a}H 1 = {a, f(a)} H = {a, …, f n (a)} n Trouver un ensemble dinstances de base insatisfaisable l intuition 1 : partir de la conclusion et essayer darriver à une contradiction par déduction l intuition 2 : utiliser le principe de résolution Calcul des prédicats

58 Programmation LogiqueNJ /127 Mise en œuvre clause vide Calcul des prédicats

59 Programmation LogiqueNJ /127 Résolution n On a un ensemble dinstances de base insatisfaisable n La formule P1 P2 P3 C est donc insatisfaisable n Le raisonnement est donc valide Calcul des prédicats

60 Programmation LogiqueNJ /127 unificateur Analysons un peu les choses n Lopération dappariement de deux atomes sappelle lunification n Algorithme dunification (vu plus tard) n On peut donc appliquer le principe de résolution sans problème Calcul des prédicats

61 Programmation LogiqueNJ /127 Propriétés du calcul des prédicats n Le calcul des prédicats muni du principe de résolution et de lunification est complet l toute formule close est vraie ou fausse n MAIS le calcul des prédicats est indécidable l Il nexiste pas dalgorithme permettant de décider à tout coup si une formule close est vraie ou fausse n En PROLOG, nous nous limiterons donc à un sous-ensemble du calcul des prédicats l non restrictif en pratique Calcul des prédicats

62 Programmation LogiqueNJ /127 Programmer en logique ? n Un petit exemple lxyz (pere(x,y)parent(y,z) grand-pere(x,z) lxy ((mere(x,y) pere(x,y)) parent(x,y) l mere(a,b) pere(c,b) pere(d,a) pere(e,c) n Forme clausale lpere(x 1, y 1 ) parent(y 1, z 1 ) grand-pere(x 1,z 1 ) lmere(x 2, y 2 ) parent(x 2, y 2 ) lpere(x 3, y 3 ) parent(x 3, y 3 ) l mere(a,b) pere(c,b) pere(d,a) pere(e,c) n On veut prouver x, grand-pere(x,b) l négation sous forme clausale : grand-pere(x,b) Calcul des prédicats

63 Programmation LogiqueNJ /127 Programmer en logique ? n On part de grand-pere(x,b) l si x = x 1 et z 1 =b unification avec pere(x 1, y 1 ) parent(y 1, z 1 ) grand-pere(x 1,z 1 ) l on obtient pere(x, y 1 ) parent(y 1, b) l si y 3 = b et y 1 =x 3 unification avecpere(x 3, y 3 ) parent(x 3, y 3 ) l on obtient pere(x, x 3 ) pere(x 3, b) l si x 3 = c unification avec pere(c,b) l on obtient pere(x, c) l si x=e unification avec pere(e,c) l on obtient QED Calcul des prédicats

64 Programmation LogiqueNJ /127 Programmer en logique ? n On a réussi à prouver x, grand-pere(x,b) n On a réussi à calculer un x n Unification = calcul l on donne des valeurs aux variables n Calcul = programmation l on va pouvoir programmer avec la logique !!! l on automatise complètement le processus l PROLOG est un démonstrateur de théorème Calcul des prédicats

65 Programmation Logique2002 Le langage PROLOG 1. Premiers pas 2. Arithmétique 3. Listes 4. Le contrôle PROLOG 5. Termes structurés 6. Méta-interprétation de PROLOG

66 Programmation LogiqueNJ / Premiers pas en Prolog n On se limite aux clauses de Horn l au plus un littéral positif –un seul littéral (positif) : fait –un littéral positif et au moins un littéral négatif : règle –pas de littéral positif : requête n Elles permettent l de forcer le retour dans la base pour continuer la démonstration l de limiter le choix par clause Le langage

67 Programmation LogiqueNJ /127 Univers PROLOG n Lunivers PROLOG est une base de connaissances décrivant létat du monde à laide de relations (prédicats) portant sur des entités (termes) n Un prédicat particulier (=) correspond à lunification Le langage

68 Programmation LogiqueNJ /127 Syntaxe de PROLOG n Considérons lénoncé l Socrate est un homme l Tout homme est mortel l Socrate est-il mortel ? Calcul des prédicatsProlog x, homme(x) homme(socrate). x, homme(x) mortel(x) mortel(X) :- homme(X). ?- mortel(socrate). Le langage

69 Programmation LogiqueNJ /127 La famille masculin(tom). % tom est de sexe masculin masculin(tim). masculin(bob). masculin(jim). % «paquet» de clauses feminin(pam). feminin(liz). feminin(ann). feminin(pat). enfant(bob,pam). enfant(bob,tom). enfant(liz,tom). enfant(ann,bob). enfant(pat,bob). enfant(tim,liz). enfant(jim,pat). Le langage

70 Programmation LogiqueNJ /127 Premières requêtes masculin(tom). masculin(tim). masculin(bob). masculin(jim). feminin(pam). feminin(liz). feminin(ann). feminin(pat). enfant(bob,pam). enfant(bob,tom). enfant(liz,tom). enfant(ann,bob). enfant(pat,bob). enfant(tim,liz). enfant(jim,pat). Est-ce que pat est un enfant de bob ? ?- enfant(pat,bob). Quels sont les enfants de tom ? ?- enfant(X,tom). X = bob; Yes X = liz ; No Le langage

71 Programmation LogiqueNJ /127 Lien avec le calcul des prédicats Règles PROLOG a :- b,c,d. Règles LOGIQUE a b c d Requête PROLOG ?- q. Requête LOGIQUE q Unification Faire correspondre requête et tête de règle

72 Programmation LogiqueNJ /127 Écriture de prédicats Qui est le père de bob ? ?- enfant(bob,X), masculin(X). masculin(tom). masculin(tim). masculin(bob). masculin(jim). feminin(pam). feminin(liz). feminin(ann). feminin(pat). enfant(bob,pam). enfant(bob,tom). enfant(liz,tom). enfant(ann,bob). enfant(pat,bob). enfant(tim,liz). enfant(jim,pat). X=pam échecretour X=tom Plus généralement pere(X,Y) :- enfant(Y,X), masculin(X). Écrire le prédicat mere/2 Le langage

73 Programmation LogiqueNJ /127 À chacun son tour n Écrire les prédicats correspondant aux relations l grand-pere/2 l frere/2 l tante/2 l cousin/2 Le langage

74 Programmation LogiqueNJ /127 PROLOG n PROLOG est un langage déclaratif on spécifie les propriétés du résultat du programme et non pas le processus pour arriver à ce résultat (aspect opérationnel) n Intérêts l facilité de compréhension l facilité décriture Le langage

75 Programmation LogiqueNJ /127 Retour sur le retour arrière n Considérons la requête l ?- frere(bob,liz). masculin(tom). masculin(tim). masculin(bob). masculin(jim). feminin(pam). feminin(liz). feminin(ann). feminin(pat). enfant(bob,pam). enfant(bob,tom). enfant(liz,tom). enfant(ann,bob). enfant(pat,bob). enfant(tim,liz). enfant(jim,pat). frere(X,Y) :- masculin(X), enfant(X,Z), enfant(Y,Z). X = bob, Y = liz Z=pam échec Yes Z = tom retour Le mécanisme de retour-arrière (backtrack) assure la complétude de la recherche Demander une nouvelle solution revient à provoquer un échec fictif pour forcer le backtrack Le langage

76 Programmation LogiqueNJ /127 Quelques propriétés n la recherche réalisée par PROLOG est une recherche en profondeur dabord n on peut obtenir plusieurs solutions pour une même requête l on appelle cela le non-déterminisme de PROLOG n un prédicat peut servir à autre chose que ce pour quoi il a été écrit l on appelle cela la réversibilité de PROLOG n les seuls résultats possibles : yes ou no l pas de fonction, les réponses sont obtenues par unification uniquement Le langage

77 Programmation LogiqueNJ /127 Récursivité n Écrire le prédicat ascendant/2 ascendant(X,Y) :- enfant(Y,X). ascendant(X,Z) :- enfant(Z,Y), ascendant(X,Y). Condition darrêt en premier Information discriminante en premier Le langage

78 Programmation LogiqueNJ /127 PROLOG = logique ? n Soit une relation binaire r. Comparer : l récursion droite fermeture(X,Y) :- r(X,Y). fermeture(X,Z) :- r(X,Y), fermeture(Y,Z). l récursion gauche fermeture(X,Y) :- r(X,Y). fermeture(X,Z) :- fermeture(Y,Z), r(X,Y). n Attention à la procédure de recherche !!! l Règle de sélection du but –le plus à gauche l Règle de sélection de la clause –la première Le langage

79 Programmation LogiqueNJ / Arithmétique n Les opérateurs usuels existent : +,, /, mod l attention il sagit de symboles de fonctions !!! ?- X = X= 1+2 +(1,2) Un opérateur spécial is ?- X is X = 3 Largument de droite doit être complètement instancié à lappel ?- X is 1 + Y. {INSTANTIATION ERROR} Le langage

80 Programmation LogiqueNJ /127 Opérateurs arithmétiques n > et < n >= et =< n =:= égalité numérique n =\= diségalité numérique attention : les deux arguments doivent être instanciés à lappel Le langage

81 Programmation LogiqueNJ /127 Exemple: calcul du PGCD n Propriétés du PGCD D de X et Y l si X et Y sont égaux, D vaut X l si X < Y alors D est le PGCD de X et de Y - X l si Y < X alors échanger le rôle de X et Y pgcd(X, Y, D) :- X =:= Y, D is X. X=YX=Y X X ). pgcd(X, Y, D) :- X < Y, pgcd(X,Y-X,D). Y1 is Y - X, pgcd(X,Y1,D). pgcd(X, Y, D) :- X > Y, pgcd(Y,X,D). oui, mais que se passe-t-il avec pgcd(1,1,2). Le langage

82 Programmation LogiqueNJ /127 Attention … l X = Y réussit si X sunifie avec Y sinon échec l X is Y réussit si Y est une expression arithmétique complètement instanciée à lappel et X est une variable libre sinon il y a erreur l X =:= Y réussit si X et Y sont deux expressions arithmétiques de même valeur sinon, il y a échec ou erreur selon le cas l X == Y réussit si les termes sont identiques (pas simplement unifiables) l X \== Y réussit si les termes ne sont pas identiques Le langage

83 Programmation LogiqueNJ / Listes n La liste vide : [] n Les listes non vides : l [a, b, c] l [a, [b, c], d] n Le constructeur de listes : | l [Tete | Reste] l [a] [a | [] ] l [a, b] [a | [b |[]]] [a | [b] ] n Analogie avec Haskell l | = : l représentation arborescente Le langage

84 Programmation LogiqueNJ /127 Analogie avec Haskell n A-t-on besoin de head et tail ? l ?- [1,2,3,4] = [H|T]. n On ne dispose pas des listes en compréhension l pas réellement un problème Le langage

85 Programmation LogiqueNJ /127 Prédicats de base n Longueur dune liste : length/2 length([], 0). length([_ | Xs], N1) :- length(Xs, N), N1 is N + 1. n Appartenance à une liste : member/2 member(X, [X|Ys]). member(X, [Y |Xs]) :- member(X,Xs). Ys ne sert à rien _ Y ne sert à rien _ Le langage

86 Programmation LogiqueNJ /127 Prédicats de base (suite) n Suppression dun élément dune liste : efface/3 efface(_, [], []). efface(X,[X|Ys], Ys). efface(X,[Y|Ys], [Y|Zs]) :- X \== Y, efface(X,Ys,Zs) Comment effacer toutes les occurrences dun élément ? Le langage

87 Programmation LogiqueNJ /127 Prédicats de base (suite) n Concaténation de deux listes: append/3 append([], Ys, Ys). append([X|Xs], Ys, [X|Zs]) :- append(Xs,Ys,Zs). n Une nouvelle version de member ? member(X,L) :- append(_, [X|_], L). Le langage

88 Programmation LogiqueNJ /127 Prédicats de base (suite) n Renversement dune liste : reverse/2 reverse([], []). reverse([X|Xs], Ys) :- reverse(Xs,Zs), append(Zs, [X], Ys). n Une autre version de reverse ? nreverse([], L, L). nreverse([X|Xs], Ys, L) :- nreverse(Xs, [X|Ys], L). nreverse(Xs, Ys) :- nreverse(Xs, [], Ys). Le langage

89 Programmation LogiqueNJ /127 Un prédicat plus délicat n Permutation dune liste : permute/2 insere(X,Ys,[X|Ys]). insere(X,[Y|Ys], [Y|Zs]) :- insere(X,Ys,Zs). permute([], []). permute([X|Xs], Ys) :- permute(Xs,Zs), insere(X,Zs,Ys). Le langage

90 Programmation LogiqueNJ /127 A vous de jouer ! n Les mutants … mutant(Nouveau) :- animal(A1), animal(A2), A1 \== A2, name(A1,L1), name(A2,L2), append(_, [X|Xs], L1), append([X|Xs], Fin, L2), append(L1, Fin, Mutant), name(Nouveau,Mutant). Le langage

91 Programmation LogiqueNJ / Le contrôle PROLOG n Contrôle du backtrack l Soit une fonction f dont une définition Prolog peut être : f(X, 0) :- X < 3. f(X, 2) :- 3 =< X, X < 6. f(X, 4) :- 6 =< X. l Que se passe-t-il si on pose la question ? ?- f(1,Y), 2 < Y. Le langage

92 Programmation LogiqueNJ /127 ?- f(1,Y), 2 < Y. f(X, 0) :- X < 3. f(X, 2) :- 3 =< X, X < 6. f(X, 4) :- 6 =< X. Démonstration de f(1,Y) Première règle : Y = 0 Démonstration de 2 < Y :- échec Deuxième règle : échec Troisième règle : échec Le langage

93 Programmation LogiqueNJ /127 La coupure : ! n On appelle but père le but ayant permis dunifier la clause contenant la coupure (! cut) n Leffet du cut est de couper tous les points de choix restant depuis le but père. Les autres alternatives restent en place f(X, 0) :- X < 3, !. f(X, 2) :- 3 =< X, X < 6, !. f(X, 4) :- 6 =< X. n ?- f(7,Y). Le langage

94 Programmation LogiqueNJ /127 Si … alors … sinon n Le cut peut servir à exprimer des conditions mutuellement exclusives et ainsi simplifier lécriture n La clause suivant un cut peut être considérée comme un sinon f(X, 0) :- X < 3, !. f(X, 2) :- X < 6, !. f(X, 4). n ?- f(1,2). Le langage

95 Programmation LogiqueNJ /127 Un usage délicat n Green cut : la sémantique déclarative du programme nest pas modifiée l on peut enlever le cut le programme fonctionnera toujours n Red cut : la sémantique déclarative du programme est modifiée l Le retrait du cut conduit à un programme au fonctionnement erroné l Généralement, la version avec cut peut être prise en défaut Le langage

96 Programmation LogiqueNJ /127 Autres prédicats de contrôle n true est un but qui réussit toujours l p(a,b). p(a,b) :- true. n fail est un but qui échoue toujours n call(X) est un méta but. Il considère X comme un but et essaie de le résoudre. l ?- Y=b, X=member(Y, [a,b,c]), call(X). Yes l Note: call(X) X dans Sicstus Prolog. Le langage

97 Programmation LogiqueNJ /127 Application : négation n Expression de la négation en Prolog l different(X, Y) :- X = Y, !, fail. different(X, Y). n Un prédicat plus général : l not(P) :- P, !, fail. not(_). Le langage

98 Programmation LogiqueNJ /127 Problèmes avec le not ! n ?- q(X), p(X). n ?- p(X), q(X). r(a). q(b). p(X) :- not( r(X) ). Le langage

99 Programmation LogiqueNJ /127 Théorie du monde clos n not(X) l ne veut pas dire –X est toujours faux l veut simplement dire –Je nai pas assez dinformation pour prouver X n Prolog considère ce qui nest pas vrai comme faux et vice-versa l cest la théorie du monde clos n A quoi peut servir : not(not(P)) ? Le langage

100 Programmation LogiqueNJ /127 Typage en Prolog n var/1, nonvar/1 n integer/1, float/1, number/1 n atom/1, string/1, atomic/1 n compound/1 n ground/1 Le langage

101 Programmation LogiqueNJ / Termes structurés n Notion de foncteur famille( indiv(tom, fox, date(7, mai, 1950), travail(emn, 7850)), indiv(ann, fox, date(9, mai, 1951), sans-emploi), [ indiv(pat, fox, date(5, mai, 1973), sans-emploi), indiv(jim, fox, date(5, mai, 1973), sans-emploi) ]) On pourrait utiliser des listes (de listes …) mais on préfère structurer linformation Le langage

102 Programmation LogiqueNJ /127 Utilisation de lunification n Les familles à trois enfants : famille(_,_,[_,_,_]). n Les femmes mariées ayant au moins trois enfants l famille(_,indiv(Prenom, Nom,_,_), [_,_,_|_]). famille( indiv(tom, fox, date(7, mai, 1950), travail(emn, 7850)), indiv(ann, fox, date(9, mai, 1951), sans-emploi), [ indiv(pat, fox, date(5, mai, 1973), sans-emploi), indiv(jim, fox, date(5, mai, 1973), sans-emploi) ]) Le langage

103 Programmation LogiqueNJ /127 Outils de manipulation n Consultation de termes structurés l functor/3 ?- functor(date(9, janvier, 1973), F, A) F = date, A = 3 l arg/3 ?- arg(3, date(9, janvier, 1973), F) F = 1973 n Construction/déconstruction de termes structurés l =../2 ?- X =.. [date, 9, janvier, 1973] X = date(9, janvier, 1973) Le langage

104 Programmation LogiqueNJ /127 Opérateurs n On peut définir de nouveaux opérateurs. Il ne sagit que dune définition syntaxique pour faciliter lécriture de termes. :- op(80, fy, non). :- op(100, yfx, et). n non a et b est devenu un terme valide, il est équivalent à et(non(a), b) Le langage

105 Programmation LogiqueNJ /127 Fonctionnement n Un opérateur possède une précédence ( ) l par exemple : + a une plus forte précédence que / car a+b/c se lit a+(b/c) n Un opérateur possède une politique de résolution des ambiguïtés : l xfx correspond aux opérateurs infixes non associatifs les deux sous-expressions ont un niveau de précédence inférieur à celui de lopérateur l xfy correspond aux opérateurs associatifs à droite seule lexpression de gauche doit avoir un niveau inférieur à lopérateur l yfx correspond aux opérateurs associatifs à gauche Le langage

106 Programmation LogiqueNJ / Méta-interprétation n Méta-programmation l écrire des programmes qui analysent, transforment et simulent dautres programmes n Prolog est un langage adapté à la méta- programmation car : l il y a identité entre programme et données Le langage

107 Programmation LogiqueNJ /127 Méta-interprétation n Un méta-interprète dun langage donné est un interprète du langage écrit dans le même langage n Le prédicat prouve(But) réussit si la requête But par rapport au programme que lon cherche à interpréter n Le plus simple des méta-interprètes Prolog prouve(But) :- But. Le langage

108 Programmation LogiqueNJ /127 Outils pour la méta-interprétation n Le prédicat clause/2 (accès aux programmes) append([],X,X). append([X|Xs], Ys, [X|Zs]) :- append(Xs,Ys,Zs). X = [], Y = _A1, Z=_A2, Corps = true ? ; X = [_A1|_A2], Y = _A3, Z = [_A1|_A4], Corps = append(_A2, _A3, _A4) ? ; no ?- clause(append(X,Y,Z), Corps). Le langage

109 Programmation LogiqueNJ /127 Un premier interprète prouve( true ). prouve( (A,B) ) :- prouve(A), prouve(B). prouve( But ) :- clause(But, Corps), prouve(Corps). Le langage

110 Programmation LogiqueNJ /127 Améliorations n Gestion des prédicats prédéfinis prouve( But ) :- predefini( But ), predefini( _ = _ ). But. predefini( _ is _ ). n Gestion explicite de lunification prouve( But ) :- But =.. [Foncteur|Arguments], Tete =.. [Foncteur|AutresArguments], clause(Tete, Corps), unification(But, Tete), prouve(Corps). Le langage

111 Programmation LogiqueNJ /127 Algorithme dunification unification( X, Y) :- var(X), !, Y = X. % nooccur(X,Y) unification( X, Y) :- var(Y), !, X = Y. % nooccur(Y,X) unification( X, Y) :- atomic(X), atomic(Y), X == Y. unification( X, Y) :- X =.. [Foncteur|Arguments], Y =.. [Foncteur|AutresArguments], unificationListe(Arguments, AutresArguments). unificationListe([], []). unificationListe([X|Xs], [Y|Ys]) :- unification(X,Y), unficationListe(Xs,Ys). Le langage

112 Programmation LogiqueNJ /127 Le test doccurrence n Théoriquement, lors dune unification il faut réaliser le test doccurrence. Prolog ne le fait pas. En particulier : ?- X = f(X). réussit mais ne peut afficher de résultat ! n Exercice : écrire le test doccurrence en Prolog Le langage

113 Programmation LogiqueNJ /127 nooccur/2 noccur( _, Y) :- ground(Y). noccur( X, Y) :- var(Y), X \== Y. noccur( X, Y) :- Y =.. [_|Arguments], nooccurListe(X, Arguments). nooccurListe(_, []). nooccurListe(X, [Y|Ys]) :- nooccur(X,Y), nooccurListe(X,Ys). Le langage

114 Programmation Logique2002 PROLOG avancé 1. Structures incomplètes 2. Listes de solutions 3. Modifications de la base 4. Indexation de clauses

115 Programmation LogiqueNJ / Structures incomplètes n Concaténation l Notoirement inefficace ! l Le problème –pas de « pointeur » sur le dernier élément –pas de possibilité de modification dune variable logique l uniquement instanciation dune inconnue Prolog avancé append([], Ys, Ys). append([X|Xs], Ys, [X|Zs]) :- append(Xs,Ys,Zs).

116 Programmation LogiqueNJ /127 Une solution : listes de différences n Une nouvelle structure de liste l idée : conserver une partie inconnue pour instanciation au dernier moment l Liste de différence –on nomme la fin de la liste –[a,b,c] est représentée par [a,b,c|Xs]-Xs –la liste vide Xs-Xs l Concaténation en une opération append(Ls-Xs, Xs-Rs, Ls-Rs). ?- append([a,b,c|Xs]-Xs, [1,2,3|Ys]-Ys, R). R = [a,b,c,1,2,3|Ys]-Ys Prolog avancé

117 Programmation LogiqueNJ /127 Une opération !?! Ls - Xs a b c ? ? ? ? ? ? Xs - Rs ? ? ? - ? ? ? Ls - Rs a b c ? ? ? - ? ? ? Merci lunification ! Prolog avancé

118 Programmation LogiqueNJ / Listes de solutions l On veut la liste de tous les enfants de tarzan et leur âge. l pere(tarzan, X), age(X,A) ne donne les solutions quune par une l Comment les récupérer toutes dans une liste ? pere(tarzan, fils). pere(tarzan, fille). age(fils, 5). age(fille, 2). age(tarzan, 25). Prolog avancé

119 Programmation LogiqueNJ /127 Prédicats « toutes solutions » l setof/3 résultat trié (fail si pas de solution) l bagof/3 résultat tel que le backtrack (fail si pas de solution) l findall/3 résultat tel que le backtrack ([] si pas de solution) ?- setof(X/A, (pere(tarzan, X), age(X,A)), L). L = [fils/5, fille/2] findall(X, member(X/Y, [b/1, a/2]), L) --> [b,a] setof(X, member(X/Y, [a/1, b/2]), L --> L=[b] Y=1 ; L=[a] Y=2 setof(X, Y^member(X/Y, [b/1, a/2]), L) --> [a,b] Prolog avancé

120 Programmation LogiqueNJ / Modifications de la base n Besoin : résistance au backtrack n Ajout dans la base l assert/1 l asserta/1 l assertz/1 n Retrait dans la base l retract/1 l retractall/1 Prolog avancé

121 Programmation LogiqueNJ / Indexation de clause n Les clauses Prolog sont rangées dans une hashtable. Elles sont indexées par le foncteur et larité de leur premier argument n Pour écrire des programmes plus efficaces, mettre en tête largument le plus discriminant. Prolog avancé

122 Programmation Logique2002 Bilan 1. Cours 2. Travaux pratiques 3. A quoi ça sert ?

123 Programmation LogiqueNJ /127 Bilan du cours n Rappels de logique n Comment programmer avec la logique n Le langage PROLOG n Subtilités du langage Bilan

124 Programmation LogiqueNJ /127 Bilan des TP n TP-1/TP-2: Mise en route, manipulations l écriture rapide de fonctions sur les listes l écriture rapide de petits outils n TP-3: Résolution dénigmes logiques/de réflexion l tester des idées, l résoudre des problèmes non triviaux n TP-4: Écriture dun système expert complet l 4 heures pour un système complet, convivial et extensible l à comparer avec 50h en Pascal … n TP-5 (noté) Bilan

125 Programmation LogiqueNJ /127 PROLOG : à quoi ça sert ? n Principal langage de lIntelligence Artificielle l Systèmes experts –cf. TP l Traitement du langage naturel –cf. GINA l Faire intervenir le raisonnement … Bilan

126 Programmation LogiqueNJ /127 PROLOG pour lIndustrie n Programmation par Contraintes l point de rencontre de diverses disciplines –programmation logique (et IA au sens large) –recherche opérationnelle (graphes, prog. Linéaire, …) –analyse numérique l Pour résoudre des problèmes combinatoires complexes –gestion de ressources (humaines ou non), –réseaux télécoms, … l Technologie française en plein boom ! –ILOG SA, Cosytec (systèmes de PPC) –Bouygues SA, Bouygues Telecom, France Telecom R&D, Air France, DGA, SNCF, … Bilan

127 Programmation LogiqueNJ /127 PROLOG dans lIndustrie n Utilisé pour l prototyper très rapidement, l tester des idées … n Mais aussi pour développer des applications l Dassault Électronique l ECRC (Centre de recherche commun Bull, Siemens) l … Bilan


Télécharger ppt "Programmation Logique2002 Programmation en Logique FI 3 - 2002 Cours Narendra Jussien TP Romuald Debruyne / Narendra Jussien."

Présentations similaires


Annonces Google