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

1 1. HISTORIQUE Origine PROLOG : PROgrammation LOGique. 1967 : SIMULA 67 1972 : introduit par Alain COLMERAUER. Ce langage permet une programmation « déclarative.

Présentations similaires


Présentation au sujet: "1 1. HISTORIQUE Origine PROLOG : PROgrammation LOGique. 1967 : SIMULA 67 1972 : introduit par Alain COLMERAUER. Ce langage permet une programmation « déclarative."— Transcription de la présentation:

1 1 1. HISTORIQUE Origine PROLOG : PROgrammation LOGique : SIMULA : introduit par Alain COLMERAUER. Ce langage permet une programmation « déclarative ». Repose sur deux courants: la définition des langages de programmation (« W- grammaires ») et la démonstration automatique 1981 : programme Japonais de 5ème Génération : Programmation Logique avec Contraintes (Prolog III) 1995 : Extension et introduction des contraintes sur intervalles (Prolog IV)

2 2 HISTORIQUE (1) Logiciels Prolog Domaine du « libre » INRIA : GNU-Prolog Sicstus, Eclipse Domaine payant PrologIA : Prolog 4 COSYTEC (Orsay) : CHIP (Constraint Handling in Prolog) ILOG Solver

3 3 HISTORIQUE(2) Méthodologie de construction de programme Spécification logique à partir de laquelle on dérive un programme à laide de « règles de dérivation ». Aspects neufs: Le langage dans lequel la spécification et le programme sont écrits est le « même ». Les règles de dérivation conservent la «logique » : si le programme sarrête le résultat est conforme à la spécification.

4 4 HISTORIQUE (3) Exemple PLC grand public vc(L, C) : vrai si L est une liste de versements annuels qui rembourse le capital C avec un intérêt de 10 %. Spécification (et aussi programme): vc([], C) <= (C = 0). vc ([V | Lp], C) <= vc(Lp, Cp) et Cp = C – V + (1/10) * C. Une première question, typique dun banquier typique: V, vc([V, V, V], 1000) ? Réponse: V = /331 ou

5 5 HISTORIQUE (5) Aspect « déclaratif » Autre question dans le même style (pas pour banquier ordinaire): V, vc([V, 2*V, 3*V], 1000) ? V = /641 ou Ou encore (pas pour banquier du tout): C, vc([200, 400, 300], C) ? C = /1331 ou

6 6 2.CLAUSES DE HORN, MACHINE PROLOG clause de Horn: P0 <= P1 … Pn avec n 0 Pi : formule atomique (plus petite formule qui peut être égale à vrai ou faux) Pi = p (t1, …, tm) avec m 0 p : prédicat t1, …, tm : termes: - soit une constante : 123, theodore, … -soit une variable (ou inconnue) : X,X1,Mav….

7 7 CLAUSES DE HORN, MACHINE PROLOG (1) -soit un terme complexe : f (t1, …, tp), p 0 f : foncteur (une constante) t1, …, tp : termes Exemple: f (1, g (3, X)) Les variables des clause sont quantifiées universellement Exemple : X, biellecoulée(X) <= plusd huile(X) voyantrouge(X)

8 8 CLAUSES DE HORN, MACHINE PROLOG (2) Toute clause de Horn peut se mettre sous la forme: P0 ¬P1 … ¬Pn avec n 0 Démonstration ? Un seul littéral (formule atomique ou formule atomique négativé) est positif (P0) Une clause générale est de la forme: P0 Q1 … Qp ¬P1 … ¬Pn Qui possède éventuellement plusieurs littéraux positifs et qui peut se mettre sous la forme: P0 Q1 … Qp <=P1 … Pn ou encore: P0 <=P1 … Pn ¬ Q1 … ¬ Qp Attention: on ne peut utiliser de clauses générales en Prolog.

9 9 Exemple initial type BD Des formules logiques pere (jacques, pierre) <= pere (pierre, isidore) <= et des théorèmes à démontrer: pere (jacques, pierre) et X pere (jacques, X), on peut déduire les règles Prolog suivantes: pere (jacques, pierre). /*regle 1*/ pere (pierre, isidore). /*regle 2*/ et les requêtes Prolog suivantes: pere (jacques, pierre). pere (jacques, X).

10 10 Exemple initial type BD (1) pere (jacques, X). fournit un succès: X = pierre pere (X, Y) fournit un succès et deux solutions X = jacques, Y = pierre ; X = pierre, Y = isidore. On trouve ici un exemple de la première de dérivation: Les règles sont consultées par le démonstrateur prolog dans leur ordre dapparition.

11 11 Exemple initial type BD (2) Le théorème à démontrer suivant Z, Y pere (jacques, Z) pere(Z, Y) peut se traduire par la requête: pere (jacques, Z), pere(Z, Y) démontrée par le processus: {jacques = jacques, Z = pierre} pere (Z, Y) {jacques = pierre, Z = isidore} Echec {Z = jacques, Y = pierre} Echec {Z = pierre, Y = isidore} Succès

12 12 Exemple initial type BD (3) On trouve ici un exemple de la deuxième règle de dérivation: Les buts (formules atomiques) sont prouvés de gauche à droite. La clause de Horn X, Y, Z grand_pere (X, Y) <= pere (Z, Y) pere (X, Z) peut se traduire par la règle grand_pere (X, Y) :- pere (Z, Y), pere (X, Z). ou par la règle grand_pere (X, Y) :- pere (X, Z), pere (Z, Y).

