Compilation et calcul de certificats pour les QCSP et les QBF

Compilation et calcul de certificats pour les QCSP et les QBF
Marc Legeay
dirigé par M. Igor Stéphan
Master 1 Informatique
Université d’Angers
7 février 2014
Résumé
Nous présentons dans cet article des implémentations en C++, ainsi que l’interfaçage
de ces implémentations avec GProlog (Diaz & Codognet, 2000). Nous formalisons égale-
ment un algorithme de lecture d’une base. Enfin, nous présentons les performances des
implémentations sur différents problèmes.
1 Introduction
Un CSP (Constraint Satisfaction Problem ou problème de satisfaction de contraintes) est
un problème où il faut trouver une affectation de valeurs pour les variables d’un ensemble
de contraintes afin qu’elles soient satisfaites. Un QCSP (Quantified Constraint Satisfaction
Problem ou problème de satisfaction de contraintes quantifiées) est un CSP dans lequel les
variables sont quantifiées universellement ou existentiellement. Un QBF (Quantifed Boolean
Formula ou formule booléenne quantifiée) est un QCSP dont le domaine des variables est
{0,1}.
Un QCSP peut être vu comme un jeu à deux joueurs, où le joueur peut décider des
mouvements des variables quantifiées existentiellement, et l’adversaire est représenté par les
variables universellement quantifiées. Le problème qui se pose alors est de trouver pour le
joueur existentiel une stratégie gagnante à tous les coups. Lorsque la stratégie a été trouvée,
le second problème qui se pose est celui du choix du prochain mouvement et de sa complexité.
Résoudre un QCSP est PSPACE-complet, donc, lorsqu’on interroge le QCSP afin de savoir
quelle valeur donner à une variable, si la stratégie que nous a donné une précédente interroga-
tion ne peut plus être suivie, il faut résoudre le QCSP une nouvelle fois pour avoir une nouvelle
stratégie gagnante correspondant aux mouvements déjà effectués. La compilation d’un QCSP
est également PSPACE, mais permet de pouvoir l’interroger avec une complexité moins im-
portante que l’interrogation d’un QCSP non-compilé qui est de complexité PSPACE-complet.
L’objectif de la compilation est de pouvoir donner le prochain mouvement en temps polyno-
mial lorsque la stratégie utilisée n’est plus possible. Un QCSP compilé donne une stratégie
gagnante à tous les coups, qui assure de résoudre le QCSP si la stratégie courante n’est plus
accessible. Dans cet article, nous avons choisis de représenter un QCSP compilé sous forme
d’une base comme dans (Stéphan, 2012).
Le problème du Boulanger : « Un boulanger souhaite acheter 4 poids de 1 à 40 kg lui
permettant de pouvoir peser d’un coup de 1 à 40 kg de farine et savoir comment utiliser ces
1

poids », peut se traduire par un QCSP. Résoudre le QCSP permet de savoir quels poids acheter,
mais pour dire de quel côté de la balance placer chacun des poids afin de peser la farine, il
faut résoudre le QCSP pour chaque poids de farine. Compiler le QCSP permet également de
savoir quels poids acheter, et permet de savoir où poser les poids dans la balance de manière
polynomiale en temps.
L’article est organisé ainsi : la section 2 définit les concepts nécessaires ; la section 3 for-
malise les fonctions utiles à la compilation et à la lecture d’une base ; la section 4 présente
l’implémentation des algorithmes ; la section 5 montre les résultats ; la section 6 conclue.
2 Préliminaires
2.1 Généralités
Le symbole ∃représente le quantificateur existentiel, le symbole ∀représente le quantifi-
cateur universel, le symbole ∧représente la conjonction.
Dans le cadre de la représentation d’un jeu à deux joueurs, il existe les SCSP (Strategic
Constraint Satisfaction Problem (Bessiere & Verger, 2006)) qui sont des QCSP dont une va-
riable quantifiée existentiellement ne peut pas prendre une valeur de son domaine si celle-ci ne
préserve pas la consistance des contraintes. Le symbole ˚ ∀représente le quantificateur universel
dans un SCSP.
Un QCSP est un n-uplet (V,ordre,quant,dom,C) dans lequel V={v1, . . . , vn}est un
ensemble fini de variables, ordre est une bijection des variables sur [1..n], quant est une fonction
de Vdans l’ensemble {q1, . . . , qn}de quantificateurs où qi∈ {∃,∀} est le quantificateur de la
variable vi∈V,dom est une fonction de Vdans l’ensemble de domaines {Dv1, . . . , Dvn}où
Dviest le domaine de la variable vi∈V, et Cest un ensemble fini de contraintes.
Un QCSP peut être noté sous la forme plus compacte : QC où Q=q1v1. . . qnvnforme le
lieur et Cest la conjonction des contraintes de C. Le QCSP (V,ordre,quant,dom,C) avec
V={c1, c2, c3, c4, f, w1, w2, w3, w4},
ordre ={(1, w1),(2, w2),(3, w3),(4, w4),(5, f ),
(6, c1),(7, c2),(8, c3),(9, c4)},
quant ={(c1,∃),(c2,∃),(c3,∃),(c4,∃),(f, ∀),
(w1,∃),(w2,∃),(w3,∃),(w4,∃)},
dom ={(c1, D3),(c2, D3),(c3, D3),(c4, D3),(f, D40),
(w1, D40),(w2, D40),(w3, D40),(w4, D40)},
D3={−1,0,1}, D40 = [1..40],
C={(f= (w1∗c1)+(w2∗c2)+(w3∗c3)+(w4∗c4))}
est noté sous la forme compacte : ∃w1∃w2∃w3∃w4∀f∃c1∃c2∃c3∃c4(f= (w1∗c1)+(w2∗c2) +
(w3∗c3)+(w4∗c4)) avec w1, w2, w3, w4, f ∈[1..40],c1, c2, c3, c4∈ {−1,0,1}.
La sémantique d’un QCSP peut être définie récursivement. Si Cest vide, alors le QCSP
admet une stratégie gagnante. Si le QCSP est de la forme ∀xQC avec x∈Dx, alors il admettra
une stratégie gagnante si, et seulement si, pour toute valeur val ∈Dx,Q(C∧(x=val)) admet
une stratégie gagnante. Si le QCSP est de la forme ∃xQC avec x∈Dx, alors il admettra une
stratégie gagnante si et seulement si, pour au moins une valeur val ∈Dx,Q(C∧(x=val))
admet une stratégie gagnante.
2

