1. HISTORIQUE

1. 1. HISTORIQUE Origine PROLOG : PROgrammation LOGique. 1967 : SIMULA 67 1972 : 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. 1989 : Programmation Logique avec Contraintes (Prolog III) 1995 : Extension et introduction des contraintes sur intervalles (Prolog IV)

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. HISTORIQUE(2) Méthodologie de construction de programme Spécification logique à partir de laquelle on dérive un programme à l’aide 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 s’arrête le résultat est conforme à la spécification.

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 d’un banquier typique:  V, vc([V, V, V], 1000) ? Réponse: V = 133100/331 ou 402.11480362537765

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 = 133100/641 ou 207.6443057722309 Ou encore (pas pour banquier du tout):  C, vc([200, 400, 300], C) ? C = 982000/1331 ou 737.7911344853494

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. 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. 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. 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. 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 d’apparition.

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: 1 2 {jacques = jacques, Z = pierre} pere (Z, Y) {jacques = pierre, Z = isidore} Echec 2 1 {Z = jacques, Y = pierre} Echec {Z = pierre, Y = isidore} Succès

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. 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) <= Z ( pere(Z, Y)  pere(X, Z))

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], F ) Q0 = requête initiale.

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 d’infé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. Machine Prolog (2) Exemple: état initial : ({U}, [grand_pere (jacques, U)], F ) Application de la règle d’inférence: ({U}, [grand_pere (jacques, U)], F), 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)} F )

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 qu’il y a « unification » des deux arbres. Exemple: { f (1,Y) = f (X,4) } ou f f = X 4 1 Y a une solution: {1 = X, Y = 4}

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

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 d’unification: • {cons(X, cons(2, cons(3, nil))) = cons(1, L)} a pour solution: • { X = 1, L = cons(2, cons(3, nil)) }

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

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. Terminaison(1) Est-ce que la démonstration de concat(X, Y, Z) se termine pour les cas suivants ? X Y Z où * signifie connu et ? inconnu * * * * * ? * ? * ? * * * ? ? ? * ? ? ? * ? ? ?

23. Terminaison(cont. 1) Théorème à retenir « toute suite entière ui, tq  i ui 0 et ui > ui+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. Terminaison(cont. 2) Pour montrer que pgcd (a0, b0) termine (a0>0, b0>0): pgcd (a0, b0) -> pgcd (a1, b1) -> pgcd (a2, b2)… Il s’agit de « découvrir » une fonction f entière respectant le théorème précédent et tq: u0 = f (a0, b0), u1 = f (a1, b1), u2= 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. 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 qu’elle 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. Notation usuelle de listes Notations de base: [], [E | L] Contractions: [E1 | [E2…[En | L]…]] = [E1, E2, …, En|L] [E1, E2, …|[]] = [E1, E2,…]

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. Dérivation de programme(1) Méthodologie: dérivation d’un 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. Coupure Troisième règle de dérivation. Nécessitée par un besoin d’efficacité 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. 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. 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: • :- B1, !, B2. B :- B3. B1:-A1. B1 :- A2. A1. 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. Coupure(3) B abandon B1, !, B2 A1, !, B2 abandon !, B2 B2

33. Négation par échec neg_par_echec(b) :- b, !, fail. neg_par_echec(b). « Fausse » négation à n’employer 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. 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. 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] n’est 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. 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. 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. 5.Analyse syntaxique et traduction • Motivations • - faire ressortir l’analogie 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 ancbn, n  0 défini par la gramaire G d’axiome S: • S -> c • S -> a S b

39. Analyse syntaxique Il s’agit 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. Analyse syntaxique(cont. 1) Exemple: la grammaire suivante d’axiome 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. 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 d’une chaîne , ie au lieu de considérer qu’il s’agit de la chaîne vide, on l’ »abstrait » (on le considère comme inconnu). En lambda-calcul, la représentation serait l’abstraction  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. Analyse syntaxique(cont. 3) Pratiquement, la représentation que nous adoptons en Prolog ne permet qu’une seule application pour une  -expression. D’un 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 l’application de X sur Y.

43. Analyse syntaxique(cont. 4) La concaténation devient: concat1([C1, S1], [C2, S2], [C, S]) :- C = C1, S1 = C2, S = S2. et d’une façon générale (n 0): concatn([C, S1], [S1, S2], … [Si-1 , Si], [Si , Si+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. 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. 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. Traduction Principe de composition (dit aussi de FREGE): la valeur d’un 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 d’axiome E: E à T E à T + E T à F T à F * T F à a F à b F à c F à ( E )

47. Traduction(cont. 1) Il s’agit de définir la traduction d’une 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. Traduction(cont. 2) Le principe de composition s’applique 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. Traduction(cont. 3) Les opérateurs que nous avons considérés (+ et *) sont associatifs ((a + b) + c = a + (b+ c)). Introduisons l’opérateur - qui ne l’est 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 n’est pas bonne idée. En effet tradE_A([[a, -, b, - , c], []], A) donne A = moins2(a, moins2(b, c)) qui n’est pas la bonne traduction, mais celle de a – (b – c). Rappel: C’est opérateur le plus à gauche qui a la plus forte priorité.

50. Traduction(cont. 4) La méthode consiste à reprendre le principe de composition et à rechercher une nouvelle décomposition, c’est-à-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, c’est le démonstrateur (+ notre représentation pour les chaînes) qui flanche: tradE_A([[a, -, b, - , c], []], A) ne termine pas, comme c’est la cas pour les analyseurs descendants, à cause de la récursivité à gauche (sur E).