Pr

1
Prédicats prédéfinies

• Prédicats de type
• Le type d un terme peut être une variable, une
  constante (atome, nombre), une structure.
• Un terme de type variable peut être instancié ou
  non.
• integer(X) ltgt est-ce que X est un entier?
• ?- integer(4).
• gt Yes.
• ?- integer(X).
• gt No.
• float(X) ltgt est-ce que X est un flottant?
• ?- float(3.14).
• gt Yes.
• number(X) ltgt est-ce que X est un nombre?

2
Prédicats prédéfinies

• atom(X) ltgt est-ce un atome?
• ?- atom(toto).
• gt Yes.
• ?- atom(3).
• gt No.
• atomic(X) ltgt est-ce un atome ou un nombre?
• var(X) ltgt est-ce une variable non instanciée?
• ?- var(X).
• gt Yes.
• ?- X f(Z), var(X).
• gt No.
• nonvar(X) ltgt (le contraire de var) ltgt X est un
  terme autre quune variable, ou une variable
  instancié.
• ?- nonvar(X).
• gt No.

3
Prédicats prédéfinies

• compound(X) ltgt est-ce un terme composé?
• ?- compound(X).
• gt No.
• ?- compound(f(X,Y)).
• gt Yes.
• ground(X) ltgt est-ce un terme fondé?
• ?- ground(f(a,b)).
• gt Yes.
• ?- ground(f(a,Y)).
• gt No.

4
Prédicats prédéfinies

• Prédicats de manipulation de termes
• functor(Terme, Foncteur, Arité).
• ?- functor(pere(jean,isa), F, A).
• gt F pere, A 2.
• ?- functor(T, pere, 2).
• gt T pere(X,Y).
• arg(N, Terme, X). ltgt unifie X à l argument
  numéro N de terme.
• ?- arg(1, pere(jean, isa), X).
• gt X jean.
• Terme ..L. ltgt transforme un terme en une
  liste.
• ?- pere(jean,isa) ..L.
• gt L pere, jean, isa.
• ?- T ..a,b,c.
• gt T a(b, c).

5
Prédicats prédéfinies

• name(atome, Liste). ltgt transforme un atome en
  une liste de ses codes ASCII.
• ?- name(toto, L).
• gt L 116, 111, 116, 111.
• ?- name(A, 116, 111, 116, 111).
• gt A toto.

6
Prédicats prédéfinies

• Exemples
• ?- var(Z), Z2.
• gt Z2
• ?- Z2, var(Z).
• gt no
• ?- integer(Z), Z2.
• gt no
• ?- var(Z), Z2, integer(Z), nonvar(Z).
• gt Z2
• ?- atom(22).
• gt no
• ?- atomic(22).
• gt yes
• ?- atom( date(1, mars, 2003) ).
• gt no

7
Prédicats prédéfinies

• Utilisation integer(X), integer(Y), Z is XY
• Que faire en cas déchecs ...
• count(A,L,N) ltgt A apparaît N fois dans L
• count(_,,0).
• count(A, AL, N) !,
• count(A, L, N1),
• N is N1 1.
• count(A, _L,N)
• count(A, L, N).
• Mais alors
• ?- count(a, a,b,X,Y, N).
• gt N 3
• ?-count(b, a,b,X,Y, N).
• gt N 3
• X et Y ont été instancié à a (b)

8
Prédicats prédéfinie

• Nouvelle solution
• count(_, , 0).
• count(A, BL, N)
• atom(B), A B, !, B est un atome A?
• count(A, L, N1), compter nombre de A dans
  L
• N is N1 1
• count(A, L, N). sinon compter dans L
• Addition
• plus(X,Y,Z) -
• nonvar(X), nonvar(Y),
• Z is X Y.
• plus(X,Y,Z) -
• nonvar(Y), nonvar(Z),
• X is Z - Y.
• plus(X,Y,Z) -
• nonvar(X), nonvar(Z),
• Y is Z - X.

9
Prédicats prédéfinie

• Algorithme d unification (version simplifiée)
• unify(Terme1,Terme2) ltgt est-ce unifiable?
• unify(X,Y)
• var(X), var(Y), XY.
• unify(X,Y)
• var(X), nonvar(Y), XY.
• unify(X,Y)
• nonvar(X), var(Y), YX.
• unify(X,Y)
• nonvar(X), nonvar(Y),
• compound(X), compund(Y),
• termUnify(X,Y).
• termUnify(X,Y)-
• functor(X, F, N),
• functor(Y, F, N),
• argUnify(N, X, Y).