Gw1= [(1,),(3,),(9,),(27,)],
Gw2= [(1,
w1
3927
),(3,
w1
1927
),(9,
w1
1327
),(27,
w1
139
)],
Gw3= [(1,
w1
w2
9 27
3
w2
3 27
9
w2
3 9
27
),(3,
w1
w2
9 27
1
w2
1 27
9
w2
1 9
27
),(9,
w1
w2
3 27
1
w2
1 27
3
w2
1 3
27
),
(27,
w1
w2
3 9
1
w2
1 9
3
w2
1 3
9
)],
Gw4= [(1,
w1
w2
w3
27
9
w3
9
27
3
w2
w3
27
3
w3
3
27
9
w2
w3
9
3
w3
3
9
27
),(3,
w1
w2
w3
27
9
w3
9
27
1
w2
w3
27
1
w3
1
27
9
w2
w3
9
1
w3
1
9
27
),
(9,
w1
w2
w3
27
3
w3
3
27
1
w2
w3
27
1
w3
1
27
3
w2
w3
3
1
w3
1
3
27
),(27,
w1
w2
w3
9
3
w3
3
9
1
w2
w3
9
1
w3
1
9
3
w2
w3
3
1
w3
1
3
9
)]
Figure 1 – Gardes des variables w1,w2,w3et w4du problème du Boulanger.
Le symbole top_base représente ce qui est toujours vrai et le symbole bottom_base ce
qui est toujours faux, d’un point de vue algorithmique, ils représentent respectivement ce qui
admet tout pour stratégie gagnante et ce qui n’admet aucune stratégie gagnante. Une base
pour un QCSP est soit le symbole top_base, soit le symbole bottom_base, soit une paire
hQ|Giavec Q=q1v1. . . qnvn, le lieur, et G= [Ge1, . . . , Gem]une liste de gardes pour chaque
variable existentiellement quantifiée (eiétant l’indice de la i-ème variable la plus externe du
lieur quantifiée existentiellement). Une garde est une liste de paires (valeur, arbre). Un arbre
appartenant à une garde est un arbre de hauteur H, égale au nombre de variables plus externes
dans le lieur que la variable à laquelle est associé l’arbre, et dont
3