13 13 Exemple initial type BD (4) Exercice: donner les deux démonstrations différentes suivant ces deux règles de la requête: grand-pere(jacques,Y). Exercice: montrer que la clause de Horn X, Y, Z grand_pere(X, Y) <= pere(Z, Y) pere(X, Z) est équivalente à la formule X, Y grand_pere(X, Y) <= pere(Z, Y) pere(X, Z))

14 14 Machine Prolog -état courant: (W, L-b, R) où W : ensemble des variables de la question initiale L-b : séquence des "buts« (formules atomiques) à prouver. R : système déquation courant (supposé « satisfiable » plus ou moins « fortement ») -état initial : (W, [Q0], ) Q0 = requête initiale.

15 15 Machine Prolog (1) -état final = (W, [ ], Rf) Rf satisfaisable. Résultat: Système déquation "le plus petit" extrait de Rf portant sur les variables de W. -règle dinférence: (W, [B0, B1, …, Bm], R), P0 :– P1, …, Pn (W, [ P1, …, Pn, B1, …, Bm], {B0 = P0} R) R et {B0 = P0} R doivent être statisfaisables

16 16 Machine Prolog (2) Exemple: état initial : ({U}, [grand_pere (jacques, U)], ) Application de la règle dinférence: ({U}, [grand_pere (jacques, U)], ), grand_pere (X, Y) :- pere (X, Z), pere (Z, Y) ({U}, [pere (X1, Z1), pere (Z1, Y1)], {grand_pere (jacques, U) = grand_pere (X1, Y1)} )

17 17 3. Contraintes sur les arbres Équation sur les arbres: satisfaisable si les étiquettes des sommets sont égales et si leurs fils sont égaux deux à deux. On dit quil y a « unification » des deux arbres. Exemple: { f (1,Y) = f (X,4) } ou f Y f X4 = a une solution: {1 = X, Y = 4}

18 18 Unification f (1,Y) et f (X,4) s»unifient » en f(1, 4). Exemple: { f (Y, 2, 1) = f (1,Y,Y) } na pas de solution. Exemple: { X = f (1,X) } a pour solution un arbre infini rationnel (voir chap. 7).

19 19 Listes - liste vide : constante, soit : nil - liste non vide : terme complexe soit:cons(E, L) où E est le premier élément de liste et L la liste restante. Exemple: cons(1, cons(2, cons(3, nil))) Exemple dunification: {cons(X, cons(2, cons(3, nil))) = cons(1, L)} a pour solution: { X = 1, L = cons(2, cons(3, nil)) }

20 20 Construction de programmes 1) Spécification logique 2) Dérivation depuis la spécification dun programme qui se termine pour la question considérée.

21 21 Terminaison et « réversibilité » Définition: concat(X, Y, Z) : vrai si X, Y, Z sont des listes et si Z est la concaténation de X et Y. Spécification: X, Y concat (nil, Y, Z) <= Z = Y. E, L, Y, L1 concat (cons(E,L), Y, cons(E, L1)) <= concat (L, Y, L1). Un programme: concat (nil, Y, Y). concat (cons(E,L), Y, cons(E, L1)) :-concat (L, Y, L1).

22 22 Terminaison(1) Est-ce que la démonstration de concat(X, Y, Z) se termine pour les cas suivants ? XY Z où * signifie connu et ? inconnu *** **? *?* ?** *?? ?*? ??* ???

23 23 Terminaison(cont. 1) Théorème à retenir « toute suite entière u i, tq i u i 0 et u i > u i+1, est finie » Exemple non trivial : proc pgcd = (ent a, b) ent : cas a = b alors a, a > b alors pgcd (a-b, b), a < b alors pgcd (a, b-a) fcas Avec pré-condition a>0, et b>0 et entiers

24 24 Terminaison(cont. 2) Pour montrer que pgcd (a0, b0) termine (a0>0, b0>0): pgcd (a0, b0) -> pgcd (a1, b1) -> pgcd (a2, b2)… Il sagit de « découvrir » une fonction f entière respectant le théorème précédent et tq: u 0 = f (a0, b0), u 1 = f (a1, b1), u 2 = f (a2, b2)… f(a, b) = a-b ne convient pas f(a, b) = | a-b | ne convient pas f(a, b) = a + b et f(a, b) = a * b conviennent.

25 25 Terminaison (cont. 3) En programmation logique, il faut prendre soin de montrer que la fonction f est évaluable Soit Z connu comme dans la requête: concat (X, cons(2, nil), cons(1, cons(2, nil))) La fonction f = |Z| convient: |cons(E, L1)) |> |cons(L1)| On montre par réccurence quelle est évaluable. Idem si X est connu. Les seuls cas de non terminaison sont ceux où ni la taille de X ni celle de Z ne sont connues. Question: quel est le résultat de la requête suivante ? concat (cons(1, nil), Y, Z)

26 26 Notation usuelle de listes Notations de base: [], [E | L] Contractions: [E1 | [E2…[En | L]…]] = [E1, E2, …, En|L] [E1, E2, …|[]] = [E1, E2,…]

