Cours introduction à ASP (Programmation par ensembles réponses) – Cours et formation gratuit

Une (gentle?) introduction à ASP

(Programmation par ensembles

réponses)

Answer Set Programming

• Approche déclarative : modélisation du problème à résoudre sous formes d’axiomes et de contraintes exprimées dans un langage logique;

• Les modèles logiques solutions de l’ensemble de

formules, les ensembles réponses, sont les résultats du programme.

• Des solveurs associés effectuent la recherche d’une, de plusieurs, ou de l’ensemble des solutions.

Résolution en programmation classique

Programme : Comment résoudre

Programme : Comment résoudre

Problème

Problème SolutionsSolutions

Compilation du programme

(binaire) Compilation du

programme

(binaire) SortiesSorties

Spécification

programmation Interprétation

compilateur exécution

Résolution à base de modèles (et ASP)

Représentation du problème

(langage logique) Représentation du

problème (langage logique)

Problème

Problème SolutionsSolutions

Compilation du problème (formules booléennes) Compilation du

problème (formules booléennes)

Modèles (ensembles

réponses) Modèles (ensembles

réponses)

Modélisation Interprétation

Instancieur Solveur

Le langage Prolog, c’est différent d’ASP

?

• Prolog= Programmation en Logique, même domaine, approche

« déclarative » (on décrit des relations, pas des procédures).

• Syntaxiquement, il y a des ressemblances évidentes Terme

–Constante : entier, mot de {a-z, A-Z,0-9,_}* débutant par une minuscule.

–Variable : mot de {a-z,A-Z,0-9,_}* débutant par une majuscule.

–Fonction : constante(terme,… terme), opérateurs infixes (a+b) ou notations de liste - L=[a,b,c]=[a|U], U =[b,c], [c]=[c|[ ]]=‘.’(c,[]) -

Clause

–Fait : p(2,a).

– Règle : q(X) :- p(X,Y), q(Y).

– But : :- q(2).

Si p(X,Y) est vrai et q(Y) est vrai, alors q(X) est vrai aussi.

Si p(X,Y) est vrai et q(Y) est vrai, alors q(X) est vrai aussi.

Est-ce que q(2) est vrai?

p(2,a) est vrai.

• Spécification du problème : définir member(X,L) qui est vérifié si X est un élément de la liste L

x,L₁, member(x,L₁)   L₂,y L₁=[y|L₂]  (x=y  member(x,L₂))

• En Prolog :

member(X,[X|L]).

member(X,[Y|L]):- member(X,L).

Purement déclaratif ? Presque…

Un premier programme Prolog

member(a,[a]).

member(a,[a]).

member(b,[a,b,c]).

member(b,[a,b,c]).

domino_chain(L):- domino_chain(L, []).

domino_chain([X,Y|L], D):- domino(X,Y), admissible(X,Y,D),

domino_chain(L,[[X,Y]|D]).

domino_chain([], _D).

admissible(X,Y,L):- not_member([X,Y], L).

admissible(X,Y,L):- not_member([Y,X], L).

not_member(P, L):- member(P,L),!, fail.

not_member(P, L).

La négation : négation par échec

• Une approche plus déclarative: l’ordre des clauses n’a aucune importance.

• Le langage inclut l’opérateur de négation.

• On peut écrire des termes quelconques mais par contre, tout doit se ramener à du propositionnel.

• Les solutions sont des modèles de l’ensemble des clauses:

des ensembles d’atomes vrais dans la théorie décrite.

• Le langage inclut l’expression de critères à optimiser. Le solveur propose différents modes de raisonnement.

ASP vs Prolog

• Définition de domaine par un fait :

• Définition de domaine par une règle :

odomino(d(X,Y), croissant, left, X) :- domino(d(X,Y)).

odomino(d(X,Y), croissant, right, Y) :- domino(d(X,Y)).

odomino(d(X,Y),decroissant, left, Y) :- domino(d(X,Y)).

odomino(d(X,Y),decroissant, right,X) :- domino(d(X,Y)).

• Paramètres :

place(1.. chain_size).

.

Les dominos en ASP : définir les domaines

dir(left). dir(right). dice(0..6). sens(croissant; decroissant).

dir(left). dir(right). dice(0..6). sens(croissant; decroissant).