– toutes les feuilles sont étiquetées par le symbole et sont à la profondeur H,
– tout nœud interne de profondeur k,0≤k < H, est étiqueté par la variable vk+1,
– tout arc reliant un nœud de profondeur kà un de ses nœuds fils est étiqueté par un
élément de Dk+1,
– tous les arcs reliant un nœud de profondeur kà un de ses nœuds fils sont étiquetés
différemment.
La garde contient donc la liste des valeurs que peut prendre la variable quantifiée existen-
tiellement. La variable peut prendre une valeur que si la condition est respectée, la condition
étant l’arbre qui stocke les coups précédents qui amèneraient à jouer cette valeur.
La figure 1 présente les gardes des variables w1,w2,w3, et w4du problème du Boulanger.
On remarque que les arbres d’une même garde ont tous la même hauteur qui correspond à
l’ordre de la variable. Ainsi les arbres de Gw1sont de hauteur 1, ceux de Gw2de hauteur 2,
etc. . .L’interprétation de la garde Gw1nous indique que w1peut prendre la valeur 1si rien n’a
été joué avant, ou bien les valeurs 3,9, ou 27 avec la même condition. De même, l’interprétation
de Gw2nous permet de savoir que w2peut prendre les valeurs 1si w1∈ {3,9,27},3si
w1∈ {1,9,27},9si w1∈ {1,3,27}ou 27 si w1∈ {1,3,9}.
2.2 Compilation des QCSP
L’algorithme récursif de compilation d’un QCSP en une base est un algorithme de re-
cherche. L’algorithme a été formalisé dans (Stéphan, 2012) et l’est également dans l’algorithme
1. Il procède ainsi : il calcule le point fixe de la propagation des contraintes 1du QCSP en
entrée et retourne bottom_base si une contradiction est détectée ; si ce n’est pas le cas et
que le lieur est vide il retourne top_base, sinon pour chaque valeur val du domaine de la
variable xla plus externe du lieur, l’algorithme est appelé récursivement avec l’ajout de la
contrainte (x=val). L’algorithme renvoie bottom_base si l’un des appels récursifs renvoie
bottom_base et que le quantificateur est universel ou que tous appels renvoient bottom_base
et que le quantificateur est existentiel. Dans le cas où les appels récursifs n’entraînent pas un
renvoie de bottom_base, l’algorithme retourne alors une combinaison des bases renvoyées en
fonction de la valeur associée.
Les algorithmes de combinaison ont été formalisés dans (Stéphan, 2012), ils sont formalisés
également avec les algorithmes 2, 3 et 4 de cet article.
La combinaison (algorithme 4) prend en entrée une variable xet une liste de paires (va-
leur, base). Elle extrait avec l’algorithme 6 les gardes contenues dans les bases de la liste en
entrée. L’algorithme 7 décompose la liste de gardes en distribuant la valeur val associée à cette
liste à chaque garde. L’algorithme 8 construit une nouvelle garde en ajoutant aux arbres de la
garde l’arc spécifiant que la variable xprend la valeur val. La combinaison a donc pour but de
créer une nouvelle base dont les gardes des bases précédemment calculées sont rassemblée en
fonction de la valeur que prend la variable. Avant de combiner, il faut vérifier avec l’algorithme
5 si la liste de paires (valeur, base) ne contient que des top_base ou bottom_base en second élé-
ment, si le quantificateur de la variable est universel alors la combinaison retournera top_base
et s’il est existentiel, elle retournera une base ayant pour unique garde la liste de paires (val,)
pour chaque (val,top_base) présent dans la liste de paires passée en entrée, grâce à la fonction
cas_de_base de l’algorithme 2. Dans le cas où l’algorithme 5 renvoie faux, la combinaison
1. Le point fixe de la propagation de contraintes est atteint lorsqu’il y a une contradiction ou lorsque les
contraintes sont satisfaites.
4

telle que décrite ci-avant s’applique et si le quantificateur est existentiel, la garde comprenant
les paires (val,) pour chaque (val,base) présent dans la liste de paires passée en entrée avec
base 6=bottom_base, est ajoutée en tête des gardes précédemment calculées. Cette garde est
construite à l’aide de la fonction premiere de l’algorithme 2.
3 Formalisations
Nous proposons la formalisations de deux types d’algorithmes, les premiers sont utilisés
dans le cadre de la compilation d’un QCSP en une base, les seconds servent à la lecture d’une
base.
Algorithme 1 rec_comp
Entrée : Q: un lieur d’un QCSP
Entrée : C: un ensemble de contraintes d’un QCSP
Sortie : une base
si calcul_pointfixe_propagation =failure alors
retourner bottom_base
fin si
si vide(Q)alors
retourner top_base
fin si
qxD←tete(Q)
listeV alBase ←[]
d←D
tant que !vide(d)faire
val ←tete(d)
d←queue(d)
base ←rec_comp(queue(Q),C ∪ {x=val})
si base =bottom_base &q=∀alors
retourner bottom_base
fin si
listeV alBase ←[(val, base)|listeV alBase]
fin tant que
si vide(listeV alBase)alors
retourner bottom_base
fin si
si q=∃alors
retourner ⊕∃(xD, queue(Q), listeV alBase)
sinon
retourner ⊕∀(xD, queue(Q), listeV alBase)
fin si
5