27 27 Dérivation de programme Définition: inverse(X, Y) : vrai si X est inverse de Y. Spécification: inverse([], []) <= E, L, Y, L1 inverse ([E| L], Y) <= concat (L1, [E], Y) inverse(L, L1). Un programme: inverse1([], []). inverse1 ([E| L], Y) :- concat (L1, [E], Y), inverse1(L, L1).

28 28 Dérivation de programme(1) Méthodologie: dérivation dun deuxième programme possédant la même spécification: inverse2([], []). inverse2([E| L], Y) :- inverse2(L, L1), concat (L1, [E], Y). Mêmes questions concernant la terminaison de démonstrations du type inverse(X, Y) selon que la taille de X ou celle de Y est connue.

29 29 Coupure Troisième règle de dérivation. Nécessitée par un besoin defficacité i toutes les démonstrations ne sont pas nécessaires. Exemple: membre_et_reste(X, L,R): vrai si X a une occurrence dans L et si R est L amputée de cette occurence. membre_et_reste(X, [X | L],L). membre_et_reste(X, [E| L], [E | Rp]):- membre_et_reste(X, L, Rp).

30 30 Coupure(1) membre_et_reste(1, [2,1,3,1,4,1,5], R). fournit: R = [2,3,1,4,1,5]; R = [2,1,3,4,1,5]; R = [2,1,3,1, 4, 5]. Si on introduit la coupure membre_et_reste(X, [X | L],L) :- !. le seul résultat est: R = [2,3,1,4,1,5].

31 31 Coupure(2) La coupure ! est une formule atomique toujours vraie. De plus, tous les buts en suspens pour prouver le but qui est le sujet de la règle dans laquelle intervient la coupure sont abandonnés. Exemple: Consigne: règle de dérivation à employer avec précaution pour ne pas « supprimer la complétude », ie supprimer toutes les démonstrations. Emploi « sur »: requête initiale, !.

32 32 Coupure(3) abandon

33 33 Négation par échec neg_par_echec(b) :- b, !, fail. neg_par_echec(b). « Fausse » négation à nemployer que sur des buts instanciés. homme(pierre). homme(jacques). fort(jacques ). homme(X), neg_par_echec(fort(X)) donne un succès. neg_par_echec(fort(X)), homme(X) donne un échec.

34 34 4. Contraintes sur les listes Objets: les listes Opérations: X o Y (concaténation) Contraintes: =, #, size(N, X) (N est la taille de X). Exemple: {[U, 2]o Y = [1]o [V, W]} se réduit en: {U = 1, 2 = V, Y = [W]} Deux questions: décidabilité de la satisfaisabilité de telles contraintes et (si décidabilité) complexité (en termes de nb de variables et nb déquations).

35 35 Linéarité Ici pour obtenir une bonne efficacité, on autorise seulement des concaténations « linéaires » tq dans Z = X oY, deux des tailles parmi celles de X, Y et Z sont connues. Exemple: X o [3] o Y = [1, 2, 3, 4] nest pas accepté. Mais size(6, X), [1, 2, 3]o X = X o [1, 2, 3]. size(10000, X), [1]o X = X o [1]. le sont.

36 36 Réversibilité. Pseudo-linéarité Pour illustrer le fait que + de contraintes => + de « réversibilité », une nouvelle mouture: inverse([], []). inverse([E] o X, Y o [E]) :- inverse(X, Y). nécessite la vérification que les équations posées sont linéaires. inverse([1, 2], Y). termine mais pose des équations non linéaires. Cependant, elles sont conservées et elles deviennent linéaires par propagation (pseudo-linéarité).

37 37 Réversibilité. Pseudo-linéarité(1) Une solution sans équations pseudo-linéaires. inverse(X, Y) :- sixe(N, X), size(N, Y), palindrome(X o Y). palindrome([]). palindrome([E] o X o [E]):- palindrome(X).

38 38 5. Analyse syntaxique et traduction otivations faire ressortir lanalogie entre la restriction que représente les clauses de Horn face aux contraintes générales et celle des grammaires hors contexte face aux grammaires générales (« context-sensitive ») -appliquer le principe de composition dans un cadre rigoureux qui fait apparaître le besoin de valeurs sous la forme de fonctions Analyse syntaxique Exemple: le langage a n cb n, n 0 défini par la gramaire G daxiome S: S -> c S -> a S b

39 39 Analyse syntaxique Il sagit de définir le prédicat analyse-G(M) : vrai si la liste M représente une chaîne du langage décrit par G: Exemple: analyse_G([a, a, c, b, b]) est vrai Deux clause sont dérivées à partir des deux règles de grammaires: analyse_G(M) :- M= [c]. analyse_G(M) :- M = [a]o M1o[b], analyse_G(M1). Mais à cause de la restriction sur la concaténation, cette dérivation ne peut être généralisée.

40 40 Analyse syntaxique(cont. 1) Exemple: la grammaire suivante daxiome A A -> X Y X -> X -> a X b Y -> Y -> c Y La démonstration de analyse-G([a, b, c]) pose léquation: M = M1o M2 et demande les démonstrations de analyse_X([M1]) et de analyse_Y(M2) qui ne terminent pas

