Évaluer la difficulté d`une grille de sudoku à l`aide d`un modèle

Commentaires

Transcription

Évaluer la difficulté d`une grille de sudoku à l`aide d`un modèle
Actes JFPC 2006
Évaluer la difficulté d’une grille de sudoku à
l’aide d’un modèle contraintes
François Laburthe1
Guillaume Rochart1
Narendra Jussien2
e-lab – Bouygues SA – 1 av. Eugène Freyssinet
F-78061 St Quentin en Yvelines, France
École des Mines de Nantes – LINA CNRS 2729 – 4 rue Alfred Kastler – BP 20722
F-44307 Nantes Cedex 3, France
{flaburthe, grochart}@bouygues.com
[email protected]
1
2
Résumé
Le sudoku est un jeu de logique qui est devenu en
quelques mois un phénomène de société en France. Il
envahit les métros, les trains, les bus, les salles de cours
et même le journal Le Monde. Grâce à ce jeu, le grand
public est devenu le M. Jourdain de la Programmation
Par Contraintes. En effet, l’intérêt de ce jeu pour montrer très rapidement et très simplement les principes premiers de la programmation par contraintes n’est plus à
démontrer. De plus, la technologie contraintes est très
performante pour modéliser à l’aide de quelques contraintes globales ce problème et le résoudre quasiment
simplement par propagation. Par contre, la mesure de
la difficulté d’une grille – qui laisse à désirer pour de
nombreuses instances publiées actuellement – n’a pas
encore été capturée de manière satisfaisante par un modèle contraintes. Une raison est qu’une telle mesure est
totalement subjective car elle dépend de la façon dont un
joueur aborde son instance. Dans cet article, nous montrons qu’il est possible de définir des modèles contraintes
permettant de retrouver des combinaisons de règles utilisées par les joueurs. Ces modèles ouvrent la porte à
une évaluation de la difficulté d’une instance par une
approche purement contraintes et même de fournir des
systèmes d’aide eux-aussi basés sur un telle approche.
1
Introduction
Est-il encore besoin de présenter le sudoku ? Ce jeu
est un jeu de logique : sa grille carrée de 81 cases
est divisée en 9 blocs (3 × 3) de 9 cases chacun (voir
la figure 1). Des chiffres sont inscrits dans certaines
cases. Il faut remplir les autres en utilisant les chiffres
de 1 à 9, mais aucun chiffre ne doit apparaître deux
fois dans la même ligne, ni dans la même colonne, ni
dans le même bloc. Les instances sont sélectionnées
de sorte qu’il n’existe qu’une unique solution. Il a été
montré qu’il existait 6 670 903 752 021 072 936 960
grilles (complètes) différentes [2]. Si on tient compte
des symétries intrinsèques de la grille (permutation
des valeurs, des colonnes, des lignes. . . ), ce nombre
descend à 5 472 730 538 [5].
Ce jeu est un cas d’école pour la programmation
par contraintes pour deux raisons : la première est
que la discipline paraît être la technique idoine pour
résoudre automatiquement les instances du sudoku (en
effet, le modèle intrinsèque du problème est basé tout
naturellement sur la contrainte all-different [3]);
la deuxième, et peut-être finalement la plus importante, tient au fait que les techniques mises en œuvre par les joueurs humains pour résoudre leurs grilles
fait appel à des principes de base de la programmation
par contraintes : la réduction de domaine (élimination
de candidats dans le vocabulaire sudokumaniaque), le
raisonnement local (dans chaque zone – ligne, colonne
ou bloc) et la propagation (partage de l’information
par les domaines – les listes de candidats).
Une problématique liée au sudoku est la mesure de
la difficulté des grilles (très souvent précisée dans les
instances publiées dans la presse). La difficulté d’une
grille (de très facile à expert) est un concept éminemment subjectif puisqu’il est censé rendre compte de
la difficulté pour un joueur à remplir correctement sa
grille. Contrairement à quelques idées reçues, cette difficulté ne dépend pas du nombre de cases pré-remplies
dans l’instance. Une manière de plus en plus répandue de mesurer cette difficulté consiste à déterminer
le niveau minimal de complexité des règles à appli-
5 8
2
4 2
8
6
7
9
4
7 3 8 6
4
8
3 6
5
9
5
9
7 2
Figure 1: Une instance difficile de sudoku
quer pour résoudre l’instance. En effet, des collections de règles à appliquer (aux noms aussi évocateurs que X-Wing ou Swordfish) fleurissent sur internet [1]. Celles-ci sont très souvent présentées dans un
ordre de difficulté (de compréhension, d’identification
et d’application) croissant.
Mais, une telle manière de mesurer la difficulté laisse
de côté la programmation par contraintes. Cela est
assez dommageable. Nous chercherons donc dans cet
article à proposer différents modèles du problème permettant de mesurer la difficulté dans un cadre contraintes.
Figure 2:
Single Candidate : les ligne et colonne rouges permettent de supprimer presque toutes les valeurs du domaine de
l’intersection (toutes sauf la valeur 2) ; on peut donc en déduire
que l’intersection aura la valeur 2. D’autres raisonnements du
même type peuvent être utilisés pour les cases en jaunes.
Par ailleurs, pour tout ensemble de valeurs V , et
tout zone Z, on note ou(V, Z), le sous-ensemble des
cases de la zone pouvant accueillir une des valeurs de
V . Formellement :
ou(V, Z) = {x[i, j] ∈ Z|quoi({x[i, j]}) ∩ V 6= ∅}
2
Résolution à base de règles
Nous proposons une description semi-formelle des règles de résolution, telles qu’elles sont présentées sur
[1]. Dans la suite de cet article, on notera C, L et B
les colonnes, lignes et blocs de la matrice ; on notera
(i, j, b) leurs indices respectifs. Chaque case x[i, j] de la
grille appartient à une ligne Li ∈ L (i-ème ligne1 ), une
colonne Cj ∈ C (j-ème colonne2 ), et un carré Bb ∈ B
(b-ème bloc3 ). On note bi,j l’indice du bloc contenant
la case (i, j) et ai,j l’indice de cette case (i, j) au sein
de ce bloc (c’est-à-dire que Bbi,j [ai,j ] = x[i, j]). Dans
l’expression des règles, on écrira x[i, j] := v pour remplir effectivement la case dite avec la valeur v ; et on
écrira x[i, j] 6= v quand on est sûr que la valeur v est
interdite pour la case.
Tout ensemble de cases de la grille est appelé une
zone. Pour toute zone Z, on note quoi(Z) l’ensemble
des valeurs qui peuvent rentrer dans une des cases de
la zone ; formellement :
quoi(Z) = {v ∈ 1..9|∃x[i0 , j0 ] ∈ Z tel que:
∀j1 6= j0 , x[i0 , j1 ] 6= v, ∀i1 6= i0 , x[i1 , j0 ] 6= v,
∀(i1 , j1 ) 6= (i0 , j0 ) tel que
bi1 ,j1 = bi0 ,j0 , x[i1 , j1 ] 6= v}
Dans l’ensemble des figures4 , on représente à
l’intérieur de chaque case, en grande police la valeur
quand la case est remplie, et dans le cas contraire, en
petite police, en bleu, les valeurs possibles, en gris,
les valeurs impossibles par examen immédiat de la
ligne, la colonne et le bloc. Enfin, on représente en
rouge les valeurs qu’un examen plus approfondi permet d’éliminer.
L’ensemble des règles présentées par la suite
s’appliquent aussi bien sur une ligne, une colonne ou
un bloc (lorsqu’elles ne portent que sur une zone) ;
ou bien des blocs vers les lignes, des blocs vers les
colonnes, des lignes vers les blocs, ou encore des
colonnes vers les blocs (lorsqu’elles portent sur une
interaction de zones).
2.1
Single Candidate
Cette règle remplit une case (i0 , j0 ) lorsque l’examen
de sa ligne, de sa colonne et de son bloc interdisent
toutes les valeurs sauf une, v0 . C’est-à-dire pour
chacune des valeurs v 6= v0 , il existe une des zones
Ci0 , Lj0 ou B(i0 ,j0 ) ayant une case contenant déjà la
valeur v (voir la figure 2).
1 Du
haut vers le bas.
la gauche vers la droite.
3 De gauche à droite puis de haut en base.
2 De
4 Les illustrations proviennent de l’applet disponible sur
www.emn.fr/jussien/sudoku/jouer.html
Figure 3:
Single Position : la ligne verte représente une zone
d’étude; les zones rouges représentent des placements interdits ;
ne restant plus qu’un emplacement pour la valeur 7, on peut
instancier la case à cette valeur.
singleCandidate(x[i, j])
si ∃v, quoi({x[i, j]}) = {v}
2.2
alors x[i, j] := v
Single Position
Cette règle choisit une zone (disons une ligne Li ), et
une valeur v qui n’est pas encore placée dans cette
ligne et cherche si une seule place est disponible (voir
figure 3).
singlePosition(Li , v)
si ∃j, ou({v}, Li ) = {x[i, j]}
alors x[i, j] := v
2.3
Candidate Lines
Cette règle examine un bloc Bb et une valeur v n’y
ayant pas encore été placée. Lorsque toutes les cases
pouvant possiblement accueillir cette valeur sont
situées sur une même ligne Li alors, on peut interdire
de toutes les autres cases de la ligne (hors du bloc)
cette valeur v.
candidateLine(Bb , v)
si ∃i tel que ou({v}, Bb ) ⊆ (Li ∩ Bb )
alors ∀x[i, j] ∈ Li \ Bb , x[i, j] 6= v
L’exemple de la figure 4 montre par exemple que la
valeur 4 ne peut pas appartenir à la deuxième colonne
des deux blocs supérieurs de droite (blocs 3 et 6).
Figure 4:
Candidate Line : Les cases en vert représentent les
seules cases pouvant avoir la valeur 4 dans le bloc correspondant (bloc 9); appartenant toutes à la même colonne, on peut
en déduire, que cette valeur n’apparaîtra pas dans cette même
colonne dans les autres blocs.
2.4
Double pairs
Cette règle examine deux blocs contigus Bb1 et Bb2 et
repère une valeur v , n’ayant dans chacun de ces blocs
que deux places possibles : x[i1 , j1 ], x[i2 , j2 ] dans Bb1 ,
et x[i3 , j3 ], x[i4 , j4 ] dans Bb2 . Si, par ailleurs, ces cases
sont situées dans une même colonne (par exemple si
i1 = i3 ), alors on peut interdire la valeur v des autres
cases de la colonne Ci1 (celles qui ne sont ni dans Bb1
ni dans Bb2 ). La figure 5 illustre cette règle.
doublePair(Bb1 , Bb2 , v)
soit b3 , j1 , j2 , j3 tels que
Bb1 ∪ Bb2 ∪ Bb3 = Cj1 ∪ Cj2 ∪ Cj3
si ∃i1 , i2 tels que
ou({v}, Bb1 ) = {x[i1 , j1 ], x[i1 , j2 ]}
ou({v}, Bb2 ) = {x[i2 , j1 ], x[i2 , j2 ]}
alors, ∀x[i, j] ∈ Bb3 \ Cj3 , x[i, j] 6= v
2.5
Multiple lines
Cette règle, généralisant la précédente, examine deux
blocs Bb1 et Bb2 d’un même tiers vertical, et cherche
une valeur v qui n’ait pas encore été placée dans ces
deux blocs, mais dont les positions possibles, tant à
l’intérieur de Bb1 que de Bb2 sont réparties sur deux
des trois colonnes. Alors on peut affirmer qu’au sein
du troisième bloc Bb3 de ce tiers vertical, la valeur v0
sera nécessairement placée sur la troisième colonne.
La figure 6 illustre cette règle.
multipleLines(Bb1 , Bb2 , v)
soit b3 , j1 , j2 , j3 tels que
Figure 5: Double Pairs : Tout d’abord, en utilisant la règle Candidate Line, on remarque que les deux valeurs 2 en
rouge dans le bloc central du haut (bloc 2) sont impossibles.
Il ne reste donc que deux positions possibles pour la valeur 2
dans ce bloc et deux positions dans le bloc en-dessous (bloc 5) ;
s’agissant des même colonnes dans les deux cas, on peut en déduire que les deux blocs devront se partager ces deux colonnes
pour cette valeur et qu’elle ne peut donc apparaître dans ces
mêmes colonnes dans le bloc central du bas (bloc 8). C’est ce
qui est représenté par les zones rouges dans ce bloc qui permettent par exemple d’instancier une case à 7.
Bb1 ∪ Bb2 ∪ Bb3 = Cj1 ∪ Cj2 ∪ Cj3
si ou({v}, Bb1 ) ⊆ Cj1 ∪ Cj2
et si ou({v}, Bb2 ) ⊆ Cj1 ∪ Cj2
alors ∀x[i, j] ∈ Bb3 \Cj3 , x[i, j] 6= v
2.6
Naked pairs
Cette règle examine une ligne et cherche s’il existe
deux cases pour lesquelles seulement deux valeurs v1
et v2 sont possibles. Si c’est le cas, v1 , comme v2
peuvent être interdites pour l’ensemble des autres
cases de la ligne (hormis les deux repérées). La
figure 7 illustre cette règle.
nakedPair(Li )
si ∃j1 , j2 , v1 , v2 tels que
quoi(Li ∩ (Cj1 ∪ Cj2 )) = {v1 , v2 }
alors ∀j, j 6= j1 , j 6= j2 , x[i, j] 6∈ {v1 , v2 }
Cette règle se généralise aisément à k valeurs,
par exemple, pour trois valeurs, on cherchera trois
cases, pour lesquelles il n’existe aucune autre valeur
possible en dehors de trois valeurs v1 , v2 et v3 . Ce qui
s’exprime par la règle Naked Tuple :
Figure 6: Multiple Lines : Considérons les blocs de gauche;
celui du haut (bloc 1) ne peut avoir la valeur 5 que dans les deux
première colonnes ; de même pour le bloc du bas (bloc 7) ; ce
qui signifie que le bloc du milieu (bloc 4) ne doit avoir de 5 que
dans la troisième colonne ce qui supprime les 5 de la première
colonne (en rouge).
alors ∀j, j 6∈ {j1 , ..., jk }, x[i, j] 6∈ {v1 , ..., vk }
2.7
Hidden pairs
Cette règle examine une ligne Li et cherche s’il existe
deux valeurs v1 et v2 pour lesquelles seulement deux
cases sont possibles. Si c’est le cas, toutes les autres
valeurs sont interdites pour ces deux cases. La figure 8
illustre cette règle.
hiddenPair(Li )
si ∃v1 , v2 , j1 , j2 tels que
ou({v1 , v2 }, Li ) = Li ∩ (Cj1 ∪ Cj2 )
alors ∀j, j 6= j1 , j 6= j2 , x[i, j] 6∈ {v1 , v2 }
La généralisation à plus de deux valeurs donne :
hiddenTuple(Li , k)
si ∃v1 , ..., vk , j1 , ..., jk tels que
ou({v1 , ..., vk }, Li ) = Li ∩ (Cj1 ∪ ... ∪ cjk )
alors ∀j, j 6∈ {j1 , ..., jk }, x[i, j] 6∈ {v1 , ..., vk }
Lemme : Soit Li une ligne contenant encore p cases
non remplies, les règles nakedTuple(Li ,n) et hiddenTuple(Li ,p − n) effectuent les mêmes inférences.
Preuve : ces deux règles effectuent une partition des
cases de la ligne :
• un ensemble E de 9 − p cases remplies ;
nakedTuple(Li , k)
si ∃j1 , ..., jk , v1 , ..., vk tels que
quoi(Li ∩ (Cj1 ∪ ... ∪ Cjk )) = {v1 , ..., vk }
• un ensemble F de n cases qui globalement ne peuvent être remplies que par n valeurs ;
Figure 7:
Naked Pairs : Deux cases de la ligne du bas ne
peuvent être instanciées qu’à 1 et 5 ; ceci signifie que ces valeurs
n’apparaîtront que dans ces deux cases ; elles peuvent être donc
retirées du reste de la ligne, permettant ainsi d’instancier une
case à 6.
• et son complémentaire, un ensemble G de p − n
cases qui globalement contiennent p−n valeurs ne
pouvant pas être mises ailleurs que dans G.
Les règles Naked sur F et Hidden sur G interdisent
toutes aux cases de G de recevoir une des valeurs considérées par les cases de F.
Par exemple, si on considère la ligne 9 dans la figure 7, le raisonnement HiddenTuple sur les valeurs 1, 3
et 9 (qui n’ont que trois colonnes disponibles : 1, 4 et
8) aboutit aux mêmes conclusions que le raisonnement
NakedPair sur les colonnes 2 et 7 (qui n’ont que deux
valeurs possibles : 1 et 5). De même, sur la troisième
ligne de la figure 8, HiddenPair sur les valeurs 1 et 3
aboutit aux mêmes conclusions que NakedTuple sur
les colonnes 3, 4 et 8.
2.8
X-Wing et Swordfish
Ces deux règles sont similaires ; elles consistent à trouver une valeur v telle que, sur plusieurs lignes, seules
deux cases peuvent avoir cette valeur et que ces cases
ne contiennent à leur tour que deux valeurs. De plus,
il est nécessaire que l’on puisse trouver un circuit passant par ces cases en suivant alternativement une ligne
et une colonne5 . Dans le cas simple où on ne considère
que deux lignes, il s’agit d’un carré comme le montre
la figure 9. Dans le cas où l’on considère trois lignes,
on obtiendrait, par exemple un L.
Dès lors, on peut remarquer que dans de telles
configurations, on peut en déduire que la valeur v
apparaîtra dans chacune des colonnes de ces cases.
5 Le raisonnement est valide si l’on passe aussi par un bloc
mais le voir à la main est nettement plus ardu.
Figure 8:
Hidden Pairs : Dans la troisième ligne, seule deux
cases peuvent être instanciées à 1 et 3; cela signifie que ces deux
cases ne peuvent être à instanciées qu’à ces deux seules valeurs;
on peut donc retirer les valeurs 4 et 2 des domaines respectifs
de ces deux cases.
On peut donc en déduire que la valeur v peut être
retirée des autres cases de ces colonnes. La figure 9
illustre cette règle.
X-Wing(v)
si ∃i1 , i2 , j1 , j2 tels que
ou({v}, Li1 ) = Li1 ∩ (Cj1 ∪ Cj2 )
et ou({v}, Li2 ) = Li2 ∩ (Cj1 ∪ Cj2 )
alors ∀i, i 6= i1 , i 6= i2 , x[i, j1 ] 6= v, x[i, j2 ] 6= v
Swordfish(v, k)
si ∃i1 , ..., ik , j1 , ..., jk tels que
ou({v}, Li1 ) = Li1 ∩ (Cj1 ∪ Cj2 )
ou({v}, Li2 ) = Li2 ∩ (Cj2 ∪ Cj3 )
...
ou({v}, Lik ) = Lik ∩ (Cjk ∪ Cj1 )
alors ∀i, i 6∈ {i1 , ..., ik } et ∀j ∈ {j1 , ..., jk }
x[i, j] 6= v
2.9
Forcing chains
La dernière règle que nous évoquerons ici est la règle
Forcing chains, qui consiste à essayer une valeur dans
une case de sorte à vérifier si ce choix amène à une
contradiction ou non (si c’est le cas, la valeur n’est
pas correcte, sinon on ne peut rien déduire). Il s’agit
de la technique utilisée par exemple dans la singletoncohérence. S’agissant, dans une certaine mesure, d’un
début de recherche, nous n’étudierons donc pas les règles qui suivent sur [1] car elles ne semblent pas applicables comme techniques de filtrage.
Dans la suite, nous présentons différents niveaux
de raisonnement pour le sudoku et basés sur la programmation par contraintes. Chaque niveau de difficulté d’un problème sera défini comme l’ensemble des
grilles de sudoku qui sont entièrement résolues par calcul d’arc cohérence pour un des modèles donnés.
3.1
Raisonnements locaux
Les premières règles présentées en section 2 sont très
simples. Il est ainsi possible de proposer des modèles
CSP uniquement basés sur des raisonnements locaux
pour les modéliser.
3.1.1
Figure 9:
X-Wing : On considère ici les occurrences de la
valeur 6 dans la quatrième et dans la dernière ligne; ces domaines
formant deux paires identiques, on peut remarquer que si l’on
choisit la valeur 6 pour un des coins du carré ainsi formé, le
coin opposé sera forcément instancié à 6 aussi; on peut donc en
déduire que la valeur 6 peut être retirée des autres cases des
colonnes.
3
Résolution par des contraintes
Ces règles ont été exprimées dans un langage compréhensible par n’importe qui (enfin presque !) mais
ça et là interviennent différent concepts fortement liés
à la programmation par contraintes. Nous proposons
donc maintenant une série de modèles sous forme de
CSP permettant de résoudre une grille de sudoku.
Un CSP M = (V, D, C) est défini par un ensemble
de variables V , leurs domaines D et des contraintes
C. Une affectation de valeurs aux variables σ est
une application associant à chaque variable vi de V
une valeur dans Di . Une affectation est une solution si pour toute contrainte c ∈ C, la substitution
des variables par leurs valeurs se réduit en une contrainte c[v ← σ(v)] vraie. L’ensemble des solutions
d’un CSP M est noté sol(M ). La projection d’une
affectation σ sur un sous-ensemble de variables W est
notée W ↓ σ. Étant donnés deux modèles Mi et Mj ,
on notera Mi 3 Mj lorsque le modèle Mi est un renforcement de Mj , c’est-à-dire lorsque :
var(Mi ) ⊂ var(Mj )
sol(Mj ) = sol(Mi ) ↓ var(Mj )
Par ailleurs, soit M un CSP, on fera référence aux
niveaux de propagation suivants: AC pour l’arc cohérence, k-AC pour la k-cohérence (cohérence sur des
chemins d’au plus k contraintes), et SAC pour la singleton arc-cohérence. Pour un modèle M , on notera
ainsi AC(M ) l’état des domaines de M après calcul
du point fixe associé à l’AC.
Modèle PRIMAL
Le premier modèle, probablement le plus simple, introduit une variable par case et des contraintes de diségalités binaires entre variables associées à des cases
d’une même zone.
Variables On associe à chaque case une variable :
∀i, j, x[i, j] ∈ {1, . . . , 9}.
Contraintes On ajoute les contraintes suivantes au
problème :
sur les lignes :
∀i, ∀j1 6= j2 , x[i, j1 ] 6= x[i, j2 ]
sur les colonnes :
∀i, ∀i1 6= i2 , x[i1 , j] 6= x[i2 , j]
sur les blocs :
∀b, ∀(i1 , j1 ), (i2 , j2 ) ∈ Bb , x[i1 , j1 ] 6= x[i2 , j2 ]
Lien avec les règles Le calcul de l’arc-cohérence sur
ce modèle, que l’on notera AC(PRIMAL), implémente
Single Candidate. En effet, on peut voir, que les figures
proposées en section 2 notent sur chaque case de la
grille son domaine de valeurs et que les inférences de
Single Candidate correspondent à la propagation des
contraintes binaires de différence.
3.1.2
Modèle DUAL
Le second modèle que nous proposons prend un point
de vue dual cherchant à répartir des valeurs dans des
blocs plutôt que d’associer des valeurs à des cases. On
associe à chaque valeur sa place au sein d’un bloc ;
par exemple idxL(j, c) représente au sein de la j-ème
ligne, l’indice de la colonne où l’on trouvera la valeur
v.
Variables On associe à chaque zone (ligne, colonne
ou bloc), des variables indiquant l’indice correspondant à la case contenant chacune des valeurs possibles
(1 à 9) :
∀i, j, x[i, j] ∈ {1, . . . , 9}
∀Li ∈ L, idxL(i, c) ∈ {1, . . . , 9}
∀Cj ∈ C, idxC(j, c) ∈ {1, . . . , 9}
∀Bb ∈ L, idxB(b, c) ∈ {1, . . . , 9}
Contraintes On ajoute tout d’abord des contraintes
de liaison entre les deux modèles :
- une valeur v se trouvant à l’indice j dans une colonne
Ci remplit la case x[i, j];
∀i, j, v, idxC(i, v) = j ⇔ x[i, j] = v
- similairement, une valeur v se trouvant à l’indice i
dans une ligne Lj remplit la case x[i, j];
∀i, j, v, idxL(j, v) = i ⇔ x[i, j] = v
- enfin, une valeur v se trouvant à l’indice ai,j dans un
bloc Bbi,j remplit la case x[i, j];
∀i, j, v, idxB(bi,j , v) = ai,j ⇔ x[i, j] = v
Puis les contraintes propres à ce modèle, indiquant
que deux valeurs différentes v1 et v2 se trouvent nécessairement à des indices différents au sein
- d’une colonne Ci ;
∀Cj ∈ C, idxC(j, v1 ) 6= idxC(j, v2 ) :
- d’une ligne Lj ;
∀Li ∈ L, idxL(i, v1 ) 6= idxL(i, v2 ) :
- d’un bloc Bb .
∀Bb ∈ B, idxB(b, v1 ) 6= idxB(b, v2 ) :
Lien avec les règles Le calcul de l’arc-cohérence sur
ce modèle, que l’on notera AC(DUAL) calcule le même
résultat (les mêmes domaines) que l’application de la
règle Single Position. En effet, puisque l’on associe
à chaque ligne, la position de chaque valeur au sein
de cette ligne, quand une valeur v n’a qu’une position possible dans cette ligne Lj , la variable idxL(j, v)
sera instanciée, et par propagation des contraintes de
liaison, la variable x[i, j] sera instanciée aussi.
L’union des deux modèles, PRIMAL ∪ DUAL,
combine les raisonnements suivant les deux vues.
L’arc-cohérence, AC(PRIMAL ∪ DUAL), calcule le
même résultat que l’application des deux règles
SingleP osition et SingleCandidate.
Les instances de sudoku pour lesquelles
AC(PRIMAL ∪ DUAL) suffit à instancier la
grille (rappelons qu’une instance de sudoku comporte
toujours une et une seule solution) sont appelées
faciles.
3.1.3
Modèle ABSTRACT
Ce modèle ajoute de nouvelles variables qui modélisent
pour une ligne (resp. une colonne, ou un bloc) et
une valeur, non plus l’indice de la case dans laquelle
tombe la valeur (9 possibles), mais simplement le bloc
(respectivement colonne ou ligne) dans lequel tombe
cette case (3 possibles). En quelques sortes il s’agit
d’une expression du modèle de départ, avec des domaines hiérarchiques, introduisant un niveau abstrait
de valeurs (les séquences de trois cases contigues et
d’un même bloc).
Variables bidxL(i, v) ∈ {b | Bb ∩ Li 6= ∅}
bidxC(j, v) ∈ {b | Bb ∩ Cj 6= ∅}
lidxB(b, v) ∈ {i | Bb ∩ Li 6= ∅}
cidxB(b, v) ∈ {j | Bb ∩ Cj 6= ∅}
Contraintes On pose deux familles de contraintes :
des contraintes de liaison entre les variables du modèle
DUAL et celles de ABSTRACT :
idxL(i, v) = j ⇒ bidxL(i, v) = bi,j ;
idxC(j, v) = i ⇒ bidxC(j, v) = bi,j ;
idxB(bi,j , v) = ai,j ⇒ lidxB(bi,j , v) = i;
idxB(bi,j , v) = ai,j ⇒ cidxB(bi,j , v) = j;
et les contraintes propres du modèle qui sont des contraintes de différence entre ces nouvelles variables :
pour i1 , i2 deux lignes du même tiers horizontal,
bidxL(i1 , v) 6= bidxL(i2 , v);
pour j1 , j2 deux colonnes du même tiers vertical,
bidxC(j1 , v) 6= bidxC(j2 , v);
pour b1 , b2 deux blocs du même tiers horizontal,
lidxB(b1 , v) 6= lidxB(b2 , v);
pour b1 , b2 deux blocs du même tiers vertical,
cidxB(b1 , v) 6= cidxB(b2 , v);
Lien avec les règles L’arc-cohérence sur ce modèle AC(PRIMAL ∪ DUAL ∪ ABSTRACT) calcule le même résultat que l’application des règles
SingleP osition, SingleCandidate et CandidateLine.
Par exemple, dans la figure 4, la propagation de la contrainte de liaison sur le bloc B9 (en bas à droite) et la
valeur 4 amène à instancier la variable cidxB(9, 4) à 8,
indiquant que la valeur 4 dans ce bloc est nécessairement située sur la colonne du milieu. La propagation
des contraintes de différence amène cidxB(3, 4) 6= 8,
c’est à dire qu’à l’intérieur du bloc en haut à droite, le
4 ne pourra pas être placé sur cette colonne du milieu.
Enfin, la propagation des contraintes de liaison amène
idxB(3, 4) 6= 8, et x[3, 8] 6= 4 pour interdire le 4 dans
la case en bas au milieu du bloc en haut à droite.
3.2
Modèles avec all-different
Nous montrons dans cette section comment sur les 3
modèles présentés précédemment, le remplacement des
contraintes de différences par des contraintes globales
de différence (all-different) permet d’effectuer plus
d’inférences sur les grilles de sudoku, et de définir ainsi
des niveaux de difficulté supérieurs
cas représenté figure 7, on a x[9, 2] ∈ {1, 5}, x[9, 7] ∈
{1, 5}, x[9, 8] ∈ {1, 6}. La propagation globale des
Ce modèle est construit à partir du modèle ABdiségalités entre x[9, 2], x[9, 7] et x[9, 8] permet imméSTRACT, en ajoutant des contraintes globales de
diatement d’instancier x[9, 8] = 6.
différence entre les nouvelles variables de ce modèle :
On peut aisément généraliser et remarquer que
- pour Cj1 , Cj2 , Cj3 trois colonnes du même tiers
AC(4-PRIMAL) calcule les inférences de la règle
vertical,
Naked Triple et que AC(k-PRIMAL) calcule les inall-different(bidxC(j1 , v), bidxC(j2 , v), bidxC(j3 , v))
férences de la règle N akedT uple(k − 1).
- pour Li1 , Li2 , Li3 trois lignes du même tiers horizonPar ailleurs, en se référant au lemme liant les raisontal,
nements entre Naked et Hidden, on remarque aussi
all-different(bidxL(i1 , v), bidxL(i2 , v), bidxL(i3 , v))
que k-AC(PRIMAL) calcule les inférences de la règle
- pour Bb1 , Bb2 , Bb3 trois blocs du même tiers horiHiddenT uple(9 − k).
zontal,
all-different(lidxB(b1 , v), lidxB(b2 , v), lidxB(b3 , v))
3.2.3 k-DUAL
- pour Bb1 , Bb2 , Bb3 trois blocs du même tiers vertical,
all-different(cidxB(b1 , v), cidxB(b2 , v), cidxB(b3 , v)) Nous proposons maintenant une série de modèles, pour
k = 3, ..., k = 9, basés sur le modèle DUAL, et
Par exemple, sur le premier tiers vertical (les blocs
lui ajoutant les contraintes de différence globale pour
1, 4, 7), on propage globalement les trois inégalités
toute clique de différences binaires de k variables. Ici
entre variables cidxB(1, v), cidxB(4, v) et cidxB(7, v),
encore, ces modèles sont évidemment emboîtés au sens
ce pour toute valeur v.
où : 9-DUAL 3 . . . 3 3-DUAL 3 DUAL
3.2.1
3-ABSTRACT
Lien avec les règles L’arc-cohérence sur ce modèle 3-ABSTRACT calcule le résultat de l’application
des règles DoubleP air et M ultipleLines. Prenons à
titre illustratif l’exemple de la figure 5 pour la règle
DoubleP air. Dans le tiers vertical du milieu (blocs 2,
5, 8), on examine les places possibles de la valeur 2.
Dans le bloc 2, la valeur 2 peut aller dans les cases
x[1, 4] et x[1, 6], soit idxB(2, 2) ∈ {1, 3}, et donc, en
termes de colonnes cidxB(2, 2) ∈ {1, 3}. Dans le bloc
5, la valeur 2 peut aller dans les cases x[5, 4] et x[5, 6],
soit idxB(5, 2) ∈ {4, 6}, et donc, en termes de colonnes
cidxB(5, 2) ∈ {1, 3}. La propagation globale des différences entre cidxB(2, 2), cidxB(5, 2) et cidxB(8, 2)
amène à déduire cidxB(8, 2) = 2
La règle M ultipleLines est basée sur le
même principe,
à savoir qu’une contrainte
all-different(x, y, z) permet de réduire le domaine
de z à {3} lorsque domain(x) = domain(y) = {1, 2}.
3.2.2
Lien avec les règles Montrons que AC(3-DUAL)
calcule les inférences de la règle X-Wing. Dans le
cas représenté figure 9, on a idxL(4, 6) ∈ {3, 9} et
idxL(9, 6) ∈ {3, 9} (le 6 dans les lignes 4 et 9 ne
peut être placé qu’à l’intersection des colonnes 3 ou
9). Prenons une autre ligne, par exemple la ligne
1, où le 6 peut être placé en colonne 2, 3 ou 9 :
idxL(1, 6) ∈ {2, 3, 9}. La propagation globale des diségalités entre idxL(1, 6), idxL(4, 6) et idxL(9, 6) permet immédiatement d’inférer idxL(1, 6) 6∈ {3, 9}.
On peut enfin montrer que AC(4-DUAL) calcule
les inférences de la règle Swordf ish. La règle identifie trois lignes Lj1 , Lj2 et Lj3 et une valeur v
telles que idxL(j1 , v) ∈ {a, b}, idxL(j2 , v) ∈ {b, c},
idxL(j3 , v) ∈ {a, c} et infère que pour toute autre ligne
Lj4 , idxL(j4 , v) 6∈ {a, b, c}. Remarquons qu’il ne s’agit
que d’un cas particulier de propagation de la clique de
diségalités entre les variables idxL(j1 , v), idxL(j2 , v),
idxL(j3 , v) et idxL(j4 , v).
k-PRIMAL
Nous proposons ici une série de modèles, pour k =
3, ..., k = 9, basés sur le modèle PRIMAL, et lui
ajoutant les contraintes globales de différence pour
toute clique de différences binaires de k variables. Ces
modèles sont évidemment emboîtés, au sens où : 9PRIMAL 3 . . . 3 3-PRIMAL 3 PRIMAL et pour
k = 9, on obtient la méthode capable des inférences
les plus performantes, et qui propage globalement les
inférences sur chaque zone (ligne, colonne ou bloc).
Lien avec les règles Montrons que AC(3-PRIMAL)
calcule les inférences de la règle N akedP air. Dans le
3.2.4
Hiérarchie de modèles
Nous avons proposé différents modèles de programmation par contraintes pour le sudoku. Ces modèles sont
tous sémantiquement équivalents au sens où ils admettent les mêmes solutions (pour les variables qui leurs
sont à tous communces, les x[i, j]). Néanmoins, ces
modèles peuvent être classés au sens où le calcul d’AC
infère plus ou moins d’information sur les domaines.
Ces modèles s’organisent dans la hiérarchie suivante :
PRIMAL ∪ DUAL ∪ ABSTRACT 3 PRIMAL ∪
DUAL 3 PRIMAL
9-PRIMAL 3 . . . 3 3-PRIMAL 3 PRIMAL
niveau
très facile
facile
moyen
difficile
très difficile
expert
règle minimale
SinglePosition
SingleCandidate
CandidateLines ou DoublePairs
ou MultipleLines
NakedPairs ou HiddenPairs ou
NakedTriples ou HiddenTriples
X-Wing ou SwordFish
autres règles
Table 1: Niveaux de difficulté en fonction des règles à
appliquer.
9-DUAL 3 . . . 3 3-DUAL 3 DUAL
9-PRIMAL ≡ 9-DUAL
9-PRIMAL ∪ 3-ABSTRACT 3 9-PRIMAL ∪ ABSTRACT 3 9-PRIMAL
3.3
Branchements
Tout comme en programmation par contraintes où le
filtrage n’est pas toujours suffisant pour trouver une
solution, les règles de déductions pures ne sont pas toujours suffisantes non plus pour résoudre complètement
une instance de sudoku. Pour contourner ces limites,
plusieurs règles proposent des techniques permettant
plus ou moins explicitement de faire de la recherche.
Par exemple, pour calculer les inférences de la règle Forcing chains, il suffit d’utiliser une singletoncohérence. En effet, cette technique consiste à essayer
une valeur d’un domaine pour détecter une contradiction et dans ce cas en déduire que cette valeur
est inconsistante. On peut donc en déduire que
SAC(PRIMAL) permet d’implémenter la règle Forcing chains.
4
niveau
très facile
facile
moyen
difficile
très difficle
modèle contraintes
AC(PRIMAL)
AC(PRIMAL ∪ DUAL)
AC(PRIMAL ∪ DUAL ∪ 3-ABSTRACT)
AC(4-PRIMAL ∪ DUAL ∪ 3-ABSTRACT)
AC(4-PRIMAL ∪ 4-DUAL ∪ 3-ABSTRACT)
Table 2: Niveaux de difficulté et modèles contraintes.
Nous proposons ainsi un lien entre niveaux de difficulté et modèles contraintes. Les niveaux présentés
sont bien différents. Pour s’en convaincre, on peut
considérer le théorème suivant :
Théorème : Le modèle (PRIMAL ∪ DUAL) est un
renforcement strict du modèle PRIMAL : (PRIMAL
∪ DUAL) 3 PRIMAL
Preuve : L’instance suivante est complètement résolue par AC(PRIMAL ∪ DUAL) et non par
AC(PRIMAL).
9
8 4
7
4
3
6 8
9 7
7 5 6
2
7 5 4
3 7
5
6 8 9
5
8
7 4 6 3
2
En effet, si l’arc-cohérence sur le modèle PRIMAL calcule le point fixe suivant (seules les variables instantiées sont représentées):
Liens entre règles et modèles
À partir de la liste des règles présentées en section 2
nous définissons 5 niveaux de difficultés. Les règles
sont ordonnées de sorte que la difficulté de compréhension et de mise en œuvre6 soit croissante. Le niveau
de difficulté est ensuite défini par le niveau minimal de
règle à appliquer pour résoudre la grille. On obtient
le tableau de définition des niveaux de difficulté de la
table 1 (pour le niveau expert, les règles définies dans
cet article ne suffisent pas à résoudre la grille).
L’intérêt des modèles présentés dans la section 3 est
qu’ils permettent de caractériser chaque niveau de difficulté puisque ceux-ci sont spécifiés par un niveau de
règles déterminé. Ainsi, le tableau 2 présente les liens
entre les niveaux de difficulté et les modèles présentés.
6 Une règle simple à comprendre peut être difficile à mettre
en œuvre en pratique.
Or, on voit bien, par exemple, que si l’on ajoute le
modèle DUAL, la case marquée en rouge doit prendre
la valeur 9 puisque c’est la seule case de sa zone à
pouvoir prendre la valeur 9, ce qui instancie la variable
du modèle DUAL et par propagation entre les modèles
instancie la valeur de la case.
Notons que [6] propose aussi différents modèles contraintes pour résoudre des grilles de sudoku. Mais,
l’objectif est tout autre, il s’agit de raffiner les différents modèles par des niveaux de cohérence et de
propagation (contraintes globales) croissants, de sorte
à résoudre une grille de sudoku quelconque par propagation uniquement. Ainsi, le degré de sophistication
du modèle nécessaire pour résoudre une instance donnée apparaît a posteriori comme une mesure, la plupart du temps mais pas tout le temps, correcte de la
difficulté affichée de la grille.
Notre démarche est tout autre puisque nous cherchons plutôt à coller au plus près au raisonnement
humain en proposant des modèles contraintes modélisant différentes règles largement appliquées.
Une perspective intéressante de ce travail est
d’utiliser ces modèles et des mécanismes à base
d’explications pour fournir une aide à la résolution orientée utilisateur. On se rend compte d’ailleurs qu’il
est aussi nécessaire de repenser les modèles classiques
d’explications [4] car il est important ici d’expliquer
finement le raisonnement interne à une contrainte
(pour faire par exemple apparaître explicitement la
notion de doublet ou de triplet dans un all-different).
Cette nécessité ne se limite pas au sudoku et peut être
nécessaire dans de nombreux problèmes dont le modèle se réduit à l’utilisation d’une ou deux contraintes
globales puissantes. Enfin, nous pouvons aussi envisager la génération directe d’instances de sudoku pour
un niveau de difficulté donné.
5
References
Conclusion et perspectives
Dans cet article, nous avons présenté différents modèles contraintes permettant de modéliser les différentes
règles communément appliquées pour résoudre à la
main des grilles de sudoku. L’intérêt de ces modèles
permet de déterminer trois niveaux globaux de difficultés liés à la puissance du raisonnement mis en œuvre
pour résoudre des grilles :
• des modèles basés sur un raisonnement local :
modèles PRIMAL, DUAL et ABSTRACT implémentant les règles Single Candidate, Single Position et Candidate Line. Ces règles ne nécessitent
qu’un raisonnement local (nécessité traduite dans
les modèles par une utilisation exclusive de contraintes de diségalité) pour être appliquées.
• des modèles nécessitant un raisonnement global :
cohérences AC(3-ABSTRACT), AC(k-PRIMAL)
et AC(k-DUAL) implémentant les règles Double Pair, Multiple Lines, Naked Pairs, Naked
Triple, X-Wing et Swordfish. Ces règles nécessitent un raisonnement global pour être appliquées. Cette nécessité est traduite dans les
modèles par l’utilisation de la contrainte globale
de type all-different.
• des modèles nécessitant une étape de recherche.
Il s’agit d’implémenter alors la technique dite de
Forcing Chains.
Ces trois niveaux permettent de réconcilier puissance de filtrage mis en œuvre dans les modèles contraintes et impression de difficulté lors d’une résolution
manuelle d’une grille de sudoku. Nous avons en effet
mis l’accent sur une variétés de modèles plutôt que sur
l’utilisation de techniques de filtrage de plus en plus
sophistiquées comme dans [6]. On peut ainsi y trouver
un intérêt pédagogique.
[1] http://www.palmsudoku.com.
[2] Bertram Felgenhauer and Frazer Jarvis.
http://www.afjarvis.staff.shef.ac.uk/sudoku/.
[3] J.-C. Regin. A filtering algorithm for constraints of
difference in CSPs. In Proc. 12th Conf. American
Assoc. Artificial Intelligence, volume 1, pages 362–
367. Amer. Assoc. Artificial Intelligence, 1994.
[4] Guillaume Rochart and Narendra Jussien. Une
contrainte stretch expliquée. JEDAI: Journal
Électronique d’Intelligence Artificielle, 3(31), 2004.
[5] Ed
Russell
and
Frazer
Jarvis.
http://www.afjarvis.staff.shef.ac.uk/sudoku/sudgroup.html.
[6] Helmut Simonis. Sudoku as a constraint problem.
In Fourth CP internation Workshop on Modelling
and Reformulating Constraint Satisfaction Problems, pages 13–27, Sitges, Espagne, 2005.