OPC – Utilisation de AbsCon et Sat4j

OPC – Utilisation de AbsCon et Sat4j
R´esum´e
Le but de ce TP est d’illustrer l’importance de la mod´elisation avec un solveur CSP, et de mettre
en ´evidence certaines forces et faiblesses de diff´erentes approches d´evelopp´ees dans le laboratoire,
au sein des plates-formes AbsCon et Sat4j. La mod´elisation des probl`emes se fera en Java, grˆace `a
AbsCon. Les probl`emes seront ensuite export´es au format XCSP 2.1 pour ˆetre lisibles par une vaste
palette de solveurs. Pour information, et pour vous convaincre de l’importance de la programmation
par contraintes dans l’industrie, une Java Specification Request existe depuis mars 2012 pour la
programmation par contrainte : la JSR 331.
1 Utiliser AbsCon et Sat4j
1.1 Utiliser AbsCon
Pour tester AbsCon, t´el´echargez le fichier abscon.jar depuis http://www.cril.fr/˜lecoutre
– onglet Enseignement. Ensuite, dans un terminal, tapez :
java -jar abscon.jar
En retour, vous obtenez des informations sur le param´etrage possible du solveur. Pour le moment,
essayons simplement le solveur sur une instance pr´ed´efinie de nom queens-8.xml au format XCSP
(que vous r´ecup´erez sur la page cit´ee plus haut). Cela donne
java -jar abscon.jar queens-8.xml
Pour obtenir toutes les solutions, tapez :
java -jar abscon.jar queens-8.xml -s=all
Pour obtenir toutes les solutions de mani`ere non verbeuse, tapez :
java -jar abscon.jar queens-8.xml -s=all -v=0
1.2 Utiliser Sat4j
Pour tester Sat4j, t´el´echargez le fichier sat4j-cps.jar depuis http://sat4j.ow2.org/.
Sat4j lit les instances au format XCSP et le transforme en probl`eme SAT. Il ne s’agit donc pas d’un
prouveur CSP qui utilise les techniques pr´esent´ees en OPC (filtrage, contraintes globales, etc).
Pour obtenir une solution du CSP, taper
java -jar sat4j-csp.jar queens-8.xml
Pour compter le nom de solutions, et afficher la derni`ere, taper :
java -Dall=true -jar sat4j-csp.jar queens-8.xml
Pour voir toutes les solutions, taper :
java -Dverbose=true -Dall=true -jar sat4j-csp.jar queens-8.xml
1

Le mode verbeux permet aussi de suivre la transformation des instances CSP en SAT : on pourra
noter sur certaines instances que le solveur passe plus de temps `a traduire le probl`eme en SAT qu’`a
le r´esoudre ensuite.
Il est possible sur certains exemples de ne pas avoir assez de m´emoire. Dans ce cas, il faudra
changer les param`etres de la JVM d’Oracle :
java -Xms2g -Xmx2g -Dverbose=true -Dall=true -jar sat4j-csp.jar queens-8.xml
2 Mod´eliser avec AbsCon
Pour mod´eliser un probl`eme avec AbsCon, le plus simple est de proc´eder comme suit avec Eclipse.
1. Utiliser un ordinateur ´equip´e avec Java SE 7 et Eclipse
2. Lancer et param´etrer Eclipse
— Si c’est la premi`ere fois qu’Eclipse est ex´ecut´e, accepter le r´epertoire de travail par d´efaut
propos´e, et ensuite “Go to Workbench”
— Cr´eer un projet Java de nom abscon :
— File - New - Java Project
— Taper le nom du projet (ici, abscon), puis choisir Next
— Dans l’onglet Libraires, choisir “add External Jars” , puis s´electionner abscon.jar
3. Cr´eer une classe Java de nom Test.java dans le r´epertoire src du projet comme suit :
import static ios.inputs.Expr.*;
import problem.*;
public class Test extends Problem {
private Variable x, y;
@Override
protected void specifyVariables() {
x = addVariable("x", range(1, 3)); // nom, valeurMin, valeurMax
y = addVariable("y", range(1, 3)); // nom, valeurMin, valeurMax
}
@Override
protected void specifyConstraints() {
addConstraint(eq(x, y)); //x=y
}
}
4. Ex´ecuter le solveur
— dans un terminal, en vous pla¸cant dans le r´epertoire bin du projet, et en copiant le fichier
abscon.jar dans ce mˆeme r´epertoire, vous pouvez taper :
java -jar abscon.jar Test
— dans un terminal, depuis n’importe quel r´epertoire, vous pouvez taper :
java -cp ˜/workspace/abscon/bin:abscon.jar abscon.Resolution Test
— depuis Eclipse,
Menu Run
Sous-menu Run configurations...
Onglet Main
Project: abscon
Main class: abscon.Resolution
Onglet Arguments
Program arguments: Test -s=all
VM arguments:
2