41 41 Analyse syntaxique(cont. 2) Une solution correcte mais très inefficace: remplacer les contraintes sur les listes par des contraintes sur les arbres. Exemple: analyse_G(M) :- concat(M1, M2, M), analyse_X(M1), analyse_Y(M2). Autre solution. Idée: « préparer » la concaténation à droite. Formellement: faire abstraction du suffixe dune chaîne, ie au lieu de considérer quil sagit de la chaîne vide, on l »abstrait » (on le considère comme inconnu). En lambda-calcul, la représentation serait labstraction S.M o S où M est la chaîne et S le suffixe. Pratiquement, en Prolog qui est basé sur la logique du 1er ordre (sans lambda-expression): une chaîne est représentée par [C, S ] comme le préfixe de la chaîne C dont le suffixe est S (« difference list »). Exemple: [[a, b, c| S], S] est la représentation de la chaîne abc.

42 42 Analyse syntaxique(cont. 3) Pratiquement, la représentation que nous adoptons en Prolog ne permet quune seule application pour une -expression. Dun point de vue mathématique, la concaténation des listes X = S.M1 o S et Y = S.M2 o S est Z = S.M2 o S Z est le résultat de lapplication de X sur Y.

43 43 Analyse syntaxique(cont. 4) La concaténation devient: concat1([C1, S1], [C2, S2], [C, S]) :- C = C1, S1 = C2, S = S2. et dune façon générale (n 0): concatn([C, S 1 ], [S 1, S 2 ], … [S i-1, S i ], [S i, S i+1 ], …[Sn, S], [C, S]). Exemple: analyse_A([C, S]) :- analyse_X([C, S1]), analyse_Y([S1, S]). analyse_X([S, S]). analyse_X([C, S]) :- mot(C, a, S1), analyse_X([S1, S2]), mot(S2, b, S). analyse_Y([S, S]). analyse_Y([C, S]) :- mot(C, c, S1), analyse_Y([S1, S]). où: mot([X|S], X, S).

44 44 Analyse syntaxique(cont. 5) analyse_A([C, S]) se lit: vrai si C débute par une dérivation du non-terminal A et se termine par S. Remarque: analyse_A([[a, b, c], []]) est vrai si abc est une dérivation de A. Note: la chaîne vide est représentée formellement par la fonction identité, soit S.S.

45 45 Analyse syntaxique(cont. 6) Dans le cas général, pour la règle hors contexte: X0 X1 … Xn, n 0 on obtient la clause: analyse_ X0([C, S]) :- p1(C1,S1), …, pn(Cn,Sn). avec C1 = C, Sn = S Et si Xi est non terminal, alors pi(Ci, Si) est: analyse_ Xi([Ci, Si]) avec Ci = Si-1 et S0= C si Xi est terminal, alors pi(Ci, Si) est: mot(Ci, Xi, Si) avec Ci = Si-1

46 46 Traduction Principe de composition (dit aussi de FREGE): la valeur dun tout est une fonction de la valeur de ses composants. Peut sembler trivial. En fait une méthode de construction de définitions (et du coup de programmes) très utile. Exemple: on considère les expressions décrites par la grammaire G suivante daxiome E: E T E T + E T F T F * T F a F b F c F ( E )

47 47 Traduction(cont. 1) Il sagit de définir la traduction dune telle expression dans le langage des termes A suivants: a, b, c, plus2(A1, A2), mul2(A1, A2) où A1 et A2 sont de type A. Donc de définir le prédicat tradE_A([C, S ], A) : vrai si C débute par une dérivation de E dont la traduction est A et se termine par S. tradE_A([C, S ], A) :- tradT_A([C, S ], A). tradE_A([C, S ], A) :- tradT_A([C, S1 ], A1), mot(S1, +, S2), tradE_A([S2, S ], A2), A=plus2(A1, A2). tradT_A([C, S ], A) :- tradF_A([C, S ], A). tradT_A([C, S ], A) :- tradF_A([C, S1 ], A1), mot(S1, *, S2), tradT_A([S2, S ], A2), A=mul2(A1, A2). tradF_A([C, S ], a) :- mot(C, a, S). … tradF_A([C, S ], A):- mot(C, (, S1). tradE_A([S1, S2], A), mot(S2, ), S).

48 48 Traduction(cont. 2) Le principe de composition sapplique sans difficulté. La décomposition est donnée par les règles de grammaire. Les valeurs des expressions termes et facteurs sont des arbres. La recomposition des valeurs est donné par construction de nouveaux arbres. Un programme se déduit aisément de cette spécification pour une requête où la taille de la chaîne C est donnée. En effet, la démonstration termine car la taille de C diminue strictement pour des démonstrations successives portant sur un même prédicat. Nous procédons dans ce qui suit à une étude montrant la nécessité de revenir sur la décomposition (ie déterminer de nouvelles grammaires pour le même langage) et sur la notion de valeur à associer à un composant (abstraction comme dans les grammaires de Montague)

