Cohérence d'arc virtuelle dynamique

HAL Id: lirmm-00830411

https://hal-lirmm.ccsd.cnrs.fr/lirmm-00830411

Submitted on 10 Oct 2019

HAL is a multi-disciplinary open access archive for the deposit and dissemination of sci- entific research documents, whether they are pub- lished or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L’archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d’enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Cohérence d’arc virtuelle dynamique

Thomas Schiex, Christian Bessière, Thi Hông Hiêp Nguyên

To cite this version:

Thomas Schiex, Christian Bessière, Thi Hông Hiêp Nguyên. Cohérence d’arc virtuelle dynamique.

9èmes Journées Francophones de Programmation par Contraintes (JFPC 2013), Jun 2013, Aix-en-

Provence, France. pp.249-258. �lirmm-00830411�

Actes JFPC 2013

Coh´ erence d’arc virtuelle dynamique

Hiep Nguyen ¹ Christian Bessiere ² Thomas Schiex ¹

1 Unit´ e de Biom´ etrie et Intelligence Artificielle, INRA, Toulouse, France

2 CNRS, Universit´ e de Montpellier, France

{hnguyen,tschiex}@toulouse.inra.fr bessiere@lirmm.fr

R´ esum´ e

La coh´ erence d’arc virtuelle (VAC) est une coh´ erence r´ ecente pour les r´ eseaux de fonctions de coˆ ut (ou r´ eseaux de contraintes pond´ er´ ees). VAC exploite une relation simple mais puissante avec les r´ eseaux de contraintes classiques. VAC a permis de clore des probl` emes d’af- fectation de fr´ equences difficiles, et est capable de r´ e- soudre directement les r´ eseaux de fonctions de coˆ ut sous- modulaires. L’algorithme pour ´ etablir VAC est un algo- rithme it´ eratif qui r´ esout une s´ equence de r´ eseaux de contraintes classiques. Dans cet article, nous montrons que les techniques utilis´ ees dans les algorithmes de coh´ e- rence d’arc dynamique peuvent ˆ etre inject´ ees dans l’al- gorithme it´ eratif de coh´ erence d’arc virtuelle. Cette in- t´ egration donne une acc´ el´ eration importante.

Abstract

Virtual Arc Consistency (VAC) is a recent local consistency for processing Cost Function Networks (or Weighted Constraint Networks) that exploits a simple but powerful connection with classical Constraint Net- works. It has allowed to close hard frequency assignment benchmarks and is capable of directly solving networks of submodular functions. The algorithm enforcing VAC is an iterative algorithm that solves a sequence of clas- sical Constraint Networks. In this work, we show that Dynamic Arc Consistency algorithms can be suitably in- jected in the virtual arc consistency iterative algorithm, providing noticeable speedups.

1 Introduction

L’analyse des mod` eles graphiques, et en particulier des r´ eseaux de contraintes, est un probl` eme impor- tant en intelligence artificielle. L’optimisation du coˆ ut combin´ e de fonctions de coˆ ut locales, probl` eme central dans le cadre des CSP valu´ es [11], permet de capturer des probl` emes vari´ es, tels que MaxSAT pond´ er´ e, CSP pond´ er´ e ou le probl` eme de recherche d’une explication de probabilit´ e maximum dans les mod` eles graphiques

stochastiques (r´ eseaux bay´ esiens, champs al´ eatoires de Markov). Elle a des applications en allocation de res- sources, ench` eres combinatoires, bioinformatique, etc.

Les approches de programmation dynamique, ba- s´ ees sur l’´ elimination de variables ou sur les arbres de jonction, ont ´ et´ e largement utilis´ ees pour r´ esoudre de tels probl` emes. Cependant, elles sont intrins` equement limit´ ees par leur complexit´ e exponentielle en espace et en temps dans la largeur d’arbre (treewidth) des pro- bl` emes trait´ es. Au contraire, la recherche arborescente en profondeur d’abord par “Branch and Bound” (s´ e- paration et ´ evaluation) permet de conserver une com- plexit´ e en espace raisonnable. Elle n´ ecessite cependant de bons minorants (forts et peu coˆ uteux) pour ˆ etre ef- ficace.

Ces derni` eres ann´ ees, des minorants de qualit´ e crois- sante ont ´ et´ e d´ efinis en appliquant des coh´ erences locales dans des R´ eseaux de Fonctions de Coˆ ut (ou CFN pour “Cost Function Networks”). Ces coh´ erences sont ´ etablies en appliquant it´ erativement des op´ e- rations appel´ ees Transformations Pr´ eservant l’Equi- valence (EPT, Equivalence Preserving Transforma- tions, [7]) qui ´ etendent les op´ erations de coh´ erence lo- cale usuelles utilis´ ees dans les CSP classiques. Les EPT d´ eplacent des coˆ uts entre des fonctions d’arit´ e diff´ e- rente tout en pr´ eservant l’´ equivalence du probl` eme.

En d´ epla¸ cant finalement des coˆ uts vers une fonction d’arit´ e nulle, les EPT sont capables de fournir un mi- norant du coˆ ut optimum qui peut ˆ etre maintenu de mani` ere incr´ ementale pendant la recherche arbores- cente.

Les coh´ erences locales traditionnelles des CFN telles qu’AC*, DAC*, FDAC* ou EDAC* [10] appliquent les EPT dans un ordre arbitraire. Par contre, la Coh´ e- rence d’Arc Virtuelle (VAC pour Virtual Arc Consis- tency [5, 6]) planifie une s´ equence d’EPT ` a appliquer.

Elle le fait en se basant sur le r´ esultat de l’´ etablisse-

ment de la coh´ erence d’arc classique dans un r´ eseau

de contraintes classique qui interdit toutes les com- binaisons de valeurs de coˆ ut non nul. VAC est non seulement plus fort que ces coh´ erences locales mais est capable de r´ esoudre les r´ eseaux form´ es de fonctions de coˆ ut sous-modulaires. Une it´ eration de VAC peut ˆ etre appliqu´ ee via un algorithme polynomial d’ordre faible et VAC a permis de clore des probl` emes d’affectation de fr´ equences difficiles [5]. Cependant, il est souvent trop couteux pour ˆ etre utilis´ e de fa¸con g´ en´ erale.

Dans cet article, l’efficacit´ e de VAC est am´ elior´ ee en exploitant son comportement it´ eratif. Chaque it´ e- ration de VAC demande d’´ etablir la coh´ erence d’arc classique dans la version durcie du r´ eseau. N´ eanmoins, chacun de ces r´ eseaux est juste le r´ esultat des modi- fications incr´ ementales effectu´ ees par les EPT appli- qu´ ees dans l’it´ eration pr´ ec´ edente. Cette situation, o` u la coh´ erence d’arc est ´ etablie it´ erativement dans les versions modifi´ ees de mani` ere incr´ ementale d’un r´ e- seau de contraintes, a ´ et´ e d´ ej` a consid´ er´ ee dans les al- gorithmes de Coh´ erence d’Arc Dynamique [1, 3] pour les CSP dynamiques [8].

En pratique, nous observons que l’utilisation de la coh´ erence d’arc dynamique dans VAC acc´ el` ere la re- cherche pour de nombreux probl` emes. Ceci est peut- ˆ etre l’une des premi` eres applications r´ eelles des algo- rithmes de Coh´ erence d’Arc Dynamique.

