Plan

Programmation Logique
Sup Galilée-INFO2

1 Aspects avancés de PROLOG

Céline Rouveirol

2016-2017

Programmation Logique - 1/24 Programmation Logique - 2/24

Prédicats non logiques Exemple : Unification en PROLOG

unify(X,Y) :-
Prédicats de types pour les termes : var(X), nonvar(X),
var(X), var(Y), X=Y.
atom(X), integer(X), atomic(X), compound(X) ....
unify(X,Y) :-
Comparaison de termes : X = Y, X \= Y, X == Y, X \== Y, var(X), nonvar(Y), not occurs in(X,Y), X=Y.
... unify(X,Y) :-
Accès aux structures functor(Terme,Foncteur,Arité), var(Y), nonvar(X), not occurs in(Y,X), Y=X.
arg(Nieme,Terme,Arg), Terme =.. Liste où Liste = unify(X,Y) :-
[Foncteur|LArgs] nonvar(X), nonvar(Y), atom(X), atom(Y), X=Y.
Entrées / Sorties : voir la doc en ligne ... unify(X,Y) :-
nonvar(X), nonvar(Y), compound(X), compound(Y),
Prédicats arithmétiques : is, +, -, >, <, =<, ...
term unify(X,Y).

Programmation Logique - Aspects avancés de PROLOG 3/24 Programmation Logique - Aspects avancés de PROLOG 4/24
 Contrôle en PROLOG Le cut : introduction

Coupe choix, ! : contrôle dynamique du bactrack PROLOG.

Conjonction : , Affecte le comportement procédural des programmes
Disjonction : ; PROLOG : élaguage dynamique de l’arbre de recherche de
Coupure : ! PROLOG.
Appel méta de l’interprète : call(X) où X est un but Avantage : efficacité accrue des programmes PROLOG (cuts
PROLOG. verts). Inconvénient : pas d’interprétation déclarative.
If-then-else : (P -> Q; R) Le cut empêche de remettre en cause tous les choix qui ont
été faits depuis le moment où le but parent a été unifié avec
If -then : (P -> Q)
la tête de la clause où apparaı̂t le cut.
true,fail
Le cut est un prédicat qui réussit toujours et qui ne réussit
qu’une fois.

Programmation Logique - Aspects avancés de PROLOG 5/24 Programmation Logique - Aspects avancés de PROLOG 6/24

Le cut : exemple Le cut en pratique

empêche de considérer les autres clauses de la même

procédure qui sont situées après celle qui contient le cut.
empêche de remettre en cause les sous buts du corps de la
clause contenant le cut placés avant le cut.
n’affecte en rien la façon dont sont résolus les buts après le
cut.
! ! ! Sensibilité accrue à l’ordre des clauses (non déclarativité).
Son utilisation :
on veut élaguer des branches qui ne mènent pas à une solution.
on ne veut pas produire toutes les solutions

Programmation Logique - Aspects avancés de PROLOG 7/24 Programmation Logique - Aspects avancés de PROLOG 8/24
 Différents types de cuts Le cut “vert”

Dans tous les cas, l’interprétation procédurale du programme Rend un programme déterministe, élague une partie de l’arbre
est modifiée : le programme de n’exécute pas de la même recherche qui mènerait forcément à un échec.
manière avec ou sans coupe-choix Pour exprimer la nature mutuellement exclusive de tests (test
arithmétique, par exemple).
Dans certains cas, la signification déclarative du programme
max(X,Y,X) :- X >= Y.
est conservée (coupe-choix “vert”) : le programme a la même
max(X,Y,Y) :- X < Y.
interprétation logique avec et sans coupe-choix
peut se réécrire en
Dans les autres cas, la signification déclarative du programme
est modifiée (coupe-choix “rouge”) : le programme n’a pas la max2(X,Y,X) :- X >= Y,!.
même interprétation logique avec et sans coupe-choix. max2(X,Y,Y) :- X < Y.

Programmation Logique - Aspects avancés de PROLOG 9/24 Programmation Logique - Aspects avancés de PROLOG 10/24

Le cut “rouge” Autre exemple de cut rouge

Soit le programme défini s(1). s(2). s(3).

Ommission de tests, modification de la signification du progamme.
ps(X) :- s(X), !.
max3(X,Y,X) :- X >= Y,!. ds(X) :- ps(Y),s(X), X \== Y, !.
max3(X,Y,Y). ?- ps(X).
Attention ! max3(5,2,2) réussit ! X = 1;
No
max4(X,Y,Z) :- X >= Y,!, X=Z. ?- ds(X).
max4(X,Y,Y). X = 2;
No

Programmation Logique - Aspects avancés de PROLOG 11/24 Programmation Logique - Aspects avancés de PROLOG 12/24
 La négation en PROLOG Remarques sur le not
La terminaison de not X dépend de la terminaison de X.
Le cut permet de distinguer les actions à effectuer suivant p(s(X)) :- p(X).
qu’une condition est ou n’est pas vérifiée. Il permet donc de q(a).
représenter une forme restreinte de la négation logique, la ?- not(p(X),q(X)). ne termine pas
négation par l’échec.
L’ordre dans lequel les clauses sont écrites est très important
not X :- call(X),!, fail. (à cause du cut).
not X. Le not peut conduire à des réponses incorrectes si le(s) but(s)
Sémantique procédurale : si X réussit, not X échoue ; si X sur lesquels porte le not ne sont pas instanciés.
échoue, not X réussit. different(X,Y) :- not X = Y.
Attention : La négation par l’échec ne correspond pas à la ?- different(2,Y), Y=3.
négation logique, c’est-à-dire, si not X réussit, cela ne veut No.
pas forcément dire que X est faux, mais qu’on n’a pas pu not X n’instancie pas les variables de X en cas de succès.
prouver que X était vrai. not( not (X = Y)) teste si X et Y sont unifiables sans effet
de bord d’instanciation.
Programmation Logique - Aspects avancés de PROLOG 13/24 Programmation Logique - Aspects avancés de PROLOG 14/24

