IFT2030 -- Travail pratique #2 -- 2006-02-22 PROGRAMMATION LOGIQUE EN PROLOG (Marc Feeley)
Le TP2 a pour but de vous faire pratiquer la programmation logique en Prolog et en particulier les concepts suivants:
- l'algorithme de résolution des requêtes en Prolog, - l'unification de termes,
- la représentation des données en Prolog.
1. Programmation
Le travail consiste à résoudre deux problèmes inspirés de 'intelligence artificielle: les n dames et la traversée de labyrinthes. Plusieurs relations sont fournies pour vous aider à réaliser le travail. Il s'agit de relations d'arithmétique sur les naturels et de traitement des listes.
Ces relations sont dans le fichier "~dift2030/tp2/recherche.pl".
1.1 Spécification des problèmes 1.1.1 Les n dames
Considérez un échiquier de n par n cases. On doit placer n dames sur l'échiquier de façon à ce qu'aucune ne puisse prendre une autre. C'est-à- dire qu'il n'y a pas deux dames sur la même colonne, la même rangée ou la même diagonale. Une disposition des dames respectant cette contrainte est une solution au problème. L'objectif consiste à trouver les solutions au problème pour un n donné. Par souci de simplicité, on considère que des solutions qui diffèrent seulement par une rotation ou une symétrie de l'échiquier sont quand même différentes. Par exemple, pour n=4 il y a 2 solutions:
+---+---+---+---+ +---+---+---+---+
| | | D | | | | D | | | +---+---+---+---+ +---+---+---+---+
| D | | | | | | | | D | +---+---+---+---+ +---+---+---+---+
| | | | D | | D | | | | +---+---+---+---+ +---+---+---+---+
| | D | | | | | | D | | +---+---+---+---+ +---+---+---+---+
1.1.2 Traverser un labyrinthe
Un labyrinthe est donné sous la forme d'une matrice de "booléens" (une liste de listes d'atomes `t' et `f'). Une entrée de la matrice qui contient vrai (`t') indique une case par où le chemin peut passer. La valeur faux (`f') indique une case par où le chemin ne peut passer (un mur). Le but consiste à partir de la case supérieure gauche (l'entrée du labyrinthe) et à se rendre à la case inférieure droite (la sortie), en passant d'une case libre à une case libre voisine. Voici un labyrinthe tel que fourni dans le TP et une transcription plus visuelle:
+---+
[[t,f,t,t,t,t,t,t,t], |E# | [t,f,t,f,f,f,t,f,t], | # ### # | [t,f,t,f,t,f,t,f,t], | # # # # | [t,f,t,f,t,f,t,f,t], | # # # # | [t,t,t,t,t,f,t,f,t], => | # # | [f,f,t,f,t,f,t,f,f], |## # # ##|
[t,t,t,f,t,f,t,t,t], | # # | [f,f,f,f,f,f,t,f,t], |###### # | [t,t,t,t,t,t,t,f,t]] | #S|
+---+
Afin de simplifier le problème, l'ensemble des cases libres forme un arbre. Ceci implique qu'entre deux cases libres quelconques du labyrinthe, il y a un et un seul chemin possible (qui ne passe pas deux fois par la même case).
1.2 Format des solutions
Pour chaque problème, définissez une relation qui met en relation le paramètre du problème et chacune des solutions (et seulement ces solutions). C'est-à-dire, que si <n> est un paramètre et <sol> est une solution correspondante, alors ils sont dans la relation. Autrement dit, la requête:
| ?- relation(<n>,<sol>).
réussit.
Utilisez les noms indiqués pour la relation attachée à chaque problème.
1.2.1 Les n dames (relation: ndames(N,Solution))
Une solution est représentée par une liste de n entiers. Le i-ème entier d'une liste est le numéro de la rangée où se trouve la dame positionnée sur la i-ème colonne. Sur l'échiquier les colonnes et rangées sont numérotées à partir de 1. Par exemple, pour le problème des 4 dames [3,1,4,2] est une solution:
| ?- ndames(4,[3,1,4,2]).
yes
1.2.2 Traverser un labyrinthe (relation: traverser(Laby,Chemin))
Puisque le labyrinthe est un arbre, il y a toujours un seul chemin non- cyclique de l'entrée à la sortie. C'est ce chemin qui est désiré. Il doit être retourné sous la forme d'une liste de coordonnées. Chaque coordonnée est une liste de deux entiers. Les coordonnées suivent la numérotation utilisée dans les matrices: le numéro de rangée vient avant le numéro de colonne. La première rangée et la première colonne ont le numéro 0. Les coordonnées [0,0] et [m-1,n-1] doivent être incluses dans le chemin. Le chemin traversant le labyrinthe présenté en exemple dans la définition du problème est:
[[0,0],[1,0],[2,0],[3,0],[4,0],[4,1],[4,2],[3,2],[2,2],[1,2], [0,2],[0,3],[0,4],[0,5],[0,6],[1,6],[2,6],[3,6],[4,6],[5,6], [6,6],[6,7],[6,8],[7,8],[8,8]]
1.3 Directives diverses
Nous utiliserons l'interprète Prolog "SICSTUS". Pour l'utiliser vous devez tout d'abord exécuter, au shell, la commande "inclure sicstus".
Ensuite il faut exécuter la commande "sicstus".
Afin de bien vous faire saisir la façon de programmer dans un langage logique, nous vous demandons de programmer vos relations dans un style pur. C'est-à-dire que vous devez éviter d'utiliser les relations méta- logiques, la négation et la coupure (cut, "!") qui sont disponibles dans l'interprète SICStus Prolog. Le style de programmation utilisé dans l'écriture du fichier "recherche.pl" n'est donc pas à imiter dans ce travail (car nous avons utilisé un style impur pour définir certaines relations).
Voici la liste des relations qui sont fournies dans "recherche.pl":
add(X,Y,Z) X + Y = Z between(Lo,X,Hi) Lo <= X <= Hi lesseq(X,Y) X <= Y less(X,Y) X < Y greatereq(X,Y) X >= Y greater(X,Y) X > Y equal(X,Y) X = Y noteq(X,Y) X <> Y
longueur(L,N) la liste L est de longueur N labyrinthe(Laby) Laby est un des labyrinthes de test Vos relations doivent mettre en relation toutes les paires paramètre et solution valides. Évidemment, ils doivent se restreindre uniquement à ces paires.
En plus d'être correctes, nous demandons à vos relations d'être complètement réversibles. C'est-à-dire qu'il devrait être possible de faire trouver un paramètre à partir d'une solution aussi bien que de faire trouver une solution à partir d'un paramètre. Il devrait même être possible de faire générer les paramètres et les solutions à la fois. Par exemple, la requête:
| ?- ndames(N,Sol).
N = 0, Sol = [] ? ; N = 1, Sol = [1] ? ; N = 4,
Sol = [3,1,4,2] ? ; N = 4,
Sol = [2,4,1,3] ? ; N = 5,
Sol = [4,2,5,3,1] ? ; ...
devrait générer indéfiniment des paires de paramètres et de solutions (il y en a évidemment une infinité).
Un des problèmes avec l'énumération infinie de paires est la question de l'exhaustivité de cette énumération. C'est-à-dire: est-ce que toutes les paires peuvent être générées? Il ne faut pas confondre cette question avec celle demandant si toutes les paires sont générées. Il est clair que l'on ne peut faire générer toutes les paires à cause de leur nombre infini. Mais on peut vérifier si l'énumération pourrait atteindre une paire si on laissait l'énumération se poursuivre assez longtemps, et ce, peu importe la paire. Par exemple, une énumération **non-exhaustive**
pour le problème des n dames pourrait être: pour chaque n pour lequel il y a une solution, dans l'ordre, générer n ainsi qu'**une** des solutions au problème des n dames. On sait qu'il y a deux solutions au problèmes des 4 dames. Or, il est clair qu'une fois que notre énumération a produit 4 et une des solutions, elle ne reviendra plus à n=4 pour générer l'autre solution. On a donc une énumération infinie mais **non- exhaustive**. Pour compléter l'exemple, une énumération exhaustive pourrait être: pour chaque n pour lequel il y a une solution et pour chaque solution au problème des n dames (pour ce n), générer cette paire.
Une autre question est la terminaison du calcul dans les cas où toutes les réponses possibles ont été énumérées. Par exemple, dans le cas du problème des 4 dames, la relation devrait produire une des solutions, ensuite l'autre solution et finalement indiquer l'échec. Il ne devrait pas provoquer des calculs sans fin lorsque l'utilisateur demande une éventuelle troisième réponse. Aussi, le fait qu'il y ait une infinité de
solutions à une certaine requête ne justifie pas que le calcul boucle à l'infini à la demande d'une prochaine solution sans produire la prochaine solution.
Vos relations doivent éviter de produire plusieurs fois la même réponse à une requête. Par exemple, lorsque l'on demande à la relation `ndames' de produire les solutions au problème des 4 dames, il ne devrait produire qu'une seule fois chaque solution.
Ces directives n'ont pas toutes la même importance dans ce travail. On peut les classer en ordre décroissant d'importance:
1. correction (c'est à dire, les solutions trouvées sont correctes) 2. terminaison du calcul
3. programmation logique pure 4. unicité des réponses 5. réversibilité 6. exhaustivité
La note attribuée à votre travail sera en fonction de l'importance des directives. La dernière directive risque d'être très difficile à respecter. Nous vous recommandons de ne pas perdre trop de temps à tenter de réussir ce point.
En ce qui concerne le style de programmation de vos relations, nous vous conseillons d'adopter une approche similaire à celle qui est recommandée dans la plupart des autres langages. Ne tentez pas de tout résoudre dans la programmation d'une seule grosse relation. Découpez la tâche en plusieurs relations simples qui ont chacune un rôle bien défini à accomplir. De plus, commentez chacune de vos relations pour qu'on puisse comprendre ce qu'elles font. Par exemple, pour une relation
"longueur(L,N)":
% La relation longueur(L,N) est satisfaite si le nombre d'éléments
% dans la liste L est égal à N.
2. Rapport
Vous devez rédiger un rapport qui, pour chaque problème, décrit:
- l'approche utilisée pour exprimer la relation,
- les problèmes rencontrés en voulant respecter les directives et les solutions apportées
et qui décrit l'impact de Prolog dans la réalisation d'un programme de résolution des problèmes soumis.
3. Évaluation
- Ce travail compte pour 10 points dans la note finale du cours.
Indiquez votre nom clairement au tout début du programme.
- Le programme sera évalué sur 5 points et le rapport sur 5 points.
- Vous devez remettre votre rapport le mardi 21 mars au démonstrateur ou au professeur. Vous avez jusqu'à minuit le même jour pour remettre votre programme. Vous serez pénalisés de 5 points sur 10 par jour de retard.
- Vous devez remettre votre programme par remise électronique grâce à la commande suivante:
% remise ift2030 tp2 tp2.pl
Notez que le programme est contenu dans un seul fichier et que ce fichier ne doit pas contenir les relations du fichier "recherche.pl".