2 Pr´ eliminaires

2.1 R´ eseaux de Fonctions de Coˆ ut

Un r´ eseau de fonctions de coˆ ut, ou CSP pond´ er´ e, est quadruplet (X, D, W, m) o` u X est un ensemble de n variables. Chaque variable i ∈ X a un domaine D <sub>i</sub> ∈ D d’au plus d valeurs. ´ Etant donn´ e un sous-ensemble de variables S ⊆ X , on note `(S) l’ensemble des n-uplets d´ efinis sur S. W est un ensemble de e fonctions de coˆ ut. Chaque fonction de coˆ ut w _S ∈ W est d´ efinie sur un ensemble de variables S, appel´ e sa port´ ee, et sup- pos´ e diff´ erent pour chaque fonction de coˆ ut. Une fonc- tion de coˆ ut w S assigne un coˆ ut ` a chaque affectation de variables dans S, c’est ` a dire w S : `(S) → [0..m]

o` u m ∈ {1, ..., +∞}. Le coˆ ut m repr´ esente un coˆ ut in- tol´ erable, associ´ e ` a une valeur ou un n-uplet interdit.

Les coˆ uts sont combin´ es par l’addition born´ ee ⊕, d´ e- finie par a ⊕ b = min(a + b, m). Un coˆ ut b peut ˆ etre soustrait d’un coˆ ut plus grand a en utilisant la sous- traction d´ efinie par : a b = a − b si a < m et m sinon. Le coˆ ut d’un n-uplet complet t est la somme des coˆ uts Val _P (t) = L

w

∈W w _S (t[S]) o` u t[S] est la projection de t sur S. Dans cet article, nous consid´ e- rons des r´ eseaux binaires, form´ es de fonctions d’arit´ e au plus 2. Nous d´ enotons par w _i et w _ij les fonctions de coˆ ut unaires et binaires d´ efinies sur la variable i

et sur les variables i, j respectivement. Nous faisons l’hypoth` ese qu’une fonction de coˆ ut unaire, not´ ee w i , existe pour toute variable i ainsi qu’une fonction de coˆ ut d’arit´ e nulle not´ ee w _∅ . Ce coˆ ut positif constant d´ efinit un minorant du coˆ ut de toutes les solutions.

L’´ etablissement d’une coh´ erence locale donn´ ee dans un CFN P consiste ` a transformer le CFN P en un probl` eme P ⁰ ´ equivalent ` a P : (Val P (t) = Val P

(t) ∀t) menant ` a un ´ eventuel accroissement du minorant de coˆ ut optimum d´ efini par w _∅ . Il s’appuie sur l’ap- plication des transformations pr´ eservant l’´ equivalence (EPT) qui d´ eplacent les coˆ uts entre les fonctions de port´ ee diff´ erente. L’algorithme 1 introduit trois EPT

´

el´ ementaires. Project( w _ij , i, a, α ) d´ eplace une quantit´ e de coˆ ut α d’une fonction binaire w _ij vers une fonc- tion unaire w i , sur une valeur a ∈ D i . Un appel ` a Ex- tend( i, a, w ij , α ) effectue le travail inverse. Enfin, Una- ryProject( i, α ) projette une quantit´ e de coˆ ut α d’une fonction unaire vers la fonction de coˆ ut d’arit´ e nulle w _∅ .

Algorithme 1 : Les EPTs ´ el´ ementaires Proc´ edure Project( w _ij , i, a, α )

1

w _i (a) ←− w _i (a) ⊕ α ;

2

foreach b ∈ D j do w ij (a, b) ←− w ij (a, b) α;

3

Proc´ edure Extend( i, a, w _ij , α )

4

foreach b ∈ D j do w ij (a, b) ←− w ij (a, b) ⊕ α;

5

w i (a) ←− w i (a) α ;

6

Proc´ edure UnaryProject( i, α )

7

foreach a ∈ D i do w i (a) ←− w i (a) α;

8

w _∅ ←− w _∅ ⊕ α ;

9

Notez qu’un CSP binaire classique peut ˆ etre repr´ e- sent´ e comme un CFN avec m = 1 (le coˆ ut 1 est assign´ e aux n-uplets interdits). Comme d’habitude, une valeur (i, a) est dite arc coh´ erente (AC) sur w ij ssi il y a une paire (a, b) (support) qui satisfait w ij et que b ∈ D j

(valide). Un CSP est AC si toutes ses valeurs sont AC sur toutes les contraintes. L’´ etablissement de AC dans un CSP P produit sa fermeture AC, un CSP qui est

´

equivalent ` a P et qui est AC.

2.2 Coh´ erence d’Arc Virtuelle

D´ efinition 1. Etant ´ donn´ e un CFN P = (X, D, W, m), le probl` eme Bool(P) = (X, D, W , 1) est un CSP qui satisfait : ∃w S ∈ W ssi ∃w S ∈ W , S 6= ∅ et w S (t) = 1 ⇔ w S (t) 6= 0. Un CFN P est arc coh´ erent virtuel (VAC) ssi la fermeture arc coh´ erente classique du CSP Bool(P) n’est pas vide [6].

Bool(P ) est un CSP dont les solutions sont exac-

tement les n-uplets complets ayant un coˆ ut de w _∅

dans P . Si P n’est pas VAC, l’´ etablissement de AC dans Bool(P ) va g´ en´ erer un domaine vide. Dans ce cas, comme indiqu´ e dans [6], il existe une s´ equence d’EPT dont l’application m` ene ` a une augmentation de w _∅ . L’algorithme d’´ etablissement de VAC utilise cette propri´ et´ e dans un processus it´ eratif en trois phases.