49 49 Traduction(cont. 3) Les opérateurs que nous avons considérés (+ et *) sont associatifs ((a + b) + c = a + (b+ c)). Introduisons lopérateur - qui ne lest pas et le terme moins2(A1, A2) dans le langage des termes. Une idée immédiate consiste à remplacer + par - (et plus2 par moins2). E T E T - E avec tradE_A([C, S ], A) :- tradT_A([C, S ], A). tradE_A([C, S ], moins2(A1, A2)) :- tradT_A([C, S1 ], A1), mot(S1, -, S2), tradE_A([S2, S ], A2). Ce nest pas bonne idée. En effet tradE_A([[a, -, b, -, c], []], A) donne A = moins2(a, moins2(b, c)) qui nest pas la bonne traduction, mais celle de a – (b – c). Rappel: Cest opérateur le plus à gauche qui a la plus forte priorité.

50 50 Traduction(cont. 4) La méthode consiste à reprendre le principe de composition et à rechercher une nouvelle décomposition, cest-à-dire une grammaire différente, mais toujours pour le même langage. Un bonne décomposition est la suivante: E T E E - T avec tradE_A([C, S ], A) :- tradT_A([C, S ], A). tradE_A([C, S ], moins2(A1, A2)) :- tradE_A([C, S1 ], A1), mot(S1, -, S2), tradT_A([S2, S ], A2). Malheureusement, cette fois, cest le démonstrateur (+ notre représentation pour les chaînes) qui flanche: tradE_A([[a, -, b, -, c], []], A) ne termine pas, comme cest la cas pour les analyseurs descendants, à cause de la récursivité à gauche (sur E).

51 51 Traduction(cont. 5) Une autre grammaire doit donc être construite avec les caractéristiques suivantes: non récursive à gauche, mettant en évidence lopérateur – et son opérande droit. La grammaire suivante (où RT, pour « reste de terme », est un nouveau non-terminal) convient: E -> T RT RT -> RT -> - T RT Le traducteur qui sen déduit pour E: tradE_A([C, S ], A) :- tradT_A([C, S1 ], A1), tradRT_V([S1, S ], V), composition(A, A1, V). pose naturellement: - la question de la nature de la valeur V dun reste de terme et - celle la composition des valeurs A1 et V qui doit donner celle dune expression, cest-à-dire A.

52 52 Traduction(cont. 6) Un exemple dans un autre domaine permet déclairer la démarche pour déterminer V et la composition recherchée. En linguistique, on se pose typiquement le problème de la traduction de groupe nominaux du type: La maison qui est belle dans un langage logique, en loccurrence ici en la formule atomique: belle(maison). Le problème rencontré est similaire au nôtre dans la mesure où la décomposition fait apparaître la proposition relative (le sujet est inconnu comme le premier opérande du premier – dans un reste de terme). La solution est de donner à une subordonnée la valeur dune principale dans laquelle le référent (ici maison) est « abstrait » (ie inconnu): X. belle (X). La composition est alors lapplication de cette fonction sur le référent, soit: ( X. belle (X))(maison) =belle(maison)

53 53 Traduction(cont. 7) Comme dans le cas des « difference lists », une lambda-expression X.F.est représentée en Prolog par un couple : nous le notons ici lambada[X, F]. Lapplication, comme on la vu, ne peut avoir lieu quune fois (ici, comme dans le cas des « difference lists » ce nest pas gênant). On obtien, tradE_A([C, S ], A) :- tradE_A([C, S1 ], A1), tradRT_V([S1, S ], lambada(X, A2)), A = A2, X = A1. De la même façon: tradRT_A ([C, S ], lambada(X, X)). tradRT_A ([C, S ], lambada(Z, A)) :- mot(C, -, S1), tradE_A([S1, S2], A1), tradRT_V([S2, S ], lambada(X, A2)), A = A2, X = moins(Z, A1).

54 54 Traduction(cont. 7) Remarque1: dans cette dernière règle la valeur de Z. A est le résultat de lapplication de X. A2 à la valeur du reste de terme - T, cest-à- dire Y. A1. Exercice: Soit X. A2 = X. moins(X, c), Y. A1= Y. moins(Y, b). Déterminer Z. A. Remarque2: la règle définissant tradE_A sécrit aussi tradE_A([C, S ], A2) :- tradE_A([C, S1 ], A1), tradRT_V([S2, S ], lambada(A1, A2)). qui fait apparaître une exécution qui nest pas celle naturellement issue du principe de composition. Il ny a pas contradiction: celui-ci est utilisé à des fins de spécification.

55 55 6. Contraintes numériques Contraintes linéaires: relations: =, >, dif(X, Y) opérations: +, -, *, / Restriction: dans un produit X*Y, X ou Y doit être connu. Exemple: nbpattestêtes(Chats, Oiseaux, Np, Nt):- Np = 4* Chats + 2* Oiseaux, Nt =Chats + Oiseaux,. Exercice: réponses aux requêtes: nbpattestêtes(Chats, Oiseaux, 16, 5). nbpattestêtes(Chats, Oiseaux, 3, 1).

56 56 Contraintes + heuristique dénumération Illustration de la méthodologie contraintes + heuristiques dénumération: le cas de la recherche des solutions entières. Exemple ( cryptogramme): Déterminer S, E, N, D, M O, R, Y entiers de 0 à 9 tels que laddition: S E N D + MORE M O N E Y soit vérifiée.Il sagit de définir solution_crypt([S, E, N, D, M, O, R, Y]) vrai si les variables S, E, N, D, M, O, R et Y répondent aux conditions précédentes.

