ELFE - DS1 (durée: 90 min)

Licence d’informatique – 2012/2013
ELFE - DS1 (durée: 90 min)
mars 2013
Exercice 1 : Dans cet exercice, vous analysez le programme Datalog (DES) P1 suivant :
q1 ( a , b ) .
q3 ( a , b ) .
p (X,Y) :− q1 (Y, Z ) , not ( q2 (Z ,X) ) , q3 (X, P ) . % r e g l e 1
q2 (Z ,X) :− q4 (Z ,Y) , q3 (Y, Z ) .
% regle 2
q4 (Z ,Y) :− p (Z ,X) , q3 (X,Y ) .
% regle 3
Question 1.1 : Le programme P1 est-il sur ? Argumentez pour chacune des règles. Pour les
règles non sures, proposez une correction, quand c’est possible.
Correction:
– règle 1 : l’utilisation de la variable X dans le corps est problématique : pas de liaison avant
d’apparaitre sous la negation. Donc, cette regle n’est pas sure. Correction : p(X, Y ) :
−q1(Y, Z), q3(X, P ), not(q2(Z, X)).
– règle 2 : utilisation de variable X dans la tête de la règle n’est pas sure. Il n’y a pas de
correction possible.
– règle 3 : aucun problème, cette règle est sure. Toutes les variables de la tete apparaissent
dans le corps, dans des predicats definis par le programme, sous forme positive,
Pour résumer : le programme n’est pas sur, puisqu’il contient des regles non sures.
Question 1.2 : Donnez le graphe des dépendances de P1 .
Correction:
p
-
q1
q2
q3
q4
2
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
Question 1.3 : Le programme P1 est il stratifiable ? Si oui, donnez la strate de chacun des
prédicats. Si non, expliquez pourquoi.
Correction:
Non, le programme n’est pas stratifiable. Il y a un cycle
q2 → p → q4 → q2 → . . .
incluant un arc négatif de q2 à p.
Exercice 2 : Le programme Datalog (DES) P2 décrit un réseau social. Il a les prédicats :
• personne(Id, N, A) : une personne identifiée par Id, du nom N, de l’âge A.
• amitie(Idx, Idy) : les personnes Idx et Idy ont mutuellement confirmé leur lien
amical. Une règle prédéfinie assure la symétrie.
• aime(P id, S) : la personne P id s’intéresse au sujet S.
• lieu(Lid, L, A, T ) : un lieu nommé L, identifiant Lid, à l’adresse A, de thématique T .
• f requente(P id, Lid) : la personne P id fréquente le lieu Lid.
Les identifiants et âges sont des entiers, les autres données des strings. Exemples :
l i e u ( 1 , ’ d o j o h a r a k i r i ’ , ’ 3 r ue Pasteur , 5 9 1 2 3 M a v i l l e ’ , ’ k a r a t e ’ ) .
aime ( 1 , ’ mangas ’ ) .
Question 2.1 : Donnez un exemple d’instanciation pour chacun des 5 prédicats, en vous
inspirant des exemples ci-dessus.
Correction :
p e r s o n n e ( 3 , ’ susanne gourmande , 2 0 ’ ) .
amitie (1 ,3).
aime ( 3 , ’ c h o c o l a t ’ ) .
l i e u ( 2 , ’ meert ’ , ’ 3 r ue Esquermoise , 59000 L i l l e ’ , ’ g a u f f r e s ’ ) .
frequente (3 ,2).
Question 2.2 : Formulez un prédicat pourrait interesser(Id, S), qui est vrai si au moins
deux amis de la personne Id aiment le sujet S.
Correction :
p o u r r a i t i n t e r e s s e r ( Id , S ) :−
a m i t i e ( Id , A1 ) ,
a m i t i e ( Id , A2 ) ,
A1 \= A2 ,
aime (A1 , S ) ,
aime (A2 , S ) .
Question 2.3 : Le réseau social cherche à mettre en relation des gens sur la base de leurs
centres d’intérêts. Formulez un prédicat suggestion amis(Id1, Id2) qui est vrai si les deux
personnes dont les identifiants sont Id1 et Id2 ont un ami commun, fréquentent le même
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
3
lieu, et s’intéressent au même sujet.
Correction :
s u g g e s t i o n a m i s ( Id1 , Id2 ) :−
a m i t i e ( Id1 , Z ) ,
a m i t i e ( Id2 , Z ) ,
Id1\=Id2 ,
aime ( Id1 ,X) ,
aime ( Id2 ,X) ,
f r e q u e n t e ( Id1 ,Y) ,
f r e q u e n t e ( Id2 ,Y ) .
Question 2.4 : Definissez un nouveau prédicat populaire(T ) qui est vrai si au moins 1000
personnes fréquentent des lieux avec la thématique T .
Correction :
t h e m a t i q u e v i s i t e u r (T, Pid ) :−
l i e u ( Lid , , ,T) , f r e q u e n t e ( Pid , Lid ) .
p o p u l a i r e (T) :−
group by (
t h e m a t i q u e v i s i t e u r (T, Pid ) ,
[T] ,
(R=count , R>=1000)
).
Question 2.5 : Formulez un prédicat branche(Id) qui est vrai pour une personne Id, si tous
les lieux fréquentés par Id ont des thématiques populaires.
Correction :
f r e q u e n t e l i e u o u t ( Pid ) :−
p e r s o n n e ( Pid , , ) ,
l i e u ( Lid , , ,T) ,
f r e q u e n t e ( Pid , Lid ) ,
not ( p o p u l a i r e (T ) ) .
branche ( Pid ) :−
p e r s o n n e ( Pid , , ) ,
not ( f r e q u e n t e l i e u o u t ( Pid ) ) .
Question 2.6 : Dessinez le graphe des dépendances pour vos définitions de populaire,
branche et d’éventuels prédicats auxiliaires, si vous en avez introduits pour les Q2.4 et 2.5.
4
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
Correction:
3 branche
2 freqente_lieu_out
1 populaire
personne
1
1 thematique_visiteur
frequente
lieu
1
1
Exercice 3 : Soit le programme Datalog (DES) P3 avec les règles suivantes :
s (X)
t (X)
u (X)
w(X)
:−
:−
:−
:−
r 1 (X) ,
r 2 (X) ,
r 3 (X) ,
r 4 (X) ,
r (X ) .
r (X ) .
t (X ) .
s (Y) , u (Y) ,Y \= X.
et les faits
r1 ( a ) . r2 ( a ) . r3 ( a ) . r4 ( a ) . r ( a ) . r1 (b ) . r3 (b ) . r4 ( c ) .
Question 3.1 : Construisez le graphe de dépendances pour P3 .
Correction:
Remarque : l’inclusion de l’inegalite n’importe pas.
r
\=
s
t
u
w
r1
r2
r3
r4
Question 3.2 : Déterminez le résultat de la requête u(a), en précisant toutes les étapes (par
exemple en dessinant un arbre de preuve).
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
Correction:
5
u(a) regle 3
r3(a)
t(a)regle 2
r2(a) r(a) Il est
Le fait est VRAI, nons montrons son arbre de preuve.
important de noter que les faits des feuilles en vert sont contenus dans la EDB. Si des faits
en feuilles n’etaient pas contenus dans EDB, on n’aurait pas de preuve. Le resultat de la
requete serait vide, c.a.d. le resultat de la requete dirait faux.
Question 3.3 : Calculez le plus petit point fixe de P3 .
Correction:
Commencean avec les faits pour prédicats EDB donnes en haut, on ajoute en premiere
iteration (c.a.d. application des regles applicables sur les faits existants) {s(a), t(a, )} , puis
en seconde iteration {u(a)}, puis en troisieme {w(c)}. Aves la troisieme iteration, le point
fixe est atteint.
Question 3.4 : L’ensemble suivant est-il un modèle du programme P3 ?
{r1(a), r2(a), r3(a), r4(a), r(a), r1(b), r3(b), r4(c), t(a), s(b), w(c)}
Correction:
non, puisqu’il manque : u(a), s(a), t(a). De plus, s(b) ne peut pas etre deduit, mais ce n’est
pas l’argument qui compte.
Exercice 4 : Imaginons un mini-langage de programmation, très simplifié, qui contient
une instruction PRINT, des variables et des opérations arithmétiques. Les lignes de code
sont numérotées, pour qu’on puisse s’y repérer. Voici un programme d’exemple (il se trouve
que c’est l’algorithme optimal pour élever un nombre à la puissance 15) :
// Exemple 1
1:
a := 42
2:
b := a*a
3:
c := b*a
4:
d := c*c
5:
e := d*d
6:
f := e*c
7:
PRINT f
//
//
//
//
//
b
c
d
e
f
=
=
=
=
=
42^2
42^3
42^6
42^12
42^15
Dans un premier temps, on voudrait utiliser DataLog pour essayer de détecter des bugs
dans des programmes. Pour cela, on modélise les programmes de ce langage simplifié avec
deux prédicats :
6
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
• read(V,L) si la variable V est lue ligne L.
• write(V,L) si la variable V est écrite ligne L.
Pour le programme d’exemple on aurait :
write(a,1).
read(a,2).
read(a,3).
read(c,4).
read(d,5).
read(c,6).
read(f,7).
read(b,3).
read(e,6).
write(b,2).
write(c,3).
write(d,4).
write(e,5).
write(f,6).
Question 4.1 : Une erreur courante des programmeurs débutants consiste à lire la valeur
d’une variable avant d’avoir initialisé la variable en question. Ecrivez un prédicat bad read(X)
qui est vrai si la variable X est lue avant d’avoir été écrite.
Correction :
w r i t t e n a t (X, L) :− write (X, L1 ) , L1 < L .
b a d r e a d (X) :− read (X, L ) , not ( w r i t t e n a t (X, L) ) .
Question 4.2 : Dans la même famille, si une variable est écrite, mais n’est pas lue par la
suite, c’est qu’il y a sûrement un problème. Définissez un prédicat f orgotten(X, L) qui est
vrai si la variable X est modifiée ligne L, mais n’est plus jamais lue ensuite.
Correction :
r e a d a f t e r (X, L) :− read (X, L a f t e r ) , L a f t e r > L .
f o r g o t t e n (X, L) :−write (X, L ) , not ( r e a d a f t e r (X, L ) ) .
Question 4.3 : Pour étendre le résultat de la question précédente, on pourrait remarquer
que si une variable est modifiée à la ligne L1 , puis modifiée à la ligne L2 , mais qu’elle n’a
pas été lue entre les deux, alors la valeur stockée ligne L1 est perdue. Cela peut indiquer
un bug (mais pas tout le temps). Étendez le prédicat f orgotten(X, L) pour détecter cette
situation.
Correction :
r e a d b e t w e e n (X, L1 , L2 ) :− read (X, L ) ,
L1<L ,
L<L2 .
f o r g o t t e n (X, L1 ) :−
write (X, L1 ) , write (X, L2 ) , not ( r e a d b e t w e e n (X, L1 , L2 ) )
On ajoute maintenant à notre langage les instructions IF et GOT O (GOT O i signifie
que l’exécution continue à la ligne i). Voici un autre programme d’exemple (il calcule le
42-ème nombre de Fibonacci) :
Licence d’informatique – 2012/2013 : ELFE - DS1 (durée: 90 min)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
7
n := 42
a := 0
b := 1
IF n == 0 THEN GOTO 11
c := a + b
a := b
b := c
m := n - 1
n := m
GOTO 4
PRINT b
Pour modéliser les GOT Os et les IF s, on utilise un prédicat succ(L1, L2) qui est vrai
s’il est possible de passer de la ligne L1 à la ligne L2 . Dans l’exemple de Fibonacci on
aurait :
succ(1,2).
succ(5,6).
succ(10,4).
succ(2,3).
succ(6,7).
succ(3,4).
succ(7,8).
succ(4,5).
succ(8,9).
succ(4,11).
succ(9,10).
Question 4.4 : [Attention, cette question est difficile] Reprogrammez les prédicats bad read
et f orgotten. Le principal changement c’est que maintenant l’ordre d’exécution des instructions ne correspond plus aux numéros des lignes. Une des difficultés vient du fait que
la même ligne peut éventuellement être exécutée plusieurs fois.
Correction :
path ( L1 , L2 ) :− s u c c ( L1 , L2 ) .
path ( L1 , L2 ) :− s u c c ( L1 , I ) , path ( I , L2 ) .
h a s b e e n w r i t t e n a t (X, L) :− path ( 1 , L1 ) , write (X, L1 ) , path ( L1 , L ) .
b a d r e a d (X) :− read (X, L ) , not ( h a s b e e n w r i t t e n a t (X, L) ) .
r e a d a f t e r (X, L) :− read (X, L a f t e r ) , path (L , L a f t e r ) .
f o r g o t t e n (X, L) :−write (X, L ) , not ( r e a d a f t e r (X, L ) ) .
r e a d b e t w e e n (X, L1 , L2 ) :− path ( L1 , L ) , read (X, L ) , path (L , L2 ) .
f o r g o t t e n (X, L1 ) :− write (X, L1 ) , write (X, L2 ) , not ( r e a d b e t w e e n (X, L1 , L2 ) ) .