La phase 1 consiste ` a ´ etablir AC dans le CSP Bool(P ). Dans cette phase, les effacements de valeurs sont m´ emoris´ es dans une structure de donn´ ees not´ ee tueur. Lorsqu’une valeur (i, a) n’a pas de support va- lide sur w ij , on affecte tueur (i, a) = j et on efface (i, a). Si aucun domaine de variable n’est vid´ e, P est VAC et le processus d’´ etablissement de VAC s’arrˆ ete.

Sinon, la phase 2 identifie le sous-ensemble des va- leurs effac´ ees qui sont n´ ecessaires pour produire le do- maine vide et les stocke dans une pile R. En retra-

¸

cant l’histoire des propagations de la phase pr´ ec´ edente d´ efinie par tueur, ` a partir de la variable dont le do- maine a ´ et´ e vid´ e jusqu’aux coˆ uts non nuls, il est pos- sible de d´ eterminer les effacements indispensables. Par ailleurs, cette phase ´ evalue la quantit´ e de coˆ ut maxi- male qu’il est possible de d´ eplacer sur w <sub>∅</sub> (not´ ee λ) et d´ efinit l’ensemble d’EPT ` a appliquer dans P afin d’at- teindre cette augmentation. Comme pr´ esent´ e dans [6], toutes les quantit´ es de coˆ ut d´ eplac´ ees par EPT sont stock´ ees dans deux tableaux de nombres entiers k(j, b) et k ij (j, b). Ils repr´ esentent respectivement le nombre de demandes de coˆ ut d’un montant λ ` a projeter sur (j, b) et ` a ´ etendre de (j, b) sur w ij . Notez que le d´ epla- cement de ces coˆ uts respecte une r` egle de conservation simple. Pour chaque valeur (j, b) d’une variable non vide j qui n’est pas la source de coˆ ut (w j (b) = 0), la quantit´ e de coˆ ut que (j, b) re¸ coit par Project est exac- tement la quantit´ e de coˆ ut sortant de (j, b) par Extend (voir [6], page 465).

∀(j, b) s.t. w j (b) = 0, k(j, b) = X

w

∈W

k ij (j, b) (1)

La phase 3 de VAC, comme d´ ecrite en d´ etail dans l’algorithme 2, modifie le CFN original en appliquant les EPT d´ efinies par les structures de donn´ ees k et k ij

sur toutes les valeurs effac´ ees indispensables stock´ ees dans R. Une valeur (j, b) effac´ ee par w ij va recevoir un coˆ ut de k(j, b) × λ par Project depuis w _ij (ligne 7).

N´ eanmoins, il faut tout d’abord ´ etendre un coˆ ut de k _ij (i, a) × λ ` a partir des supports invalides (i, a) sur w <sub>ij</sub> (ligne 5). Cette phase produit finalement un nou- veau probl` eme P ⁰ ´ equivalent ` a P avec un minorant w _∅ augment´ e (ligne 8).

Notez qu’` a la fin de la phase 1, lorsqu’il y a une variable de domaine vide i <sub>0</sub> , le probl` eme obtenu n’est pas forc´ ement la fermeture arc coh´ erente maximum de Bool(P ). Il y a peut-ˆ etre quelques valeurs qui n’ont

pas ´ et´ e encore supprim´ ees bien qu’elles n’aient aucun support valide, parce que le domaine concern´ e n’a pas encore ´ et´ e r´ evis´ e. Une telle variable est encore dans la file de propagation Q AC qui contient les variables res- tant ` a propager. Quant aux autres valeurs, soit elles ont un support valide, soit elles ont ´ et´ e supprim´ ees et leur tueur associ´ e n’est pas vide. Un tel probl` eme est appel´ e une fermeture arc coh´ erente partielle jus- tifi´ ee de Bool(P ). Aucun domaine dans ce probl` eme ne peut ˆ etre plus large que dans Bool(P ), les valeurs effac´ ees n’ont pas de support valide et sont justifi´ es correctement par les tueur.

Algorithme 2 : Phase 3 de VAC : Application des EPTs

tant que R 6= ∅ faire

1

(j, b) ←− R.pop();

2

i ←− tueur [j, b];

3

pour chaque a ∈ D i s.t. k ij (i, a) 6= 0 faire

4

Extend( i, a, w ij , λ × k ij (i, a) ) ;

5

k ij (i, a) ←− 0;

6

Project( w ij , j, b, λ × k(j, b) ) ;

7

UnaryProject( i 0 , λ ) ;

8

L’algorithme de VAC a une complexit´ e spatiale en O(ed) parce que les structures de donn´ ees tueur, k et k ij n´ ecessitent une m´ emoire de O(nd), O(nd) et O(ed) respectivement. La complexit´ e en temps de chaque it´ e- ration de VAC est en O(ed ² ) tant qu’un algorithme de AC optimal est utilis´ e dans la phase 1.

Les it´ erations de VAC ´ etablissent AC sur une s´ equence de CSP l´ eg` erement modifi´ es : Bool(P), Bool(P <sup>0</sup> ), . . . Cela motive l’id´ ee d’utiliser des algo- rithmes d’AC dynamique pour appliquer AC ` a chaque it´ eration.

2.3 Coh´ erence d’Arc Dynamique

D´ efinition 2 ([8]). Un CSP dynamique est une s´ e- quence P ₀ , P ₁ , ..., P _n de CSP o` u chaque P _i est un CSP r´ esultant de l’addition ou du retrait d’une contrainte dans P _i−1 .

Les algorithmes de Coh´ erence d’Arc Dynamique (DnAC) consistent ` a maintenir la coh´ erence d’arc dans la s´ equence des probl` emes P i . L’´ etablissement d’AC est naturellement incr´ ementale pour la restriction (ad- dition d’une contrainte) : il est suffisant d’´ etablir AC (phase 1) avec une file de propagation Q _AC contenant les variables de la contrainte qui vient d’ˆ etre ajout´ ee.

Cependant, AC n’est pas incr´ emental pour la relaxa-

tion (retrait d’une contrainte). On a donc besoin d’un

processus suppl´ ementaire pour r´ egler ce cas : il faut

restaurer les valeurs supprim´ ees directement ou indi- rectement ` a cause de la contrainte retir´ ee d` es lors qu’il n’y pas d’autre raison de les supprimer.

Diff´ erentes familles d’algorithmes ont ´ et´ e propos´ ees pour DnAC. Dans cet article, nous nous appuyons sur AC/DC2 [1] qui est une am´ elioration de AC/DC [2]

s’appuyant sur des structures de donn´ ees persistantes tr` es limit´ ees. La plus importante d’entre-elles est un tableau justification(i, a) (comme dans DnAC4 [3]) qui m´ emorise la source de l’effacement de (i, a). Cette structure correspond exactement ` a la structure tueur de VAC ¹ .

Lors du retrait d’une contrainte donn´ ee w ij , AC/DC2 se d´ eroule en 3 ´ etapes : 1) initialisation : toutes les valeurs des variables i et j supprim´ ees par w ij sont candidates pour ˆ etre restaur´ ees et marqu´ ees en “Propageable”. On peut d´ eterminer exactement ces valeurs en se basant sur le tableau justification. 2) pro- pagation : chaque valeur propageable est propag´ ee vers ses variables voisines en v´ erifiant si elle offre un nou- veau support aux valeurs dont elle ´ etait le tueur (va- leurs qui ont ´ et´ e effac´ ees par le manque de support sur la variable propageable) et qui seront alors aussi mar- qu´ ees comme “Propageable”. Notez que grˆ ace ` a justifi- cation, quand on propage la variable “Propageable” i, on ne consid` ere que les valeurs (j, b) effac´ ees par w ji

comme candidates ` a la restauration, au lieu de tes- ter toutes les valeurs du voisinage. Lorsqu’une valeur est propag´ ee sur toutes les variables de son voisinage, elle est marqu´ ee “Restaurable” et sera restaur´ ee. 3) fil- trage : toutes les valeurs restaur´ ees ont besoin d’ˆ etre rev´ erifi´ ees pour la coh´ erence d’arc. Ceci est accompli en ´ etablissant l’AC via la file de propagation Q <sub>AC</sub> , initialis´ ee de fa¸ con ` a imposer la r´ evision des variables ayant des valeurs restaur´ ees.

La complexit´ e spatiale d’un algorithme AC/DC bas´ e sur AC3 est en O(nd + e). La complexit´ e en temps de AC/DC2 est d´ efinie par l’algorithme de filtrage utilis´ e dans la derni` ere ´ etape : en O(ed ³ ) pour AC-3 et en O(ed ² ) pour AC2001 [1].