puis Run
Remarque 1 Pour simplifier, par la suite, on ´ecrira toujours
java -jar abscon.jar ...
quelle que soit la m´ethode utilis´ee pour lancer le solveur (telle que d´ecrite ci-dessus).
3 Le probl`eme des reines
1. Le code ci-dessous est `a placer dans un fichier de nom Queens.java.
import static ios.inputs.Expr.*;
import problem.Problem;
public class Queens extends Problem {
private int nbQueens, model; // parameters
private Variable[] queens; // variables
@Override
protected void specifyParameters() {
nbQueens = addParameterInt("Nb queens", 2); // message, minValue
model = addParameterInt("Model (1 to 3)", range(1, 3)); // message, minValue, maxValue
}
@Override
protected void specifyVariables() {
queens = addVariableArray1D("Q", range(0, nbQueens - 1), nbQueens);
}
private void model1() {
for (int i = 0; i < nbQueens; i++)
for (int j = i + 1; j < nbQueens; j++)
addConstraint(ne(queens[i], queens[j]));
for (int i = 0; i < nbQueens; i++)
for (int j = i + 1; j < nbQueens; j++) {
int rowDistance = Math.abs(i - j);
String colDistance = dist(queens[i], queens[j]);
addConstraint(ne(colDistance, rowDistance));
}
}
@Override
protected void specifyConstraints() {
switch (model) {
case 1:
model1();
break;
}
}
}
Il est important de noter que pour d´efinir des contraintes en intension, on peut construire des
expressions/formules bool´eennes (pr´edicats) `a l’aide de constantes (enti`eres et bool´eennes) et
des fonctions (op´erateurs) d´ecrits par la table 1.
2. Lancer le solveur en mode interactif (il demandera la valeur des param`etres) avec :
java -jar abscon.jar Queens
Sinon on peut directement les donner en ligne de commande
java -jar abscon.jar Queens 8 1
3. Pour obtenir un affichage plus lisible des solutions, red´efinissez la m´ethode prettySolutionDisplay
comme par exemple :
3

Operation Arity Syntax Semantics
Arithmetic (operands are integers)
Opposite 1 neg(x) -x
Absolute Value 1 abs(x) |x|
Addition 2 add(x,y) x + y
Substraction 2 sub(x,y) x - y
multiplication 2 mul(x,y) x * y
Integer Division 2 div(x,y) x div y
Remainder 2 mod(x,y) x mod y
Power 2 pow(x,y) xy
Minimum 2 min(x,y) min(x,y)
Maximum 2 max(x,y) max(x,y)
Relational (operands are integers)
Equal to 2 eq(x,y) x = y
Different from 2 ne(x,y) x 6= y
Greater than or equal 2 ge(x,y) x ≥y
Greater than 2 gt(x,y) x >y
Less than or equal 2 le(x,y) x ≤y
Less than 2 lt(x,y) x <y
Logic (operands are Booleans)
Logical not 1 not(x) ¬x
Logical and 2 and(x,y) x ∧y
Logical or 2 or(x,y) x ∨y
Logical xor 2 xor(x,y) x ⊕y
Logical equivalence (iff) 2 iff(x,y) x ⇔y
Control
Alternative 3 if(x,y,z) value of y if x is true,
otherwise value of z
Table 1 – Op´erateurs utilis´es pour construire des pr´edicats
@Override
public void specifySolutionDisplay() {
for (int i = 0; i < nbQueens; i++) {
for (int j = 0; j < nbQueens; j++)
System.out.print(queens[i].dom.getUniqueValue()==j?"Q":"-");
System.out.println();
}
}
4. Noter le temps et le nombre de noeuds n´ecessaire pour trouver toutes les solutions de l’instance
des 12 reines (avec le mod`ele 1) :
java -jar abscon.jar Queens 12 1 -s=all -v=0
5. Int´egrer une nouvelle formulation des contraintes (model = 2) o`u les deux jeux de contraintes
sont fusionn´es (i.e. les contraintes de mˆeme port´ee sont fusionn´ees). Tester le nouveau mod`ele
et comparer le temps de r´esolution ainsi que le nombre de noeuds explor´es (pour toutes les
solutions de l’instance des 12 reines).
6. Pour le mod`ele 3, ajouter simplement une contrainte globale redondante (utilisez la m´ethode
addConstraintAllDifferent au mod`ele pr´ec´edent.
7. Comparer les 3 mod`eles en terme de temps d’ex´ecution et du nombre de noeuds explor´es lorsque
les 14 200 solutions au probl`eme des 12 reines sont recherch´ees.
4