domino(d(X,Y)) :- dice(X), dice(Y), X<=Y.

domino(d(X,Y)) :- dice(X), dice(Y), X<=Y.

#const chain_size=28.

#const chain_size=28.

• Installation : http://potassco.sourceforge.net/

• Une version binaire linux/windows/mac :

http://www.cs.uni-potsdam.de/~sthiele/bioasp/downloads/bin/

• Appel : (liste des options avec option –help)

gringo domino1.lp -t Pour voir le modèle instancié généré

gringo input.lp model.lp –c chain_size=28 | clasp –stats 1 solution

clingo domino1.lp –n 10 10 solutions

gringo domino1.lp | clasp –n 0 Toutes les solutions

Utiliser les programmes de Potassco

clingo

• Langage simple mais très expressif

(très différent de la prog. linéaire, contient aussi la disjonction).

• Même base que Prolog (termes, clauses).

Commentaires % ou %* *% Alternatives a;b 1..3 a,b;;c,d

• Littéral : p not q

X<Y U!=V X+Y<5 - built-in -

1{r(X):q(X)}2 2{r(U):q(U)=U, s(V):t(V)=2} –condition, agrégat-

• Contrainte : :- p(X),q(X). :- not M-1{r(U+1):q(U)}, max(M).

• Optimisation : #maximize [ p=1@2, q(X,Y):X>0:Y<0=2@2].

#minimize [ t(X):s(X)=X-1@1 ].

• Sorties : #hide.

#show p(X). #show p/1. #show s(X):r(X).

Un peu de syntaxe (gringo 3)

• Il n’y a pas de notion de liste, on écrit directement les domaines comme vu précédemment.

ville(brest;rennes;nantes;paris;lille).

• Plus grande ville de France :

• Plus petite ville de France :

• On dispose en fait de la donnée du nombre d’habitants des villes dans le fichier france.lp, prédicat ville(Nom, Population).

Ecrire les mêmes prédicats sur le critère de la taille de la population.

Un premier programme ASP : plus petit et plus grand élément d’un domaine

plusgrandeville(V):- ville(V), U<=V:ville(U).

plusgrandeville(V):- ville(V), U<=V:ville(U).

pluspetiteville(V):- ville(V), not ville(U):ville(U):U<V.

pluspetiteville(V):- ville(V), not ville(U):ville(U):U<V.

• Choix d’une chaine de dominos complète:

Un domino a 1 orientation et 1 place, chaque place 1 domino orienté

• A écrire :

– Les doubles sont arbitrairement orientés dans le sens croissant;

– On veut commencer la chaîne par un double zéro;

– Les dominos doivent avoir les bords qui se touchent égaux.

domino1.lp : chaînage complet correct

1{ domino_chain(D,K,S) : place(K):sens(S)}1 :- domino(D).

:- 2{domino_chain(D,K,S) : domino(D):sens(S)}, place(K).

1{ domino_chain(D,K,S) : place(K):sens(S)}1 :- domino(D).

:- 2{domino_chain(D,K,S) : domino(D):sens(S)}, place(K).

• %Les doubles sont arbitrairement orientés dans le sens croissant

• %On veut commencer la chaîne par un double zéro

• % Les dominos doivent avoir les bords qui se touchent égaux

Une solution pour le chaînage de dominos

:- domino_chain ( d(X,X), K, decroissant ).

:- domino_chain ( d(X,X), K, decroissant ).

:- not domino_chain(d(0,0),1,croissant).

:- not domino_chain(d(0,0),1,croissant).

:- domino_chain(D1,K,O1), domino_chain(D2,K+1,O2), odomino(D1,O1,right,X), not odomino(D2,O2,left,X).

:- domino_chain(D1,K,O1), domino_chain(D2,K+1,O2), odomino(D1,O1,right,X), not odomino(D2,O2,left,X).

Un puzzle sur les dominos…

D11 D12 D13

D17 D14

D16 D15

• Placer correctement tous les dominos en 4 super-dominos (rectangles);

• Les dominos s’apparient en chaine ainsi que les coins des super- dominos;

• Total décroissant des points des super-dominos de gauche à droite.

• Optimisation :Total maximal pour le 1^er puis le 4ème superdomino ?

• Quelles sont toutes les solutions optimales possibles ?