3 Algorithme de VAC Dynamique

En ´ etablissant VAC, le CFN P est incr´ ementale- ment modifi´ e dans la phase 3 de chaque it´ eration de VAC. Nous proposons donc une version am´ elior´ ee de VAC, appel´ ee VAC dynamique (DynVAC), qui utilise AC dynamique pour maintenir AC dans les Bool(P ) successifs au lieu de filtrer ` a partir de z´ ero ` a chaque it´ e- ration comme le fait l’algorithme VAC standard. Nous

1. AC/DC2 introduit une autre structure time-stamp(i, a) qui m´ emorise l’ordre des effacements. Le premier auteur de AC/DC2 nous a confirm´ e que cette structure est subsum´ ee par justification(i, a) (communication priv´ ee) et est donc inutile.

utilisons AC/DC2 [1] bas´ e sur AC2001, pour son op- timalit´ e. Un avantage de l’utilisation d’AC/DC2 est que la structure de donn´ ees justification est fournie gratuitement par la structure tueur de VAC.

3.1 Propri´ et´ es et algorithme

Dans les CSP dynamiques traditionnels, les algo- rithmes de DnAC sont appliqu´ es apr` es chaque addition ou suppression d’une contrainte. Dans le cas de VAC, la situation est plus compliqu´ ee parce qu’une s´ erie de modifications de Bool(P ) a lieu durant la phase 3 via l’application des EPT. Un appel de Project( w ij , i, a, α ) a deux effets : 1) l’augmentation du coˆ ut unaire w i (a) et 2) la diminution de coˆ uts dans la fonction de coˆ ut binaire w ij . Si un coˆ ut w i (a) nul augmente et de- vient strictement positif, la valeur (i, a) est enlev´ ee de Bool(P ), et ceci correspond ` a une restriction. Au contraire, si la paire (a, b) de coˆ ut strictement positif voit son coˆ ut atteindre z´ ero, cette paire pr´ ec´ edemment interdite dans w _ij devient autoris´ ee et ce fait corres- pond ` a une relaxation. Au lieu d’appliquer un algo- rithme de DnAC ` a chaque op´ eration Project , Extend et UnaryProject , une approche plus rationnelle consiste ` a appliquer les principes de DnAC une seule fois apr` es la phase 3 pour ´ eviter les restaurations/suppressions inutiles.

Chaque it´ eration de VAC transforme le CFN P ac- tuel en un probl` eme modifi´ e P <sup>0</sup> dont les fonctions de coˆ uts sont not´ ees w <sub>i</sub> <sup>0</sup> et w <sub>ij</sub> <sup>0</sup> . Il est possible de calculer les valeurs w <sub>i</sub> <sup>0</sup> et w <sup>0</sup> <sub>ij</sub> d` es la fin de la phase 2 puisqu’elles sont d´ efinies par une s´ equence connue d’op´ erations Pro- ject , Extend et UnaryProject appliqu´ ees sur w i et w ij . Par exemple, toutes les valeurs a d’une variable non vide i satisfont l’´ equation suivante :

w ⁰ _i (a) = w i (a) ⊕ (k(i, a).λ)

w

∈W (k ij (i, a).λ) De mani` ere similaire, il est possible de calculer les coˆ uts de la variable de domaine vide et des w ⁰ _ij . Nous allons maintenant prouver que l’effet global des toutes les EPT sur Bool(P ) dans la phase 3 est simplement un ensemble de relaxations au niveau des fonctions unaires et binaires.

Propri´ et´ e 1. D` es la phase 2, nous savons que : (a) ∀(i, a) : w ⁰ _i (a) ≤ w i (a).

(b) ∀(i, a) et (j, b) : si w ⁰ _ij (a, b) 6= w ij (a, b) alors (i, a) ou (j, b) est effac´ ee de la fermeture arc coh´ erente partielle justifi´ ee actuelle de Bool(P ).

D´ emonstration. (a) Dans VAC, la seule op´ eration qui

peut augmenter les coˆ uts unaires est l’op´ eration Pro-

ject Cependant, selon l’´ ˙ equation 1, si une valeur (i, a)

re¸ coit un coˆ ut via Project , elle va faire un Extend de

la mˆ eme quantit´ e de coˆ ut (vers d’autres fonctions de coˆ ut binaires ou vers w _∅ ). En cons´ equence, les coˆ uts unaires ne peuvent pas augmenter.

(b) Il n’y a que deux fa¸ cons pour changer un coˆ ut binaire w ij (a, b). C’est d’ex´ ecuter une op´ eration Project

`

a partir de w ij ou une op´ eration Extend sur lui. N´ ean- moins, la phase 3 de VAC n’applique Project et Extend qu’avec des valeurs extraites de la file des valeurs sup- prim´ ees R (construite dans la phase 2). Donc, quand le coˆ ut d’une paire (a, b) change, il faut que (i, a) ou (j, b) soit effac´ ee.

Corollaire 1. Les EPT appliqu´ ees dans la phase 3 de VAC transformant Bool(P ) en Bool(P ⁰ ) ne g´ en` erent que les types de relaxation suivants :

(1) des valeurs (i, a) deviennent autoris´ ees (w _i (a) >

w ⁰ _i (a) = 0).

(2) des paires ((i, a), (j, b)) deviennent autoris´ ees (w _ij (a, b) > w ⁰ _ij (a, b) = 0).

D´ emonstration. Selon la Propri´ et´ e 1(a), nous savons que les coˆ uts unaires ne peuvent que diminuer. Cer- tains coˆ uts non nuls peuvent diminuer ` a z´ ero. Donc, les valeurs correspondantes r´ eapparaissent dans Bool(P ⁰ ).

Ce fait peut ˆ etre consid´ er´ e comme la r´ etraction de contraintes unaires.

Selon la Propri´ et´ e 1(b), le coˆ ut des paires peut aug- menter ou diminuer. Si un coˆ ut binaire (a, b) augmente de z´ ero ` a non nul, cela ne peut d´ etruire aucun support valide parce qu’une des deux valeurs est effac´ ee dans la fermeture partielle actuelle. Le support n’est donc pas valide. Au contraire, si le coˆ ut de (a, b) diminue, cela peut cr´ eer un nouveau support pour a ou b.

En cons´ equence, l’algorithme DnAC utilis´ e peut ˆ