10
Prédicats prédéfinie

• argUnify(N,X,Y)-
• Ngt0,
• argUnify1(N, X, Y),
• Ns is N-1,
• argUnify(Ns, X, Y).
• argUnify(0,X,Y).
• argUnify1(N, X, Y)-
• arg(N, X, ArgX),
• arg(N, Y, ArgY),
• unify(ArgX, ArgY).

11
Prédicats de méta-programmation

• Ajout et suppression de clauses (règles) en cours
  dexécution
• Clause(Tete, Corps) ltgt renvoie les corps des
  clauses pour une tête donnée.
• personne(jean).
• Personne(isa).
• Personne(X,Y)-
• fils(Y,X),
• masculin(X).
• ?- clause(pere(X,Y), C).
• gt C (fils(Y,X), masculin(X)).
• ?- clause(personne(X), C).
• gt X jean, C true
• gt X isa, C true

12
Prédicats de méta-programmation

• Exemple d application les méta-interpréteurs
• pour prouver un but
• prove(But)-call(But).
• Ou bien simplement
• prove(But)- But.
• On peut aussi descendre dans le code et écrire
• prove(true).
• prove((But1, Buts2)) -
• prove(But1),
• prove(Buts2).
• prove(But)-
• clause(But, Corps),
• prove(Corps).

13
Prédicats de méta-programmation

• Le méta-interpréteur le plus connu (vanilla)
• solve(true).
• solve((But, Reste))-
• solve(But),
• solve(Reste).
• solve(But)-
• clause(But, Corps),
• solve(Corps).

14
Prédicats de méta-programmation

• Le méta-interpréteur le plus connu (vanilla)
• solve(true).
• solve((But, Reste))-
• solve(But),
• solve(Reste).
• solve(But)-
• clause(But, Corps),
• solve(Corps).
• assert(C) ltgt ajout de la clause C à la base de
  données.
• ?- assert(personne(françois)). ajoute le fait
  personne(françois). au programme.
• Autres variantes
• Asserta(C) ajout au début du programme
• assertz(C) ajout en fin du programme

15
Prédicats de méta-programmation

• abolish(Terme, Arité) ltgt permet de retirer tous
  les termes Terme darité Arité
• consult(Terme, Arité) ltgt Réalise un assert des
  faits et des règles du fichier.
• retract(Terme) ltgt retract(P) permet de retirer P
  de la base de donnée.
• ? retract(personne(X)).
• gt X jean, X francois
• retractall(Tete) ltgt Tous les faits et toutes les
  clauses dont la tête sunifie avec Tete sont
  retirés.

16
Prédicats du 2nd ordre

• findall/3, bagof/3, setof/3
• La résolution Prolog peut toutes les solutions
• satisfaisant un ensemble de buts.
• Mais lorsqu une nouvelle solution est générée,
  la
• solution précédente est perdue.
• Les prédicats bagof,setof et findall permettent
  de
• collecter ses solutions dans une liste.

17
Prédicats du 2nd ordre

• Le prédicat findall
• Exemple
• eleve(françois, 2, info).
• eleve(isa, 2, info).
• eleve(françois, 3, math).
• ?- findall(X, eleve(X, 2, info), B).
• gt B françois, isa.
• ?- findall(X, eleve(X,Y,Z),B).
• gt B françois, isa, françois.

18
Prédicats du 2nd ordre

• Le prédicat bagof
• Exemple
• eleve(françois, info, 2).
• eleve(isa, info, 2).
• eleve(françois, info, 3).
• eleve(paul, math, 3).
• masculin(françois).
• masculin(paul).
• feminin(isa).
• ?-bagof(X, eleve(X, info, 2), B).
• gt B francois, isa.
• ?-bagof(X, eleve(X, info, Y), B).
• gt B françois, isa, Y2
• gt B françois, Y3

19
Prédicats du 2nd ordre

• Utilisation d un quantificateur ()
• ?-bagof(X, Yeleve(X, info, Y), B).
• gt B françois, isa, françois.
• ?-bagof(X, eleve(X, Y, Z), B).
• gt B françois, isa, Y info, Z2.
• gt (etc )
• ?-bagof(X, ZYeleve(X, Y, Z), B).
• gt B françois, isa, françois,paul.
• ?-bagof(X, ZY(eleve(X, Y, Z), masculin(X)), B).
• gt B françois, françois, paul.
• Le prédicat setof/3
• idem que bagof/3, sauf que la liste est triée et
  les doublons exclus

20
Prédicats repeat