If then else If then else

Symbole de prédicat ->

If -> Then ; Else :-
call(If),!, Une autre implémentation de max(X,Y,Z)
call(Then). max(X,Y,Z) :- X =<Y -> Z=Y; Z=X.
If -> Then ; Else :- Ajouter un élément à un ensemble (pas de duplication
!, d’éléments add(E,L1,L2)
call(Else). add(X,L1,L2) :- member(X,L1) -> L2=L1; L2=[X|L1].
If -> Then :-
call(If),!,
call(Then).

Programmation Logique - Aspects avancés de PROLOG 15/24 Programmation Logique - Aspects avancés de PROLOG 16/24
 Modifications dynamiques d’un programme PROLOG Modifications dynamiques d’un programme PROLOG
Possibilité en Prolog de modifier dynamiquement la définition
de certains prédicats, préalablement déclarés dynamique. Utilisations possibles :
:- dynamic toto/2. ajout d’une clause dérivable par le programme
Prédicats prédéfinis assert/1, asserta/1, retract/1, (mémo-fonction)
permettent de modifier le programme
fib(0,1) :- !.
fib(1,1) :- !.
fib(N,F) :-
NA is N - 1, NB is N - 2,
fib(NA,FNA), fib(NB,FNB),
F is FNA + FNB,
asserta((fib(N,F) :- !)).
Complexité linéaire en fonction de N au lieu d’exponentielle.

Programmation Logique - Aspects avancés de PROLOG 17/24 Programmation Logique - Aspects avancés de PROLOG 18/24

Modifications dynamiques d’un programme PROLOG Ensemble de solutions

Utilisations possibles :
simulation d’une variable globale avec possibilité d’affectation
destructive. findall(T,But,L) :- call(But), assertz(sol(T)),
affecter(NomDrapeau,Valeur) :- fail.
nonvar(NomDrapeau), findall(T,But,L) :- assertz(sol(’fin’)), fail.
retract(tmpdrap(NomDrapeau,V)),!, findall(T,But;L) :- recup(L).
asserta(tmpdrap(NomDrapeau,Valeur)). recup([T|Q]) :- retract(sol(T)), T \== ’fin’,
affecter(NomDrapeau, Valeur) :- recup(Q).
nonvar(NomDrapeau), recup([]).
asserta(tmpdrap(NomDrapeau,Valeur)).
valeur(NomDrapeau, Valeur) :-
tmpdrap(NomDrapeau,Valeur).

Programmation Logique - Aspects avancés de PROLOG 19/24 Programmation Logique - Aspects avancés de PROLOG 20/24
 Ensemble de solutions Findall, example

findall(+Motif, +But, Liste) créé une liste Liste des s(b,1). s(a,1). s(c,1). s(d,2).
instanciations de Motif pour tous les succès de But. Si But ?- bagof(T,s(T,1),L).
?- findall(T,s(T,1),L). L = [b, a, c] ;
n’a pas de solution, alors findall retournera la liste vide. L = [b, a, c] ; No
bagof(+Motif, +But, -Liste) se comporte comme No ?- bagof(T,s(T,X),L).
findall/3, à la différence que : bagof/3 échoue si But n’a ?- findall(T,s(T,X),L). X = 1
pas de solution et qu’il a un comportement différent L = [b, a, c, d] ; L = [b, a, c] ;
concernant les variables libres de Motif. No X = 2
?- findall(T,s(T,3),L). L = [d] ;
setof(+Motif, +But, -Liste) se comporte comme L = [] ; No
bagof/3, à la différence que : il y a suppression des doublons No ?- bagof(T,s(T,3),L).
dans Liste et Liste est triée en utilisant le prédicat sort/2 No

Programmation Logique - Aspects avancés de PROLOG 21/24 Programmation Logique - Aspects avancés de PROLOG 22/24

Ensemble de solutions, exemple Bagof, exemple

foo(a, b, c). foo(a, b, d). foo(b, c, e). foo(a, b, c). foo(a, b, d). foo(b, c, e).
foo(b, c, f). foo(c, c, g). foo(b, c, f). foo(c, c, g).

?- findall(C, foo(A, B, C), Cs). ?- bagof(C, A∧foo(A, B, C), Cs).

Cs = [c, d, e, f, g]. B = b, Cs = [c, d] ;
B = c, Cs = [e, f, g].
?- bagof(C, foo(A, B, C), Cs).
A = a, B = b, Cs = [c, d] ; ?- bagof(C, A∧C∧foo(A, B, C), Cs).
A = b, B = c, Cs = [e, f] ; B = b, Cs = [c, d] ;
A = c, B = c, Cs = [g]. B = c,Cs = [e, f, g].

Programmation Logique - Aspects avancés de PROLOG 23/24 Programmation Logique - Aspects avancés de PROLOG 24/24