etre sp´ ecialis´ e pour un ensemble de relaxations (Al- gorithme 3). Le protocole de restauration se compose de 3 ´ etapes, comme dans AC/DC2. Notez que Bool(P ) est maintenu apr` es la phase 3 de chaque it´ eration. D i

mentionn´ e dans l’algorithme 3 repr´ esente le domaine de la variable i dans la fermeture arc coh´ erente par- tielle justifi´ ee finale obtenue apr` es la phase 1.

L’´ etape initialisation parcourt toutes les valeurs dans la file R dans le mˆ eme ordre de parcours que la phase 3 pour identifier les valeurs qui doivent ˆ etre restaur´ ees (ligne 2). La variable i 0 , dont le domaine a ´ et´ e vid´ e, est trait´ ee s´ epar´ ement. Selon le corol- laire 1, il y a deux cas possibles : (1) quand une va- leur (i, a) devient autoris´ ee w i (a) > w _i ⁰ (a) = 0, elle sera restaur´ ee (ligne 5), (2) quand un nouveau sup- port valide apparaˆıt pour la valeur (j, b) en satisfaisant (w _ij (a, b) ⊕ w _i (a)) > (w ⁰ _ij (a, b) ⊕ w _i ⁰ (a)) = 0 et tueur [j, b] = i, (j, b) sera restaur´ ee (ligne 7). Lorsqu’une va- leur (i, a) est restaur´ ee, elle est stock´ ee dans un tableau restaur´ e[i] et la variable i est ajout´ ee dans la liste RL

Algorithme 3 : Mise ` a jour de Bool(P) Proc´ edure Initialisation

1

pour chaque (j, b) ∈ R faire

2

i ←− tueur [j, b];

3

pour chaque a ∈ D _i − D _i faire

4

si (w _i (a) > 0) ∧ (w ⁰ _i (a) = 0) alors

5

Restaurer( i, a ) ;

si b / ∈ D j ∧ w _i ⁰ (a) = 0 ∧ w _ij ⁰ (a, b) = 0

6

alors Restaurer( j, b ) ; pour chaque a ∈ D _i

tel que

7

w _i

(a) > 0 ∧ w _i ⁰

0

(a) = 0 faire Restaurer( i ₀ , a ) ; Proc´ edure Restaurer( i, a )

8

ajouter a dans D i et restaur´ e[i];

9

ajouter i dans RL;

10

tueur [i, a] ← nil;

11

Proc´ edure Propagation

12

tant que RL 6= ∅ faire

13

i ← RL.pop();

14

pour chaque w ij ∈ W faire

15

pour chaque b ∈ D _j − D _j s.t. tueur

16

[j, b]= i faire

si ∃a ∈ restaur´ e[i] s.t. w _ij ⁰ (a, b) = 0

17

alors Restaurer( j, b ) ; restaur´ e[i] ← ∅ ;

18

Q _AC ← Q _AC ∪ {j | w _ij ∈ W }

19

qui contient les variables dont la restauration doit ˆ etre propag´ ee.

L’´ etape propagation propage les restaurations de valeurs vers les variables voisines, comme dans AC/DC2 (ligne 14,15). Chaque variable i peut restau- rer une valeur (j, b) dans une variable voisine j si cette valeur a ´ et´ e supprim´ ee ` a cause de w ij (ligne 16) et qu’elle maintenant support´ ee par une valeur restaur´ ee dans i (ligne 17). Apr` es avoir propag´ e toutes les va- leurs restaur´ ees, la liste restaur´ e est vid´ ee (ligne 18) pour ´ eviter de repropager les valeurs qui ont ´ et´ e d´ ej` a propag´ ees.

L’´ etape filtrage doit ´ eliminer les valeurs restaur´ ees (i, a) qui ne sont pas arc coh´ erentes sur une contrainte w _ij et assigner j ` a tueur [i, a]. Cette tˆ ache est exacte- ment le travail de la phase 1 de VAC. En cons´ equence, nous avons int´ egr´ e cette ´ etape dans la phase 1 en ajou- tant les variables voisines des variables ayant des va- leurs restaur´ ees dans la file de r´ evision Q AC (ligne 19).

Il est possible de prouver la correction de l’algo-

rithme DynVAC en montrant que cet algorithme four-

nit exactement une fermeture arc coh´ erente partielle

justifi´ ee de Bool(P ⁰ ) pour l’it´ eration suivante de VAC.

2 2 a

b

a b a b

a b x

x

x

x

1

1 1 1 w

= 0

(a) Probl` eme original (b) Bool(P ) (c) Phase 1

2 2

1 1

1 1 1 0

0 w

= 0

(d) Phase 2

1 1 2

1

1 1

1 1 w

= 0

1 2

1 1

1 1

1 w

= 0

1 1 1

1 1

1 w

= 1

(e) Phase 3

It´ eration 1

(f) Bool(P ) modifi´ e (g) Phase 1

1 1 1

1 1

1 1 1

1 w

= 1

(h) Phase 2

1

1 1 1 1 1

1 1 w

= 1

1 1

1

1

1 1

w

= 1

1 1

1

1 1

1 1 w

= 1

1

1 1

1 w

= 2

(i) Phase 3

It´ eration 2

Figure 1 – Exemple du fonctionnement de VAC dynamique durant les it´ erations Nous ne pr´ esentons pas la preuve dans cet article.

3.2 Exemple

L’avantage de DynVAC par rapport ` a VAC est que la liste des variables ` a r´ eviser utilis´ ee dans la phase 1 est maintenue pendant toutes les it´ erations, au lieu d’ˆ etre r´ einitialis´ ee ` a l’ensemble complet de toutes les variables X ` a chaque it´ eration, comme fait l’algo- rithme VAC de [6]. Ce fait, illustr´ e dans l’exemple sui- vant, permet d’´ eviter de r´ ep´ eter des filtrages inutiles.

Soit le CFN binaire de la Figure 1(a). Chaque va- riable a deux valeurs a et b, repr´ esent´ ees par des som- mets. Les coˆ uts unaires non nuls sont affich´ es ` a cˆ ot´ e des valeurs. Une arˆ ete entre deux sommets implique un coˆ ut binaire non nul de la paire correspondante.

Les coˆ uts nuls ne sont pas affich´ es. Dans Bool(P ) (Fi- gure 1(b)), les valeurs interdites sont barr´ ees et les arˆ etes repr´ esentent les paires interdites.

Supposons que les contraintes soient r´ evis´ ees dans la phase 1 dans l’ordre (w 13 , w 34 , w 12 , w 24 ). Apr` es avoir r´ evis´ e w 13 , w 34 , w 12 , les valeurs (3, a), (4, b) et (2, b) sont respectivement effac´ ees de Bool(P ). D` es que la variable 2 a un domaine vide, la phase 1 s’arrˆ ete (Fi- gure 1(c)). Les fl` eches en gris repr´ esentent la structure de donn´ ees tueur pointant sur la variable qui a caus´ e la perte de support valide. Dans la phase 2 (Figure 1(d)), l’effacement de (2, b) est suffisant pour produire un do- maine vide. w <sub>∅</sub> peut augmenter d’une quantit´ e de coˆ ut d’au maximum λ = 1 en utilisant les coˆ uts non nuls de w <sub>12</sub> (b, b) et w <sub>1</sub> (a). Les nombres en italique asso- ci´ es aux fl` eches indiquent la valeur correspondante de

k(i, a). En appliquant les EPT pr´ ec´ edemment identi- fi´ ees, la phase 3 (Figure 1(e)) transforme P en un pro- bl` eme ´ equivalent P ⁰ avec w _∅ ⁰ = 1. Les coˆ uts ´ etendus sont affich´ es en gras.