8. Il existe un format de repr´esentation g´en´erique pour les r´eseaux de contraintes permettant
de s’affranchir du codage d’un probl`eme par programmation. Ce format bas´e sur XML et
appel´e XCSP 1d´ecrit pr´ecis´ement les diff´erents composants d’un r´eseau de contraintes. Il est
possible sous AbsCon de sauvegarder un r´eseau d´efini par programmation sous ce format. Il
suffit d’utiliser une commande telle que :
java -jar abscon.jar Queens 12 2 -xo=2 -export
Vous obtenez en retour l’affichage de la repr´esentation XCSP du probl`eme sur la sortie standard.
Bien sur, vous pouvez la rediriger dans un un nouveau fichier (extension xml obligatoire) comme
suit :
java -jar abscon.jar Queens 12 2 -xo=2 -export > Queens-12-2.xml
Pour lancer la r´esolution avec AbsCon `a partir de ce nouveau fichier, vous n’avez qu’`a utiliser
une commande telle que :
java -jar abscon.jar Queens-12-2.xml
L’int´erˆet ici est que ce format est reconnu par diff´erents solveurs.
G´en´erer un fichier xml du probl`eme des 12 reines pour chaque mod`ele.
9. Comparer les 3 mod`eles en terme de temps d’ex´ecution et de nombre de conflits pour le prouveur
Sat4j.
4 Le probl`eme Sudoku
Int´egrer le code suivant pour le probl`eme du Sudoku (d´efini ici pour une grille vierge) :
public class Sudoku extends Problem {
protected int order;
protected Variable[][] matrix;
@Override
protected void specifyParameters() {
order = addParameterInt("order (9 = classical Sudoku)", 2);
}
@Override
protected void specifyVariables() {
matrix = addVariableArray2D(range(1, order), order, order);
}
@Override
protected void specifyConstraints() {
for (int i = 0; i < order; i++)
addConstraintAllDifferent(matrix[i]); // rows
for (int i = 0; i < order; i++)
addConstraintAllDifferent(Variable.columnOf(matrix, i)); // columns
int base = (int) Math.sqrt(order);
for (int i = 0; i < order; i += base)
for (int j = 0; j < order; j += base)
addConstraintAllDifferent(Variable.pieceOf(matrix, i, base, j, base)); // blocks
}
@Override
public void specifySolutionDisplay() {
for (int i = 0; i < order; i++)
for (int j = 0; j < order; j++)
Kit.pr(variables[i *order + j].dom.getUniqueVal() + (j == order - 1 ? "\n" : " "));
}
}
1. Voir http://arxiv.org/pdf/0902.2362v1
5