• Repeat
• Le prédicat repeat est toujours vrai (succès) et
  à chaque fois qu il est rencontré, une nouvelle
  branche d exécution est générée.
• Repeat peut être définie par
• repeat.
• repeat repeat.
• Exemple dutilisation
• carre
• repeat,
• read(X),
• (X stop, ! Y is XX, write(Y), fail ).

21
Entrées / sorties

• Le prolog standard ne connaît que l ASCII. Les
  entrées sorties sont primitives.
• Lire et écrire des caractères
• ?- get0(X).
• a ?
• gt X 65.
• ?- put0(65).
• gta.
• ?- get0(X).
• D
• gt X -1.

22
Entrées / sorties

• Lire et écrire des termes
• ?- read(X).
• pere(françcois, isa).
• gt X pere(françcois, isa).
• Read renvoie end_of_file en fin de fichier.
• ?- T pere(françois, isa), write(T).
• pere(francois, isa).
• ?- nl. Insère une nouvelle ligne.
• Ouvrir et fermer des fichiers
• see(fichier).
• Ouverture en lecture du fichier fichier. Le
  fichier devient le flux d entrée courant.
• see(user).
• Le flux courant redevient l utilisateur - le
• clavier

23
Entrées / sorties

• see(fichier).
• Rappelle fichier à l endroit où il était s il
  n a
• pas été fermé. Et il redevient le flux courant.
• seen.
• Fermeture du fichier ouvert en lecture.
• L utilisateur devient le flux courant.
• seeing(F).
• F s unifie au fichier en cours
• tell(fichier).
• Ouverture en écriture du fichier. Le fichier
  devient
• le flux de sortie courant.
• telling(F).
• F s unifie au fichier en cours

24
Entrées / sorties

• tell(user).
• Le flux courant de sortie redevient
  l utilisateur -
• le clavier.
• told.
• Fermeture du fichier ouvert en écriture.
• Exemples lecture d un fichier
• read_file(File, List)-
• see(F),
• read_list(List),
• seen,
• !.
• Read_list(XL)-
• get0(X), X \ -1, ! , read_list(L).
• Read_list().

25
Entrées / sorties

• Copie d un fichier dans un autre (supposés
  correctement ouvert)
• copie-
• repeat,
• ecrire(X),
• X end_of_file,
• !.
• ecrire(end_of_file).
• ecrire(X)-
• write(X), nl.
• Découpage de phrases en mots
• ?- tokenise(X).
• le petit chat.
• gt X le, petit, chat, ..

26
Termes préfixés et N-uplets

• Termes préfixés
• Codage
• Exemple du calcul booléen

27
Codage des termes préfixés (1)

• Donnons-nous une suite de propositions
• Il fait beau.
• Jean habite Lens.
• Pierre est le père de Marie...
• Associons leur des variables P, Q, R,
• Si on les relie à laide de connecteurs et, ou,
  non, on obtient des formules de logiques.

28
Codage des termes préfixés (2)

• Ces formules sont de la forme
• P et Q, P ou Q, non P,
• On peut alors construire
• (P et Q) ou (R et S)
• P et (Q ou (R et non(S)))
• Ce qui donne en notation préfixée (préférable)
• ou(et(P, Q), et(R, S))

29
Codage des termes préfixés (3)

• Ces formules sont représentées par des arbres.
• Exercice dessiner les arbres des 2 formules
  précédentes.
• Ces structures sont appelées des termes préfixés.
  Cette notation est utilisée pour représenter
• des relations parle(louis, chinois)
• des fonctions.

30
Codage des termes préfixés (4)

• Le nombre darguments ne dépend que de la
  relation ou de la fonction utilisées.
• La seule restriction est que le terme qui sert à
  préfixer doit être un identificateur, il ne peut
  sagir dune variable.

31
Calcul booléen (1)

• Illustration de lutilisation des termes
  préfixés.
• Attribuons
• la valeur 1 à une proposition vraie
• la valeur 0 à une proposition fausse.
• Exercice écrire les règles du calcul booléen
  associées aux propositions suivantes et(P, Q),
  ou(P, Q), non(P).

32
Calcul booléen (2)

• Problème écrire les règles qui calculent la
  valeur booléenne dune formule.
• Nous allons travailler sur lexemple
• et(ou(0, non(1)), et(1, non(0)))
• Exercice représenter larbre associé à cette
  formule.

33
Calcul booléen (3)

• Approche naturelle
• appeler les règles valeur-booleenne
• y faire figurer 2 arguments la formule à
  évaluer et le résultat de l'évaluation.