L’´ etablissement de VAC se poursuit car P ⁰ n’est pas encore VAC. Bool(P ⁰ ) n’est pas construit ` a partir de P <sup>0</sup> mais inf´ er´ e ` a partir de Bool(P). Pour mettre

`

a jour Bool(P ), au lieu de consid´ erer toutes les va- leurs effac´ ees, nous consid´ erons uniquement les va- leurs (1, a), (2, a) et (2, b) pour restauration car seule la contrainte w 12 a ´ et´ e modifi´ ee par des EPT dans la phase 3. Parmi les trois valeurs effac´ ees consid´ e- r´ ees, seule (2, b) est restaur´ ee car elle a un coˆ ut final nul et un nouveau support (b, b) dans w 12 . Cette res- tauration ne provoque aucune autre restauration. Les contraintes du probl` eme Bool(P <sup>0</sup> ) sont inf´ er´ ees direc- tement ` a partir des coˆ uts non nuls de P ^{0 2} . En fait, le r´ esultat de la mise ` a jour, tel que d´ ecrit dans la Figure 1(f), est d´ ej` a une fermeture arc coh´ erente par- tielle justifi´ ee de Bool(P ⁰ ), avec deux valeurs effac´ ees suppl´ ementaires (3, a) et (4, b), et les tueur associ´ es d´ e- finis. La phase 1 de l’it´ eration suivante peut d´ emarrer

`

a partir de ce probl` eme. (4, a) est effac´ ee apr` es la r´ evi- sion de w 24 et le domaine de la variable 4 devient vide (Figure 1(g)). La phase 2 et la phase 3 fonctionnent de la mˆ eme mani` ere qu’` a l’it´ eration pr´ ec´ edente. Le pro- bl` eme final (Figure 1(i)) avec w ⁰⁰ _∅ = 2 est VAC.

2. En pratique, aucune contrainte n’est cr´ e´ ee. On se contente

de tester la positivit´ e stricte du coˆ ut dans P

.

3.3 Maintien de VAC dynamique pendant la re- cherche

On peut maintenir VAC durant la recherche arbores- cente en maintenant le probl` eme Bool(P ), d´ efini par la liste des valeurs effac´ ees et leurs justifications, de ma- ni` ere incr´ ementale. Lors d’une affectation i = a, il est habituel de propager les fonctions binaires contenant i dans leur port´ ee et de les d´ econnecter du r´ eseau car la propagation en a extrait toute l’information. Dans Bool(P ), la valeur (i, a) s´ electionn´ ee pouvait ˆ etre effa- c´ ee par absence de support valide. Apr` es la suppression des fonctions binaires contenant i dans leur port´ ee, une telle valeur peut redevenir viable dans Bool(P ) et il faut donc envisager sa restauration. Lors d’une restriction de domaine (i 6= a, i > a ou i < a), des valeurs de variables voisines peuvent perdre leur sup- port, il faut donc refaire une partie de la propagation.

Au lieu de reconstruire Bool(P ) pour chaque nouveau nœud de l’arbre de recherche, le probl` eme Bool(P ) du nœud parent est mis ` a jour en ajoutant une variable af- fect´ ee dans la liste RL ou les variables r´ eduites dans la file de propagation Q _AC . En remontant dans l’arbre de recherche, la fermeture de Bool(P ) est reconstruite via la seule restauration des tueur qui ont ´ et´ e sauvegard´ es par “trailing”. En effet, dans une fermeture justifi´ ee, tueur [i, a] = null si et seulement si (i, a) n’a pas ´ et´ e effac´ ee.

Comme dans [6], afin d’acc´ el´ erer l’algorithme de VAC dynamique pendant le recherche, nous avons remplac´ e Bool(P ) par une version relax´ ee mais de plus en plus stricte, not´ ee Bool(P ) _θ , qui permet de collecter rapidement des contributions importantes au minorant w _∅ . Un n-uplet t est interdit dans Bool(P) _θ ssi son coˆ ut dans P est plus grand que θ. L’ensemble des coˆ uts binaires c _ij non nuls du probl` eme sont tri´ es dans un nombre fix´ e k de groupes en temps lin´ eaire (via l’uti- lisation d’un algorithme de type “bucket sort”). Les coˆ uts minimum de chaque groupe d´ efinissent une s´ e- quence de seuils (θ 1 , θ 2 , ...θ k ). En partant de θ 1 , les it´ e- rations de VAC fonctionnent avec un seuil fix´ e jusqu’` a ce qu’il n’y ait plus de domaine vide. On contraint alors le probl` eme en utilisant le seuil θ i+1 . Apr` es le dernier θ k , une strat´ egie g´ eom´ etrique, d´ efinie par θ i+1 = θ i /2, est utilis´ ee et s’arrˆ ete lorsque θ i est plus petit qu’une valeur T donn´ ee. Ce seuil T permet d’obtenir un al- gorithme qui se termine dans tous les cas. Dans VAC dynamique, le seuil θ est maintenu de mani` ere incr´ e- mentale pendant la recherche avec l’objectif d’h´ eriter du travail fait dans les nœuds parents. θ est ´ egalement sauvegard´ e/restaur´ e durant les backtracks par “trai- ling”.

3.4 Complexit´ e

DynVAC a la mˆ eme complexit´ e spatiale que VAC, en O(ed). L’´ etape initialisation a une complexit´ e en temps de O(nd) parce qu’il y a au maximum n × d valeurs ayant un coˆ ut strictement positif (ligne 5, Al- gorithme 3). La complexit´ e en temps dans le pire des cas de l’´ etape “propagation” est en O(ed ² ) parce que chaque paire de valeurs de chaque contrainte est tes- t´ ee au maximum une fois (ligne 17, 18, Algorithme 3).

Donc, la mise ` a jour de Bool(P ) a la mˆ eme complexit´ e en temps que la phase 3 de VAC : O(ed ² ). En cons´ e- quence, chaque it´ eration de DynVAC a une complexit´ e en temps en O(ed ² ) comme VAC, tant qu’un algo- rithme AC optimal est utilis´ e dans la phase 1.

Bien que DynVAC n’am´ eliore pas la complexit´ e asymptotique de VAC, les exp´ erimentations pr´ esent´ ees dans la prochaine section montrent qu’il peut fournir des acc´ el´ erations importantes en pratique.