• Y-a-t-il un pattern commun a l’ensemble des solutions ?

• Optimisation :Total maximal pour le 1^er puis le 4ème superdomino ?

• Quelles sont toutes les solutions optimales possibles ?

• Y-a-t-il un pattern commun a l’ensemble des solutions ?

D21 D22 D23

D27 D24

D26 D25

D31 D32 D33

D37 D34

D36 D35

D41 D42 D43

D47 D44

D46 D45

On ne considèrera que les solutions à une symétrie horizontale près

• Chaque place de domino à l’intérieur du super-domino est numérotée (de 1 à 7) dans l’ordre des aiguilles d’une montre;

• Hint : On n’a besoin de préciser que la valeur à gauche d’un domino, l’autre s’en déduit automatiquement par chaînage…

• Ecrire d’abord le programme générant comme ensembles réponses tous les super-dominos possibles (vérifier que les dominos diffèrent tous dans un deuxième temps)…

• …puis étendre pour choisir 4 super-dominos, chacun étant numéroté (de 1 à 4).

Modélisation des super-dominos

Générer tous les super-dominos possibles

#const nb_places=7. sdomino_place(1..nb_places). dice(0..6).

1{ldom_place(K,D):dice(D)}1:- sdomino_place(K).

#const nb_places=7. sdomino_place(1..nb_places). dice(0..6).

1{ldom_place(K,D):dice(D)}1:- sdomino_place(K).

1. Générer l’espace des possibles sans se soucier des dominos utilisés plusieurs fois

2. Eliminer les configurations avec des dominos égaux

domino(K1,DA,DB):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DA<=DB.

domino(K1,DB,DA):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DB<DA.