• Il y a deux types de formules au sein de larbre
  représentatif
• les nœuds en et, ou, non
• les feuilles 0 et 1

34
Calcul booléen (4)

• Règles relatives aux feuilles
• R1 valeur-booleenne(0, 0).
• R2 valeur-booleenne(1, 1).
• Examinons les regles relatives à une formule
  et(P, Q)
• R3 valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, U),
• valeur-booleenne(Q, V),
• combiner-et(U, V, B).

35
Calcul booléen (5)

• Avec
• R6 combiner-et(1, 1, 1).
• R7 combiner-et(1, 0, 0).
• R8 combiner-et(0, 1, 0).
• R9 combiner-et(0, 0, 0).
• Exercice écrire les autres règles
• R4 valeur-booleenne(ou(P, Q), B)
• R5 valeur-booleenne(non(P), B)
• R10 à R15 règles combiner-ou et combiner-non

36
Calcul booléen (6)

• Commentaires
• Le programme est conçu de façon purement
  déclarative.
• Chacune des règles correspond à un cas
  spécifique, il ny a pas de remontée possible.
• R3, R4, et R5 sont des règles récursives. R1 et
  R2 sont les règles d'arrêt.

37
Calcul booléen (7)

• Améliorations du programme
• Nest-il pas possible darranger les règles ?
• 1) remarque sur le et(0, _) et modification de
  valeur-booléenne
• 2) introduction de coupure
• 3) comment supprimer la coupure ?
• 4) introduction de poursuivre-et
• 5) simplification des règles
• 6) adaptation du raisonnement à ou

38
Calcul booléen (8)

• Amélioration 1
• et(0, Q) donne toujours la valeur faux. Il nest
  donc pas nécessaire d'évaluer Q. Doù la règle
• S1 valeur-booleenne(et(P, Q), 0) -
• valeur-booleenne(P, 0).
• S2 valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, U),
• valeur-booleenne(Q, V),
• combiner-et(U, V, B).

39
Calcul booléen (9)

• Amélioration 2
• Lamélioration 1 na rien apportée car si P vaut
  0, S1 sapplique, et le programme se poursuit.
  Lors de la remontée, il applique S2 !!
• S1 valeur-booleenne(et(P, Q), 0) -
• valeur-booleenne(P, 0) !.
• S2 valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, U), valeur-booleenne(Q, V),
• combiner-et(U, V, B).

40
Calcul booléen (10)

• Amélioration 3
• Problème du cut détruit laspect déclaratif du
  programme en introduisant un contrôle sur
  lexécution. Pour le supprimer, il suffit de
  réserver S2 aux cas où P est vraie.
• S1 valeur-booleenne(et(P, Q), 0) -
• valeur-booleenne(P, 0).
• S2 valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, 1), valeur-booleenne(Q, V),
• combiner-et(1, V, B).

41
Calcul booléen (11)

• Amélioration 4
• On na pas progressé car P est toujours évalué 2
  fois. Le programme est toujours inefficace. Cest
  S1 la source du problème.
• S1 valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, U), poursuivre-et(U, Q, B).
• S2 poursuivre-et(0, Q, 0).
• S3 poursuivre-et(1, Q, B)- valeur-booleenne(Q,
  V),
• combiner-et(1, V, B).

42
Calcul booléen (12)

• Amélioration 5
• La règle S2 prend en compte le cas où la valeur
  booléenne de P est nulle. On peut donc supprimer
  des déclarations dans combiner-et.
• combiner-et(1, 1, 1).
• combiner-et(1, 0, 0).
• Mais si on efface combiner-et(1, V, B) sur ces
  deux règles, V et B prendront la même valeur. On
  peut donc supprimer combiner-et en identifiant V
  et B.

43
Calcul booléen (13)

• On a donc les règles
• valeur-booleenne(et(P, Q), B) -
• valeur-booleenne(P, U), poursuivre-et(U, Q, B).
• poursuivre-et(0, Q, 0).
• poursuivre-et(1, Q, B) - valeur-booleenne(Q, B).
• Exercice écrire de la même façon les règles de
  ou(P, Q) et de non(P).
• La première version était plus lisible, mais nous
  avons supprimé 4 règles et gagné énormément en
  efficacité.

44
Conclusion - termes préfixés

• Nous avons généralisé la structure de liste en
  définissant les termes préfixés, ou encore des
  arbres dont le nœuds ne sont pas seulement des
   . , mais des identificateurs. Nous allons
  maintenant voir des arbres dont les nœuds peuvent
  être des variables, et plus seulement des
  identificateurs.