57 57 Contraintes + heuristique dénumération (cont. 1) solution_crypt([S, E, N, D, M, O, R, Y]) :- tous_differents([S, E, N, D, M, O, R, Y]), K1 = 1000*S + 100*E + 10*N + D, K2 = 1000*M + 100*O + 10*R + E, K3 = 10000*M *O + 100*N + 10*E + Y, K3 = K1 + K2, dif(S, 0), dif(M,0), /* fin de la partie contraintes, suit lénumération*/ enumeration([S, E, N, D, M, O, R, Y]). Exercice: trouver un « bon » (efficace) ordre dans lequel énumérer (voir ci-après) les variables (qui nest pas forcément S, E, N, D, M, O, R, Y). Cest tout lart de déterminer une heuristique (méta-connaissance). Par exemple, en énumérant dabord les variables intervenant dans le plus grand nombre de contraintes.

58 58 Contraintes + heuristique dénumération (cont. 2) tous_differents([]). tous_differents([X | L]) :- 0 X, X 9, different(X, L), tous_differents(L) different(X, []). different(X, [Y | L]):- dif(X, Y), different(X, L). enumeration([]). enumeration([X | L]) :- enum0_9(X), enumeration(L). enum0_9(0). enum0_9(1). … enum0_9(9).

59 59 Démonstration automatique Illustrations de lutilisation dun résolveur pour la démonstration automatique (en particulier de formules universelles). A noter: le démonstrateur Prolog permet de faire de la démonstration, mais, comme on la vu, elle nest pas vraiment automatique, il faut quelquefois laider pour que la démonstration termine. Méthode pour démontrer X P(X) => Q(X): montrer que ¬( X P(X) => Q(X)) nest pas satisfaisable. Soit montrer que X ¬( P(X) => Q(X)) ou encore X P(X) ¬ Q(X) nest pas satisfaisable. Exemple: le théorème de Varigon: « pour tout quadrilatère ABCD, le quadrilatère des milieux M1 M2 M3 M4 (M1 (resp. M2, M3, M4) milieu de AB(resp. BC, CD, DA)) est un parallélogramme ». Il sagit de montrer que la proposition »il existe un quadrilatère ABCD pour lequel le quadrilatère des milieux nest pas un parallélogramme » n est pas satisfaisable.

60 60 A B C D M4 M2 M1 M3 I J Démonstration automatique. Fig.

61 61 Démonstration automatique (cont. 1) Sachant quun parallélogramme est caractérisé par le fait que ses deux digaonales se coupent en leur mieux, il vient: varignon :- neg_par_echec(non_varignon_possible). non_varignon_possible: - milieu(A, B, M1), milieu(B, C, M2), milieu(C, D, M3), milieu(D, A, M4), milieu(M2, M4, J), milieu(M1, M3, I), dif(I, J) /* négation de la conclusion*/. milieu([X1, YI], [X2, Y2], [X, Y]) :- X = (X1 + X2) / 2, Y = (Y1 + Y2) / 2. Bien noter la nécessité que les équations posées soient linéaires (cest le cas ici).

62 62 Démonstration automatique (cont. 2) Autre exemple: montrer que toute suite entière telle que u i+2 = |u i+1 | - u i a une période de 9. periode9 :- neg_par_echec(periode9_non_possible). periode9_non_possible :- size(11, S), bonne_suite(S), size(2, S1), size(7, S2), size(2, S3), S = S1 o S2 o S3, dif(S1, S3) /* négation de la conclusion*/. bonne_suite([X1, X0]). bonne_suite(S o [X2, X1, X0]) :- val_abs(X1, X1p), X2 = X1p – X0, bonne_suite(S o [X2, X1]). val_abs(X, X):- X 0. val_abs(X, -X):- X < 0.

63 63 7. Arbres infinis rationnels Introduits naturellement par des équations au point fixe sur les arbres. Exemple: X = f(1, X) Deux approches sont possibles: -on admet que ces systèmes ont des solutions: des arbres infinis dits rationnels dans la mesure où ils possèdent un nombre fini de sous-arbres. -Exemple: dans le cas précédent X admet deux sous-arbres : 1 et X. --on rejette ces systèmes pour des raisons théoriques (intuitivement, il devient possible quun système cohérent sur les arbres ne le soit pas si on donne des significations aux foncteurs: f(X, 4) = f(3, Y) est cohérent si f est interprété par + ou par *, ce nest pas le cas pour X = f(1, X)). Ce rejet est coûteux: il faut vérifier que chaque unification ne donne pas lieu à de telles équations.

64 64 f f 1 1 1… f 1 f Grâce aux arbres infinis on dispose en Prolog IV des graphes finis comme des « valeurs à part entière », cest-à-dire manipulable comme des touts X = Arbres infinis rationnels. Fig.

65 65 Arbres infinis rationnels (cont. 1) f f 1 1 f g g g ……. Il existe bien sur des arbres infinis non rationnels. Exemple:

66 66 Arbres infinis rationnels (cont. 2) Illustrations: - dune part, de représentation à laide de graphe fini et dutilisation (grammaire et analyse syntaxique) - dautre part, de la construction de graphes finis et de la terminaison de parcours (substitution appliquée à un arbres infini rationnel)