next_place(K,K1):- sdomino_place(K), K1=(K #mod nb_places)+1.

:-2 [ domino(K,DA,DB) : sdomino_place(K) ], dice(DA),dice(DB).

domino(K1,DA,DB):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DA<=DB.

domino(K1,DB,DA):- ldom_place(K1,DA), next_place(K1,K2), ldom_place(K2,DB), DB<DA.

next_place(K,K1):- sdomino_place(K), K1=(K #mod nb_places)+1.

:-2 [ domino(K,DA,DB) : sdomino_place(K) ], dice(DA),dice(DB).

%Constants

#const nb_sdominos=4. #const nb_places=7. dice(0..6).

%The superdomino frames and the 2 associated chaining relations.

sdomino_number(1..nb_sdominos). sdomino_place(1..nb_places).

next_sdomino(1,2;;2,3;;3,4).

next_place(K,K1):- sdomino_place(K), K1=(K #mod nb_places)+1.

%Choose the left part of dominos in the superdomino

1{ldom_place(I,K,D):dice(D)}1:- sdomino_number(I), sdomino_place(K).

% Horizontal symetry breaking : domino(1,2) < domino(7,6)

:- ldom_place(1,1,T1), ldom_place(1,7,T7), T7<T1.

:- ldom_place(1,1,T), ldom_place(1,7,T),

ldom_place(1,2,T2), ldom_place(1,6,T6), T6<T2.

domino2.lp : début de résolution du

puzzle

%Infer dominos from ldom_place and check they are all different

domino(I,K1,DA,DB):- ldom_place(I,K1,DA), next_place(K1,K2), ldom_place(I,K2,DB), DA<=DB.

domino(I,K1,DB,DA):- ldom_place(I,K1,DA), next_place(K1,K2), ldom_place(I,K2,DB), DB<DA.

:-2[domino(I,K,DA,DB):sdomino_number(I):sdomino_place(K)], dice(DA),dice(DB).

%Chain the sdominos so that corners are matching

:- ldom_place(I,3,T3), ldom_place(I,4,T4), ldom_place(I,5,T5), next_sdomino(I,J), [ ldom_place(J,1,T3),ldom_place(J,7,T5) ] 1.

%The sum of dices of superdominos must decrease from left to right

total(I,Sum):- Sum=[ldom_place(I,K,T):sdomino_place(K)=T], sdomino_number(I).

:- total(I,SumI), total(J,SumJ), next_sdomino(I,J), SumI<=SumJ.

domino2.lp : contraintes sur le puzzle

%The sum of all dices must be maximal

%#maximize[total(1,Sum)=Sum @2].

%#maximize[total(4,Sum)=Sum @1].

#maximize[ldom_place(1,K,T)=T @2].

#maximize[ldom_place(4,K,T)=T @1].

%Alternative if using cautious mode

%:- [ldom_place(1,K,T)=T]32.

%:- [ldom_place(4,K,T)=T]15.

#hide.

#show total/2.

domino2.lp : optimisation

• Meilleurs totaux 1 et 4 : 33 et 16 (utilisation heuristique Vsids).

• 22 solutions avec 33 et 16 (options --opt-all --opt-value=114,131).

• Intersection des solutions

ldom_place(1,4,3) total(4,16) total(3,17) total(2,18) total(1,33)

Réponses pour le puzzle des dominos

• Les possibilités du langage sont en fait plus complexes mais au-delà des possibilités d’un cours d’introduction.

• On peut écrire des programmes disjonctifs, ce qui signifie qu’il peut y avoir une alternative au niveau de la tête des clauses (e.g. p|q. ou p|q:-r.). Il faut alors faire appel à un solveur spécifique (claspD) et la complexité explose…

• Notons qu’il est possible d’utiliser la négation classique en utilisant le moins (e.g –p:-q.)

Remarque sur l’expressivité dans

gringo

• Techniquement, ASP offre un cadre unifié où sont intégrés des aspects bases de données, bases de connaissances, résolution de contraintes et programmation logique.

• Il est possible de faire de l’optimisation et d’utiliser différents modes de raisonnement pour chercher une solution, toutes, les meilleures, leur intersection ou leur union.

• La résolution des problèmes combinatoires est le cœur de cible d’ASP. En particulier c’est un candidat de choix pour attaquer des problèmes NP-complets et NP-difficiles (graphes,

raisonnement,…) du fait de la facilité de mettre au point et tester différents modèles et différentes heuristiques .

ASP, c’est utile dans quels cas ?

• remplacer des algorithmes classiques maîtrisés : pour faire du tri, du calcul ou du traitement de séquences, il faut

revenir à un langage de programmation classique. Le

langage de script Lua est inclus dans gringo pour les pré et post-traitements;

• travailler dans des espaces peu structurés et peu contraints ou des espaces difficiles à discrétiser.

• résoudre un problème qui nécessiterait de nombreuses étapes successives qui communiquent : un programme ASP ne permet pas d’écrire des procédures.

ASP ne doit pas être utilisé pour…

• Un programme positif est constitué d’un ensemble de règles (clauses définies) A:-B1,B2,…Bm ou A (la tête de la règle) et les B (le corps) sont des atomes (variables booléennes).

A:-B1,B2,…Bm correspond à la formule B1  B2  …  Bm

 A

• Un ensemble d’atomes X est clos pour un programme positif si pour l’ensemble de ses règles r,

corps(r)X  tête(r)X

(C’est un modèle du programme vu comme une formule).

• L’ensemble réponse (answer set) d’un programme positif P est le plus petit ensemble d’atomes qui soit clos pour P. Il existe et est unique.

Et la sémantique ? Programmes

positifs

• Un programme est constitué de manière plus générale d’un

ensemble de règles A:-B₁,B₂,…B_m, not B_m+1, not B_m+2,… not B_m+n

• Le réduit d’un programme par rapport à un ensemble d’atomes X est l’ensemble des règles A:-B₁,B₂,…B_m telles qu’aucun des B_m+1, B_m+2,… B_m+n n’appartient à X.

• Un ensemble réponse (on dit aussi modèle stable) d’un

programme P est un plus petit ensemble d’atomes clos pour le réduit de P (il peut y en avoir 0, 1 ou plusieurs).

Autrement dit, on ne met dans un modèle l’atome d’une tête de règle que si la règle est un fait (règle réduite à une tête) après en avoir enlevé les littéraux négatifs qui ne sont pas dans le modèle ou si tous les littéraux positifs du corps sont dans le modèle et aucun des littéraux négatifs.

Et la sémantique ? Programmes avec

not

• p:- p. q:- not p.

interprétations possibles : {p,q}, {p}, {q}, 

(stable si en réduisant le programme avec et par clôture, on retombe sur le même ensemble…)

• p:- not q. q:- not p.

interprétations possibles : {p,q}, {p}, {q},  Autre écriture 1{p,q}1.

• p:- not p.

interprétations possibles : {p}, 

Où l’on teste

si la sémantique de base est comprise…

• p:- p. q:- not p.

{p,q} : dans ce cas, le programme réduit est p:- p. dont l’ensemble clos minimal associé est , pas de stabilité

{p} : dans ce cas, le programme réduit est p:- p. dont l’ensemble clos minimal associé est , pas de stabilité

{q} : dans ce cas, le programme réduit est p:- p. q. dont l’ensemble clos minimal associé est {q}. OK

 : dans ce cas, le programme réduit est p:- p. q. dont l’ensemble clos minimal associé est {q}, pas de stabilité

• p:- not q. q:- not p.

ensembles réponses : {p}, {q}

• p:- not p.

pas d’ensemble réponse

Sémantique : solutions…

Un ensemble réponse contient des atomes du programme.

Tout élément d’un ensemble réponse est supporté par une règle Un ensemble réponse contient des atomes du programme.

Tout élément d’un ensemble réponse est supporté par une règle

• C’est le rôle de l’instancieur (grounder), qui agit comme une base de données déductive, de les traiter.

• Etant donné un programme P, on peut distinguer

– L’ensemble des termes sans variables H (univers de Herbrand);

– Pour une règle r l’ensemble des variables de r var(r).

• On définit le programme instancié ground(P) en remplaçant toutes les règles r par des règles instanciées ground(r) où les variables sont remplacées par des termes de H:

ground(r) = { r |  : var(r)  H}

• gringo est un instancieur intelligent réduisant au mieux le nombre d’instances produites. C’est en fait un véritable solveur qui s’occupe des aspects purement déterministes du calcul. Au total, un ensemble réponse est un ensemble minimal sur le réduit du programme instancié

Et les variables ?

• p(X,Y) :- q(X,Y). q(a,b). q(b,c).

• {a, b, c}

• { p(a,a):-q(a,a), p(a,b):-q(a,b), p(a,c):-q(a,c), p(b,a):-q(b,a), p(b,b):-q(b,b), p(b,c):-q(b,c), p(c,a):-q(c,a), p(c,b):-q(c,b), p(c,c):-q(c,c), q(a,b), q(b,c) }

• { p(a,b), p(b,c), q(a,b), q(b,c) }

Exemple de grounding…

{A₁,A₂,…A_m} :- B_m+1,B_m+2,…B_n, not B_n+1, not B_n+2,… not B_p

•Intuitivement : tout sous ensemble de {A1,A₂,…A_m} peut être inclus dans l’ensemble réponse lors de la clôture.

•Règle équivalente au programme suivant :

B:- B_m+1,B_m+2,…B_n, not B_n+1, not B_n+2,… not B_p. A₁:- B, not C₁. C₁:- B, not A₁.

A₂:- B, not C₂. C₂:- B, not A₂.

…

A_m:- B, not C_m. C_m:- B, not A_m.

•Ensembles réponses de : p. {q}:-p. ?

Extension à d’autres constructeurs…

• :- Bm+1,Bm+2,…Bn, ^not Bn+1, not Bn+2,… not Bp.

équivaut à

new :- Bm+1,Bm+2,…Bn, not Bn+1, not Bn+2,… not Bp, not new.

• p :- k{A1,A2,…Am}l

équivaut à

p :- q, not r.

q :- cc(A1, k).

r :- cc(A1, l+1).

cc(A1,I+1):- cc(A2,I), A1. cc(A1,I):- cc(A2,I), A1.

Et pour les contraintes d’intégrité et

les contraintes de cardinalité?

• En logique classique, si on fait croître une théorie, on ne peut qu’en déduire plus de faits :

{p, p q, (q  r) s} permet de conclure {p, p q, (q  r) s, q } Ajouter r à la théorie permet de conclure {p, p q, (q  r) s, q, r }

• La réalité de la science exprime des besoins un peu

différents : lorsqu’on dispose de plus de faits, une théorie peut être remise en question partiellement pour aboutir à un ensemble de conclusions réduite…

• ASP utilise une logique non monotone:

{p, p q, (q  r) s} permet de conclure {p, p q, (q  r) s, q, s } Ajouter r à la théorie permet de conclure {p, p q, (q  r) s, q, r }

Toutes les logiques se valent-elles ?

1. Prétraitement des données par un script Lua pour produire les faits de l’instance du problème traité;

2. Définition des domaines des variables;

3. Génération des choix d’ensembles réponse possible pour la classe de problèmes;

4. Test et filtrage des ensembles admissibles par contraintes d’intégrité; Réduction des solutions symétriques;

5. Optimisation hiérarchisée selon différents critères.

Méthodologie de programmation de

base

• On peut sans problème générer un programme instancié avec quelques millions de variables. Cependant, cette

limite est facilement atteinte par produits cartésiens : il faut limiter au maximum le nombre de variables différentes

dans une clause.

• Il y a un compromis à équilibrer entre les parties résolues par gringo et par clasp.

– Gringo dépense de la mémoire, il précalcule (tabule) tout ce qui peut être instancié à l’avance de manière déterministe.

– Clasp dépense du CPU, il effectue les choix et élague dynamiquement l’espace de recherche

• Le solveur va être d’autant plus efficace qu’il pourra apprendre des nouvelles contraintes en cours de

résolution : avoir un programme croisant des contraintes génériques mais redondantes peut être intéressant.

L’art de la modélisation : Warning !

• On n’échappe pas à la complexité, on peut juste tirer parti des particularités d’une instance de problème à résoudre : paramétrer l’espace de recherche de façon à faire dépendre la complexité

d’un paramètre qui garde des valeurs raisonnable (penser à iclingo).

• ASP permet d’exprimer facilement des propriétés mathématiques sur un espace de recherche : plus vous aurez de propriétés, mieux ça marchera !

• Il reste actuellement difficile de tracer un programme ASP pour savoir où se cache la partie complexe. Le découpage très

modulaire en clauses indépendantes facilite cependant la mise aux points : procéder par étapes ! Il existe un prototype de

profileur de l’exécution d’un programme mais qui n’est pas encore public.

De la complexité…

• Etant donné un graphe pondéré non orienté décrit par des faits trouver un circuit hamiltonien minimum sur ce graphe, c’est-à- dire un chemin en boucle qui passe une et une seule fois par tous les nœuds et minimise la somme des poids des arcs qu’il emprunte.

• Application à un circuit sur une carte routière de la France : france.lp.

Exemple de la recherche de circuit hamiltonien minimum

edge(Sommet1, Sommet2, Poids).

edge(Sommet1, Sommet2, Poids).

edge(X,Y,C):- edge(Y,X,C).

edge(X,Y):- edge(X,Y,_).

node(X;Y):- edge(X,Y).

min_node(X):- node(X), not node(Y): node(Y):Y<X.

1{cycle(X,Y):edge(X,Y)}1:-node(X).

1{cycle(X,Y):edge(X,Y)}1:-node(Y).

reached(Y):- cycle(X,Y), reached(X).

reached(Y):- cycle(X,Y), min_node(X).

:- node(X), not reached(X).

:- cycle(X,Y), cycle(Z,X), min_node(X), Z<Y.

#minimize[cycle(X,Y):edge(X,Y,C)=C].

#hide. #show cycle/2.

Programme du circuit hamiltonien

Définir les domaines Définir les domaines

Générer les cycles Générer les cycles

Tester l’accessibilité et filtrer sinon Tester l’accessibilité

et filtrer sinon Traiter les symétries Traiter les symétries

Optimiser Optimiser

• On utilise des techniques issues de la résolution de contraintes et de la résolution SAT.

• La plupart des solveurs SAT utilisent des variantes de l'algorithme de Davis–Putnam–Logemann–Loveland (DPLL)

DPLL consiste à appliquer la propagation unitaire sur les clauses, à éliminer les clauses pures et à choisir récursivement et avec

backtrack la valeur de vérité d’une proposition.

• Un littéral est pur s’il apparaît toujours avec le même signe. Les clauses pures sont celles contenant des littéraux purs.

• L’inférence en ASP est un algorithme plus évolué qui consiste principalement à faire de la propagation unitaire sur des

« nogoods » appris en cours de résolution de conflits et à faire du backjumping à la place du backtrack classique

Un coup d’œil sur la façon dont ça marche

• affectation=vrai;

• Tant que affectation

– Propagation des conséquences déterministe du jeu de clauses;

– Si pas de conflit (clause vide détectée)

• Alors si toutes les variables sont assignées

– alors Sortir la solution; affectation=faux

– sinon Choisir une variable et lui affecter une valeur de vérité

• Sinon si le conflit implique les 2 alternatives possibles du 1^er choix

– alors Pas de solution; affectation=faux

– sinon Backtrack : Défaire toutes les affectations faites depuis le dernier choix et essayer l’autre valeur de vérité pour ce choix

La boucle de résolution avec DPLL

• affectation=vrai;

• Tant que affectation

– Propagation des conséquences déterministe du jeu de clauses;

– Si pas de conflit (clause vide détectée)

• Alors si toutes les variables sont assignées

– alors Sortir la solution; affectation=faux

– sinon Choisir une variable et lui affecter une valeur de vérité

• Sinon si le conflit implique les 2 alternatives possibles du 1^er choix

– alors Pas de solution; affectation=faux – sinon

La boucle de résolution clasp dirigée par les conflits (CDCL)

Analyser la source du conflit et ajouter une contrainte de conflit

Défaire toutes les affectations de variable jusqu’à contrainte unitaire Analyser la source du conflit et ajouter une contrainte de conflit

Défaire toutes les affectations de variable jusqu’à contrainte unitaire

• Plusieurs solveurs existent en fait, il faut essayer...

– Utilisation « tout en un » : clingo (gringo+clasp)

– Solveur incrémental : iclingo (#base+ paramètre incrémentant d’un pas de résolution à l’autre #cumulative k +)

– Solveur de contraintes sur entiers : clingcon

• Il existe un petit manuel

http://sourceforge.net/projects/potassco/files/potassco_guide/2010-10-04/

ainsi que pas mal de slides de cours plus avancés sur le site potassco

http://potassco.sourceforge.net/teaching.html

• Il existe également en support une mailing-list, un forum de discussion et un wiki et même un groupe google+ !

http://sourceforge.net/p/potassco/wiki/Home/

• https://plus.google.com/102537396696345299260/

La suite potassco : utiliser ASP en

pratique

Merci à

Torsten Schaub et Martin Gebser dont je me suis beaucoup inspiré pour cette présentation.

Answer Set Solving in Practice Martin Gebser, Roland Kaminski, Benjamin Kaufmann, and Torsten Schaub Synthesis Lectures on

Artificial Intelligence and Machine Learning, Dec. 2012, Vol. 6, No. 3 , Pages 1-238 (doi: 10.2200/S00457ED1V01Y201211AIM019)

– Langage : logique du premier ordre, clauses de Horn – Une seule structure de données : le terme

– Algorithme = Logique + Contrôle [Kowalski]

– Réécriture des requêtes par résolution SLD avec les clauses, en effectuant les points de choix dans un ordre fixé « haut-bas

gauche-droite ».

– Solution = instanciation des variables de la requête.

– Enumération des solutions par retour arrière (backtracking) sur les points de choix.

Paradigme de la programmation

logique

Connaissance nécessaire du solveur en Prolog : exemple des dominos

• domino(X,Y):- member(X,[0,1,2,3,4,5,6]), member(Y, [0,1,2,3,4,5,6]).

:- domino(A,B).

Yes. A=1, B=1; …

• domino_chain ([X,Y]) :- domino(X,Y).

domino_chain ([X,Y|L]):- domino(X,Y), domino_chain([Y|L]).

versus

• domino_chain([X,Y|L]):- domino_chain([Y|L]), domino(X,Y).

domino_chain([X,Y]):- domino(X,Y).

Enumération de l’ensemble des solutions ou boucle infinie de résolutions sans solution !

• La propagation unitaire est un mécanisme de simplification de clauses utilisant les clauses réduites à 1 seul littéral.

• Etant donné un ensembles de clauses comprenant une clause unitaire réduite au littéral p, on peut enlever de l’ensemble toutes les autres clauses qui contiennent p et enlever le littéral opposé ~p des clauses restantes.

• {p, p q, not p  r , not r  s} se réduit ainsi à {p, r , not r  s} qui se réduit lui-même en {p, r, s}.

• Un nogood est un assignement de valeurs de vérité à un ensemble d’atomes qui suffit à provoquer la violation d’une contrainte du programme.

Propagation unitaire sur nogood