4 Exp´ erimentations

Dans cette section, nous comparons l’efficacit´ e de DynVAC ` a VAC que ce soit en pr´ e-traitement ou maintenu pendant la recherche, sur un ensemble de probl` emes extraits de la “Cost Function Library” ³ . Les exp´ erimentations sont impl´ ement´ ees dans le sol- veur toulbar2 et ex´ ecut´ ees sur un processeur Intel(R) Core(TM)2@2.66GHz avec 4GB de RAM. Comme dans [5,6], pour chaque probl` eme, nous ´ etablissons une version limit´ ee de VAC qui s’arrˆ ete d` es que l’augmen- tation de w _∅ reste plus petite qu’une valeur ε donn´ ee sur un nombre donn´ e d’it´ erations successives. Nous avons fix´ e ε = 0.05 pour les exp´ erimentations de pr´ e- traitement (Table 1) tandis que dans les exp´ erimenta- tions en recherche (Table 2) ε = ₁₀₀₀₀ ¹ ` a la racine de l’arbre de recherche et ε = 0.1 pendant la recherche.

Pour le simple pr´ e-traitement des probl` emes, comme esp´ er´ e, DynVAC est plus rapide que VAC sur une large partie des instances extraites de l’entrepˆ ot CFLib. La table 1 affiche les moyennes du temps total (en se- condes), du minorant (lb) et du nombre d’it´ erations (iter) pour l’´ etablissement de VAC en utilisant l’al- gorithme VAC statique usuel et le nouvel algorithme DynVAC. Chaque ligne correspond ` a une classe de

#inst probl` emes. Le meilleur temps ou minorant est indiqu´ e ` a chaque fois en gras. Les exp´ erimentations montrent que DynVAC est respectivement 1,6, 3 et 5 fois plus rapide que VAC pour les classes celar, tagsnp, warehouse tandis qu’il fournit des minorants de mˆ eme qualit´ e. Nous observons que le nombre d’it´ erations en moyenne de DynVAC peut augmenter par rapport ` a

3. https ://mulcyber.toulouse.inra.fr/scm/viewvc.php/

trunk/ ?root=costfunctionlib

Table 1 – Les valeurs du minorant, le temps, et le nombre d’it´ erations de VAC n´ ecessaires pour traiter des probl` emes r´ eels et fabriqu´ es de la “Cost Function Library”.

classe #inst VAC

DynVAC

DynVAC

avec heuristique

lb temps iter lb temps iter lb temps iter

celar 32 6.180 3,14 382 6.204 1,92 418 5.892 1,12 319

prot maxclique 10 1.016 51,00 1.022 1.016 364,00 1.022 1.016 56,95 1.022 tagsnp r0.5 25 1,43×10

364,31 8.798 1,43×10

116,57 4.653 1,43×10

81,46 5.810 tagsnp r0.8 82 1,11×10

4,64 155 1,11×10

1,53 120 1,11×10

2,54 150

dimacs maxclique 65 266 0,78 284 266 3,65 284 266 0,96 284

planning 68 1.074 0,25 46 1.074 0,19 50 1.072 0,23 76

warehouse 57 7,23×10

341,00 946 7,24×10

66,00 719 7,25×10

114,17 790

celui de VAC. Mais le temps total en moyenne diminue comme esp´ er´ e : il y a moins de travail ` a faire ` a chaque it´ eration dans DynVAC parce que les effacements de valeurs sont h´ erit´ es des it´ erations pr´ ec´ edentes. Notez que le minorant final obtenu par DynVAC et VAC n’est pas obligatoirement identique. Apr` es la premi` ere it´ era- tion, VAC et DynVAC peuvent r´ eviser les contraintes dans un ordre diff´ erent dans la phase 1 menant ` a des s´ equences d’EPT diff´ erentes. Le crit` ere d’arrˆ et peut alors agir diff´ eremment selon les cas.

N´ eanmoins, DynVAC est plus lent que VAC (7 et 4 fois respectivement) pour toutes les cat´ egories des probl` emes de type “clique maximum” test´ ees : protein maxclique et dimacs maxclique. Ces probl` emes ont une structure sp´ ecifique avec des domaines boo- l´ eens, des contraintes de diff´ erence binaires et des fonc- tions de coˆ ut (non dures) seulement au niveau unaire.

Du fait de cette structure sp´ ecifique, chaque it´ eration restaure de nombreuses valeurs en cascade mais de fa¸ con inutile, car elles vont ˆ etre ` a nouveau effac´ ees, pour une autre raison, dans l’it´ eration suivante. Afin d’am´ eliorer l’efficacit´ e de DynVAC sur ces probl` emes d´ efavorables, nous avons utilis´ e une heuristique d’or- donnancement des r´ evisions orient´ ee variable, propo- s´ ee dans [12]. Nous l’appliquons durant l’´ etablissement de AC dans la phase 1. L’heuristique s´ electionne pre- mi` erement dans la file Q <sub>AC</sub> la variable dont la taille de domaine est la plus petite dans Bool(P ). Ensuite, les contraintes sont trait´ ees en ordre ascendant en terme de la taille des domaines des variables oppos´ ees. Le r´ e- sultat obtenu, pr´ esent´ e dans la derni` ere colonne de la table 1, montre que cette heuristique permet d’am´ elio- rer consid´ erablement la performance de DynVAC sur les probl` emes de type “clique maximum”. L’heuristique int´ egr´ ee dans DynVAC fournit une performance com- parable ` a celle de VAC statique dans ces cas extrˆ eme- ment d´ efavorables (20% de d´ epassement en temps qui est probablement caus´ e par le calcul de l’heuristique).

Finalement, nous testons les performances de Dyn- VAC et VAC lorsqu’elles sont maintenues pendant la

recherche d’une solution de coˆ ut optimal, sur des pro- bl` emes d’affectation de fr´ equence (celar, [4]) et des probl` emes d’affectation d’entrepˆ ots (uncapacited wa- rehouse location problems warehouse, [9]). Ces pro- bl` emes, qui ont ´ et´ e d´ ej` a utilis´ es pour l’´ evaluation de VAC dans [6], sont issus de probl` emes difficiles, de taille parfois importante et poss` edent de grands do- maines, ce qui constitue sans doute un terrain de pr´ e- dilection pour DynVAC. Sur ces probl` emes, VAC est effectivement domin´ e par DynVAC au niveau du pr´ e- traitement. La table 2 affiche le temps (en secondes) et le nombre de nœuds visit´ es durant la recherche, jus- qu’` a l’obtention et la preuve d’une solution optimale, en utilisant VAC statique ou DynVAC. La derni` ere colonne pr´ esente le ratio de temps CPU de DynVAC par rapport ` a celui de VAC. Comme dans le cas du pr´ e-traitement, VAC dynamique continue ` a ˆ etre plus efficace sur la plupart des instances de ces classes. Il est en moyenne 40% plus rapide que VAC et visite 18%