67 67 Grammaire et analyse syntaxique Exemple de graphe fini: à un non terminal est associé un arbre ou et à une règle un arbre et: E T E T + E T F T F * T F a F b F c F ( E ) ou et ou et ou et a b c () + *

68 68 Grammaire et analyse syntaxique(1) Cet arbre est E, solution du système suivant: E = ou (et(T), et(T, +, E)), T = ou (et(F), et(F, *, T)), F= ou(et(a), et(b), et(c), et((, E, ))). Lobjectif consiste à construire: analyse_G(G, [C, S]): vrai si C commence par la dérivation du nom terminal G (représenté par un arbre infini) et se termine par S. Exemple: analyse_G(E, [[a, +, b, *, c], []]) est vrai.

69 69 Grammaire et analyse syntaxique(2) Les sous-arbres sont soit une feuille, soit de la forme ou(…), soit de la forme et(…). On utilise la contrainte =.. telle que: f(X1, …, Xn) =.. [f, X1, …, Xn] analyse_G(G,[C, S]) :- leaf(G), mot(C, G, S), dif(G, et). analyse_G(G,[C, S]) :- G =.. [ou | [R|L_r]], analyse_G(R, [C, S]). analyse_G(G,[C, S]) :- G =.. [ou | [R|L_r]], Gp =..[ou | L_r], analyse_G(Gp, [C, S]). analyse_G(G,[S, S]):- G =.. [et | []]. analyse_G(G,[C, S]) :- G =.. [et | [E|L_e]], analyse_G(E, [C, S1]), Gp =..[et| L_e], analyse_G(Gp, [ S1, S]). NB: il y a terminaison si la taille de C est connue

70 70 Substitution Il sagit de donner une méthode assurant la terminaison dans le cas où le graphe est parcouru et contient des cycles. Exemple: subst(A1, A2, X, Y): vrai si larbre A2 est larbre A1 dans lequel les feuilles X sont remplacées par Y. On suppose que les arbres sont de la classe A qui sont des feuilles ou de la forme f(A1, A2) où A1et A2 sont des arbres de la classe A. Exemple: subst(f(a, b), f(b, b), a, b) est vrai. En supposant que A1 et A2 sont finis, on obtient: subst(A1, A2, X, Y):- leaf(A1), leaf(A2), A1= X, A2 = Y. subst(A1, A2, X, Y):-l eaf(A1), leaf(A2), dif(A1, X), A2 = A1. subst(A1, A2, X, Y):- A1 = f(A11, A12), A2 = f(A21, A22), subst(A11, A21, X, Y), subst(A12, A22, X, Y).

71 71 f f a f f a a b A1 = f(a, f(A1, b)), subst(A1, A2, b, a). Substitution (cont. 1)

72 72 Substitution (cont.2) Si A1 et A2 peuvent être infinis, il est nécessaire dintroduire une liste dancêtres L_a pour obtenir des chemins finis: la décomposition dun arbre nest considérée que si cet arbre nappartient pas à L_a. subst(A1, A2, X, Y):- substp(A1, A2, X, Y, []). substp(A1, A2, X, Y, L_a):- leaf(A1), leaf(A2), A1= X, A2 = Y. subspt(A1, A2, X, Y, L_a):- leaf(A1), leaf(A2), dif(A1, X), A2 = A1. substp(A1, A2, X, Y, L_a):- membre([A1, A2], L_a). substp(A1, A2, X, Y, L_a):- non_membre([A1, A2], L_a), A1 = f(A11, A12), A2 = f(A21, A22), substp(A11, A21, X, Y, [[A1, A2] | L_a]), substp(A21, A22, X, Y, [[A1, A2] | L_a]). NB: On remarque quil y a terminaison si la profondeur de A1 où celle de A2 est connue.

73 73 Unification et arbres infinis rationnels Lunification de deux arbres infinis nécessite un algorithme étendu. Exemple: il faut détecter la satisfiabilité du système: X = f(1, X), Y = f(1, f(1, Y)), X = Y Un algorithme possible conserve les associations des sous-arbres (gauches et droits) déjà considérés comme des couples (arbre-g, arbre- d). Chaque fois quun sous-arbre gauche est considéré à nouveau, cest son arbre droit dans lassociation qui est considéré pour lunification. Exemple: pour le système précédent, on donne les couples successifs (arbre-g, arbre-d) mis en jeu successivement.

74 74 f 1 f f Y = X = Unification et arbres infinis rationnels (cont.1)

75 75 8. Suspension de processus Il sagit de la quatrième règle de dérivation pour produire un programme à partir dune spécification. Lidée consiste à permettre un « cadencement » entre des démonstrations pour les terminer plus rapidement. La nouvelle structure de contrôle est: freeze(X, B): -vrai si B est vrai -retarde la démonstration de B si X nest pas « connu ». X est dit connu si: létiquette (ie le foncteur) de X est connu et si on sait si les nombre de feuilles de X est nul ou non. Exemples: dans les cas suivants X est connu: X = 1, X = [], X = [E| L] Les démonstrations dépendantes de X sont prioritaires si X devient connu. Exemple: freeze(X, B), B1, X = 3, B2. La démonstration de B est prioritaire par rapport à celle deB2. Entre deux démonstrations dépendantes de X, la priorité nest pas définie.

76 76 Suspension de processus (cont. 1) Exemple: même_mot_feuilles(A1, A2): - mot_feuilles(A1, M), mot_feuilles(A2, M). mot_feuilles(A2, M): vrai si M est le mot des feuilles (liste des feuilles de gauche à droite) de larbre A. On suppose que les arbres sont de laclasse A qui sont des feuilles ou de la forme f(A1, A2) où A1et A2 sont des arbres de la classe A. mot_feuilles(A, [A]) :- leaf(A). mot_feuilles(f(A1, A2), [A1| M]) :- leaf(A1), mot_feuilles(A2, M). mot_feuilles(f(f(A11, A12), A2), M) :- mot_feuilles(f(A11, f(A12, A2)), M).

77 77 Suspension de processus (cont. 2) Une démonstration de même_mot_feuilles(A1, A2) où A1 et A2 sont connus procède par production et vérification (« generate and test ») de M. Elle peut être très coûteuse si par exemple, M est très grand et si les deux arbres diffèrent dès la première feuille. Exemple: même_mot_feuilles(f(a, f(b, c)), f(f(b, b), c)) La démonstration échoue seulement après que le mot des feuilles de f(a, f(b, c)) (soit [a, b, c]) ait été totalement produit alors que celui-ci diffère du mot des feuilles du second arbre (soit [b, b, c]) par son premier élément. Il serait plus efficace de considérer ces deux mots de feuilles de façon symétrique en comparant leurs deux premiers éléments, puis les deux suivants…etc, cest-à-dire en cadençant les démonstrations des formules mot_feuilles(f(a, f(b, c)), ) et mot_feuilles(f(f(b, b), c))).

78 78 Suspension de processus (cont. 3) La méthode de dérivation est basée dune part sur lidentification dun producteur et dun ou plusieurs consommateurs, dautre part sur lactivation du (ou des) consommateur(s) une fois la production dun élément (notion à préciser par le concepteur) faite et la reprise du producteur après ces consommations. Cette méthode est illustrée sur un exemple artificiel trivial. Soit prod(D, T) le producteur (produisant une liste T à partir dune liste donnée D et conso(T, R) le consommateur de T fournissant en résultat la liste R. Si p(D1, T1) et c(T1, R1) modélisent respectivement les productions et consommations élémentaires, on obtient: programme :- prod(D, T), conso(T, R). prod([],[]). prod([D1 | D], [T1| T]) :- p(D1, T1), prod(D, T). conso([],[]). conso([T1 | T], [R1| R]) :- c(T1, R1), conso(T, R).

79 79 Suspension de processus (cont. 4) La transformation vise simplement mettre en attente de T le consommateur (et à le déclencher dabord) et à laisser le producteur le reprendre. Concernant lexemple précédent, pour montrer que cest au concepteur de décider ce quest une production élémentaire, on décide que la production élémentaire est accomplie après la démonstration de p(D1, T1). On obtient (les transformations sont indiquées en rouge). programmep :- consop(T, R), prodp (D, T). consop(T, R) : - freeze(T, conso(T, R)). prodp([],[]). prodp([D1 | D], M) :- p(D1, T1), M = [T1|T], prodp(D, T). conso([],[]). conso([T1 | T], [R1| R]) :- c(T1, R1), consop (T, R).

80 80 Suspension de processus (cont. 5) Lapplication de la méthode à meme_mot_feuilles, en choisissant mot_feuilles(A1, M) comme producteur donne: même_mot_feuillesp(A1, A2): - mot_feuillesp (A2, M), mot_feuillespp(A1, M). mot_feuillesp(A2, M) :- freeze(M, mot_feuilles(A2, M)) mot_feuilles(A, [A]) :- leaf(A). mot_feuilles(f(A1, A2), [A1| M]) :- leaf(A1), mot_feuillesp(A2, M). mot_feuilles(f(f(A11, A12), A2), M) :- mot_feuilles(f(A11, f(A12, A2), M). NB. On note que dans la troisième règle, il nest pas nécessaire de placer le consommateur en attente.

81 81 Suspension de processus (cont. 6) La production élémentaire demande que la première feuille du mot des feuilles du producteur soit connue: mot_feuillespp(A, [A]) :- leaf(A). mot_feuillespp (f(A1, A2), Mp) :- leaf(A1), Mp = [A1|M], mot_feuillespp (A2, M). mot_feuillespp (f(f(A11, A12), A2), M) :- mot_feuillespp (f(A11, f(A12, A2), M).

82 82 Suspension de processus (cont. 7) On peut aussi concevoir un producteur artificiel, dont le rôle est de cadencer les consommateurs. Exemple: un producteur fournit successivement les éléments du mot du feuille. même_mot_feuilles(A1, A2): - mot_feuillesp (A1, M), mot_feuillesp (A2, M), liste(M). liste ([]). liste([E|M]):- liste(M).


Télécharger ppt "1 1. HISTORIQUE Origine PROLOG : PROgrammation LOGique. 1967 : SIMULA 67 1972 : introduit par Alain COLMERAUER. Ce langage permet une programmation « déclarative."

Présentations similaires


Annonces Google