de moins de nœuds sur des instances celar (correspon- dant ` a la section en haut de la table). Cependant, il y a quelques instances celar qui sont plus longues ` a r´ esoudre avec DynVAC. Le r´ esultat est encore plus vi- sible avec la classe warehouse o` u DynVAC est de 2 ` a 5 fois plus rapide que VAC, sur toutes les instances de cette classe (sauf pour “capb”) en visitant souvent un peu moins de nœuds.

5 Conclusion

Cet article pr´ esente une approche incr´ ementale pour l’´ etablissement de VAC dans les r´ eseaux de fonc- tions de coˆ ut. Notre approche combine l’id´ ee des algo- rithmes d’arc consistance dynamique avec l’algorithme it´ eratif VAC afin de maintenir efficacement la coh´ e- rence d’arc dans le CSP Bool(P ) durant l’´ etablisse- ment de VAC.

Le nouvel algorithme fournit un minorant de mˆ eme

qualit´ e qu’avec l’algorithme VAC statique mais il est

plus efficace sur de nombreux probl` emes, particuli` e-

Table 2 – R´ esultats de DynVAC et VAC pendant la recherche sur un sous-ensemble des instances.

VAC

DynVAC

ratio

temps nœuds temps nœuds temps

cl6-1-24 12 9.686 18 13.962 1,5

cl6-1 26 14.871 38 17.131 1,46

cl6-2 29 11.228 46 13.081 1,59

cl6-3 161 54.083 133 35.614 0,83 cl6-4

160 47.646 138 30.399 0,86 cl6-4 210 52.724 270 47.806 1,29

cl7-1 194 17.951 84 8.733 0,43

cl7-2 1.076 33.415 773 33.545 0,72 cl7-3 4.983 142.755 2.979 85.626 0,6 cl7-4 9.193 380.566 7.426 207.207 0,81

gr11

6 618 5 639 0,83

gr11 470 6.600 366 4.292 0,78

gr13

34 50 20 11 0,59

gr13 1.431 5.921 1.144 3.022 0,8 sc06-16

884 142.740 625 170.851 0,71

sc06-16 1.873 283.872 1.052 290.993 0,56 sc06-18

677 143.386 360 118.060 0,53 sc06-18 1.511 276.610 736 213.282 0,49 sc06-20

595 125.674 358 124.856 0,6

sc06-20 765 130.260 508 164.515 0,66 sc06-22

374 96.270 177 79.211 0,47 sc06-22 433 91.202 235 74.481 0,54 sc06-24

156 45.558 81 36.407 0,52 sc06-24 165 40.045 89 37.170 0,54

sc06-30

5 1826 3 1.697 0,6

sc06-30 14 6.990 10 6.184 0,71

sc06

3.629 310.034 2.183 270.387 0,6 sc06 5.227 347.925 2.454 275.992 0,47 capa 2.462 1.100 1.013 1.101 0,41 capb 3.019 1.350 6.168 1.826 2,04 capc 2.027 1.650 1.228 1.233 0,61

capmo1 123 2.254 95 2.671 0,77

capmo2 64 407 21 328 0,33

capmo3 93 1.105 32 993 0,34

capmo4 74 846 18 574 0,24

capmo5 75 412 14 305 0,19

capmp1 1.573 3.030 920 3.554 0,58 capmp2 1.063 1.611 452 2.130 0,43 capmp3 1.123 1.454 443 1.474 0,39 capmp4 1.340 2.585 680 1.518 0,51

capmp5 984 1.932 311 1.541 0,32

capmq1 5.111 3.546 2.374 2.419 0,46 capmq2 6.520 4.408 3.209 4.633 0,49 capmq3 6.310 3.943 2.743 3.115 0,43 capmq4 7.530 7.208 4.295 6.124 0,57 capmq5 13.938 13.980 7.219 11.629 0,52

rement sur les probl` emes avec coˆ uts ´ elev´ es et grands domaines. Cependant, DynVAC peut ˆ etre ralenti pour certains probl` emes sp´ ecifiques comme les probl` emes de la classe clique maximum. L’int´ egration d’une heuris- tique de r´ evision orient´ ee variable dans l’algorithme AC permet d’´ eviter ce comportement pathologique.

Dans l’avenir, nous comptons ´ etendre DynVAC aux fonctions de coˆ ut d’arit´ e arbitraire et identifier des heuristiques de r´ evision appropri´ ees qui pourraient am´ eliorer la performance de DynVAC et en mˆ eme temps am´ eliorer le minorant produit.

R´ ef´ erences

[1] Roman Bart´ ak and Pavel Surynek. An impro- ved algorithm for maintaining arc consistency in dynamic constraint satisfaction problems. In Proc. of the 18 ^th International FLAIRS Confe- rence, pages 161–166, Menlo Park, CA, USA, 2005. AAAI Press.

[2] P. Berlandier and B. Neveu. Maintaining Arc Consistency through Constraint Retraction. In Proc. of the 6 ^th IEEE International Conference on Tools with Artificial Intelligence (TAI94), New Orleans, LA, 1994.

[3] Christian Bessi` ere. Arc-consistency in dynamic constraint satisfaction problems. In Proc. of AAAI’91, pages 221–226, Anaheim, CA, 1991.

[4] B. Cabon, S. de Givry, L. Lobjois, T. Schiex, and J.P. Warners. Radio link frequency assignment.

Constraints Journal, 4 :79–89, 1999.

[5] M Cooper, S de Givry, M Sanchez, T Schiex, and M Zytnicki. Virtual Arc Consistency for Weigh- ted CSP. In Proc. of AAAI’2008, Chicago, USA.

[6] M. Cooper, S. de Givry, M. Sanchez, T. Schiex, M. Zytnicki, and T. Werner. Soft arc consistency revisited. Artificial Intelligence, 174 :449–478, 2010.

[7] M C. Cooper and T. Schiex. Arc consistency for soft constraints. Artificial Intelligence, 154(1- 2) :199–227, 2004.

[8] Rina Dechter and Avi Dechter. Belief mainte- nance in dynamic constraint networks. In Proc.

of AAAI’88, pages 37–42, St. Paul, MN, 1988.

[9] J. Kratica, D. Tosic, V. Filipovic, and I. Ljubic.

Solving the Simple Plant Location Problems by Genetic Algorithm. RAIRO Operations Research, 35 :127–142, 2001.

[10] J. Larrosa, S. de Givry, F. Heras, and M. Zytnicki.

Existential arc consistency : getting closer to full

arc consistency in weighted CSPs. In Proc. of the

19 ^th IJCAI, pages 84–89, Edinburgh, Scotland,

August 2005.

[11] T. Schiex, H. Fargier, and G. Verfaillie. Valued constraint satisfaction problems : hard and easy problems. In Proc. of the 14 ^th IJCAI, pages 631–

637, Montr´ eal, Canada, August 1995.

[12] R.J. Wallace and E.C. Freuder. Ordering heuris- tics for arc consistency algorithms. In Proceedings of the Biennial Conference-Canadian Society for Computational Studies of Intelligence, pages 163–

163, 1992.