Ar-Consisteny for Non-Binry Dynmi CSPs Christin Bessière LIRMM (UMR C 9928 CNRS / Université Montpellier II) 860, rue de Sint Priest 34090 Montpellier, Frne Emil: essiere@rim.fr Astrt. Constrint stisftion prolems (CSPs) provide model often used in Artifiil Intelligene. Sine the prolem of the existene of solution in CSP is n NP-omplete tsk, mny filtering tehniques hve een developed for CSPs. The most used filtering tehniques re those hieving r-onsisteny. Nevertheless, mny resoning prolems in AI need to e expressed in dynmi environment nd lmost ll the tehniques lredy developed to solve CSPs del only with stti CSPs. So, in this pper, we first rell wht we nme dynmi CSP, nd then, generlize the inrementl lgorithm hieving r-onsisteny on inry dynmi CSPs to generl dynmi CSPs. Like for the inry version of this lgorithm, there is n dvntge to use our speifi lgorithm for dynmi CSPs insted of the est stti one, GAC4. 1. Introdution Constrint stisftion prolems (CSPs) provide simple nd good frmework to enode systems of onstrints nd re widely used to express stti prolems. Nevertheless, mny prolems in Artifiil Intelligene involve resoning in dynmi environments. For instne, in design proess, the designer my dd onstrints to speify further the prolem, or relx onstrints when there re no more solutions (see the system to design peptide synthesis plns: SYNTHIA [1]). Every time onstrint hs een dded or removed we need to hek if there still exist solutions in the CSP. Proving the existene of solutions or finding solution in CSP re NP-omplete tsks. So, filtering step is often pplied to CSPs efore serhing solutions. The most used filtering lgorithms re those hieving r-onsisteny. Almost ll r-onsisteny lgorithms re written for stti CSPs. So, if we dd or retrt onstrints in CSP nd hieve r-onsisteny fter eh modifition with one of these lgorithms, we will proly do mny times lmost the sme work. The only r-onsisteny lgorithm written for dynmi CSPs, DnAC-4 in [2], dels only with inry CSPs. So, in this pper we rell tht Dynmi CSP (DCSP) is sequene of stti CSPs eh resulting from the ddition or retrtion of onstrint in the preeding one ([3], [2]). We propose generlized version of DnAC-4 to mintin r-onsisteny in generl DCSPs whih outperforms those written for stti CSPs. The pper is orgnized s follows. Setion 2 presents the CSP model (2.1) nd defines wht is Dynmi CSP (2.2). Ar-onsisteny filtering method is introdued nd the est lgorithm hieving it (GAC4 in [4]) is desried (2.3). Why this lgorithm is not optiml in DCSPs is underlined in 2.4. Setion 3 presents new method whih dpts the ide of GAC4 to reh etter performnes on DCSPs. Setion 4 ontins summry nd some finl remrks. 2. Definitions nd preliminries 2.1. Constrint Stisftion Prolems A stti onstrint stisftion prolem (CSP) (X, dom, ) involves set of n vriles, X={i, j }, eh tking vlue in its respetive domin, dom(i), dom(j),, elements of dom, nd set of onstrints. A onstrint C p (i 1,,i q ) onstrining the suset {i 1,...,i q } of X is suset of the Crtesin produt dom(i 1 )x xdom(i q ), tht speifies whih vlues of the vriles re omptile with eh other. A onstrint is usully represented y the set of ll tuples whih re not foridden y it. A solution of CSP is n ssignment of vlues to ll the vriles suh tht ll the onstrints re stisfied. The tsk, in CSP, is to find one, or ll the solutions. Consider for instne the CSP presented in fig. 1. Eh node represents vrile whose vlues re expliitly indited. Eh onstrint is expliitly given y the list of its dmissile tuples (C 1 nd C 5 re strit lexiogrphi order long the rrows nd C 2, C 3, C 4 re equlity onstrints). 1 6 C1 C5 C2 2 C4 C3 5 3 4 C1 1 2 C4 2 5 C2 2 3 C 5 6 2 Figure 1: An exmple of CSP C3 3 4 5
2.2. Dynmi Constrint Stisftion Prolems A dynmi onstrint stisftion prolem (DCSP) p is sequene of stti CSPs p (0),...p (α), p (α+1),..., eh resulting from hnge in the preeding one imposed y "the outside world". This hnge n e restrition ( new onstrint is imposed on suset of vriles) or relxtion ( onstrint whih ws present in the CSP is removed euse it is no longer interesting or euse the urrent CSP hs no solution). So, if we hve p (α) =(X, dom, (α) ), we will hve p (α+1) =(X, dom, (α+1) ) where (α+1) = (α) ± C, C eing onstrint. p (0) =(X, dom, ). 2.3. Ar-onsisteny The tsk of finding solutions in CSP hs een treted y severl uthors, nd sine the prolem is NPomplete, some of them hve suggested tht preproessing or filtering step e pplied efore the serh (or ktrking) proedures. Then, onsisteny lgorithms were proposed ([5], [6], [7]). These lgorithms do not solve CSP ompletely ut they eliminte one nd for ll lol inonsistenies tht nnot prtiipte in ny solutions. These inonsistenies would otherwise hve een repetedly disovered y most ktrking proedures. The most widely used onsisteny lgorithms re those hieving r-onsisteny. Definition. A tuple u in onstrint C p is vile iff for ll vrile i onstrined y C p, u[i] is vile vlue. A vlue for vrile i is vile iff for ll onstrint C p onstrining i there exists vile tuple u in C p suh tht u[i]=. A CSP is ronsistent iff for ll i X, for ll dom(i), is vile. The omplexity of the est lgorithm uilding the lrgest r-onsistent domin in generl CSPs (GAC4 in [4]) is O(K) with K the sum of the lengths of ll tuples for ll onstrints. It hs een shown tht it is n optiml lgorithm. The effiieny of GAC4 omes from the dt struture it hndles whih is suitle to the r-onsisteny property. Ar-onsisteny n e seen s sed on the notion of support. A vlue for the vrile i is vile if there exists t lest one tuple whih "supports" it t eh onstrint. GAC4 mkes this support evident y ssigning set of supports to eh onstrint-vlue pir. The sets designed y S ip ontin the tuples in C p tht support the vlue for the vrile i. The lgorithm is founded on reursive vlue pruning, deleting vlue when it hs no support on onstrint, nd then removing t their turn ll tuples inluding this vlue. And so on until ll remining vlues hve support on ll the onstrints. So, the CSP is r-onsistent. And it is the mximl r-onsistent domin. 2.4. Ar-onsisteny in DCSPs Mohr's nd Msini's lgorithm, GAC4, n e used in DCSPs. It keeps ll its goods properties when we do restrition, strting filtering from the urrent ronsistent domin nd pruning new vlue when one of its support sets is empty fter ddition of onstrints. But, when we remove onstrint (mking relxtion), GAC4 nnot find whih vlue must e put k nd whih one must not: s it hs "forgotten" the reson why vlue hs een removed, it nnot mke the opposite propgtion it hs done during restritions. So, we hve to strt filtering from the initil domin. 3. The inrementl method 3.1. Introdution As we hve seen ove, GAC4 does not hve good properties (inrementlity) for proessing relxtions. So, in this setion, we propose DnGAC4, new ronsisteny lgorithm for DCSPs. In DnGAC4 we extend GAC4 y reording some informtions during restritions while keeping its good properties. Then, DnGAC4 remins inrementl for relxtions. More preisely, during restrition, for every vlue deleted, we keep trk of the onstrint origin of the deletion s the "justifition" of the vlue deleted. The justifition is the first onstrint on whih the vlue is without support. For every tuple deleted, we keep trk of the vlue origin of its deletion s the "killer" of the tuple deleted. The killer is the first vlue retrted in the tuple. During relxtion, with the help of justifitions nd killers, we n inrementlly dd to the urrent domin vlues whih elong to the new mximl r-onsistent domin. But we need to e reful euse fter the relxtion the system must e in the sme stte s if the lgorithm hd strted with the initil CSP p (0) nd hd done only restritions with ll the new set of onstrints: the set of justifitions nd killers must remin well-founded to ensure tht the new domin is the mximl r-onsistent domin. Definition. Justifitions nd killers re wellfounded iff in ny set E of retrted vlues there exists vlue (i, ) suh tht, its justifition eing the onstrint C p, every tuple of C p inluding (i, ) hs its killer out of E. In other words, well-foundness mens tht every removed vlue is justified y non-yli hin of justifitions nd killers. The vlue is not reorded s one of the resons of its self deletion.
3.2. The lgorithm DnGAC4 The lgorithm we propose works with the following dt strutures: tle D of oolens keeps trk of whih vlues re in the urrent domin or not (the urrent domin eing nmed D we onfuse (i, ) D nd D(i, )=true) set of supports for eh vlue on eh onstrint: S ip ={u C p /(i, ) u nd u is vile} for eh vlue, the onstrint origin of its deletion is stored in justif(i, ). if (i, ) is vile, justif(i, )=nil else justif(i, )=the numer of the first onstrint on whih (i, ) hd got n empty support. for eh tuple, we store in killer(u) the first vlue deleted in it. if u is vile, killer(u)=nil else killer(u)=the first vlue in u retrted from D. set of killed tuples for eh vlue on eh onstrint: T ip ={u C p /killer(u)=(i, )} the lists SL nd RL respetively ontrol the propgtion of deletions nd dditions of vlues long the onstrints; the list UL reords for reonsidertion the tuples put k to ensure well-foundness ut tht still hve killer. Before giving the lgorithms, we define the funtion find-killer whih will e used in the following. funtion find-killer(u: tuple): vlue; return (j, ) u /D(j, )=flse else return nil When the lgorithm strts with p (0), the tles re initilized: for ll (i, ) dom do D(i, ), true; justif(i, ), nil ; Add onstrint C p to the DCSP is done y lling the proedure Add. proedure Add (C p (i 1,,i q ): onstrint); Put C p (i 1,,i q ) in ; SL, ; Init-Add (C p (i 1,,i q ), SL ); Propg-Suppress (SL ); the proedure Init-Add retes lists S ip nd T ip for ll (i, ) suh tht i is onstrined y C p. It updtes killer for ll tuple u in C p, dding u in ll S jp suh tht (j, ) u if u is vile or in T killer(u)p if not. All (i,, p) without support (S ip = ) re dded to SL. proedure Init-Add (in C p (i 1,,i q ): onstrint; in out SL: list); 1 for ll i {i 1,,i q } do 2 for ll dom(i ) do S ip, ; T ip, 3 for ll u C p do 4 killer(u ), find-killer(u ); 5 if killer(u ) = nil then 6 for ll (j, ) u do Append(S jp, u ); 7 else Append(T killer(u)p, u ) 8 for ll i {i 1,,i q } do 9 for ll dom(i ) do 10 if D(i, ) nd S ip = then Append(SL, (i,, p )); the proedure Propg-Suppress tkes onstrint-vlue pirs (i,, m) in SL, removes (i, ) from D, updtes justif(i, ) nd lso killer(u) for ll u vile suh tht (i, ) u. These tuples u re dded to T ip nd removed from ll S jp whih they were elonging. If S jp eomes empty, (j,, p) is dded in SL. And so on. proedure Propg-Suppress (in out SL: list); 1 while SL do 2 keep(sl, (i,, m )); 3 if D(i, ) nd S im = then 4 justif(i, ), m ; 5 D(i, ), flse; 6 for ll C p in onstrining i do 7 for ll u S ip do 8 killer(u ), (i, ); Append(T ip, u ); 9 for ll (j, ) u do 10 Suppress(S jp, u ); 11 if D(j, ) nd S jp = then Append(SL, (j,, p )); To retrt the onstrint C m (i 1,,i q ) from the DCSP we ll the proedure Relx. proedure Relx (C m (i 1,,i q ): onstrint); SL, ; Init-Propg-Relx (C m (i 1,,i q ), SL ); Propg-Suppress (SL ) Two prts re needed in the relxtion proess to mintin the well-founded property. prt 1. first, the proedure Init-Propg-Relx dds to D nd puts in RL ll vlues (i, ) for whih deletion ws justified y C m (i.e. justif(i, )=m). In seond step, the onsequenes of the ddition of these vlues (i, ) to D re propgted. Tuples u deleted y them (killer(u)=(i, )) re put k in the supports lists S jp of vlues (j, ) tht they support (lines 13-15), exept if there is nother vlue of u for whih we re sure tht retrtion is independnt of u's retrtion (lines 10-12). At eh tuple put k, we dd in D nd in RL every (j, ) whih hs the supports set S jp tht eomes non empty on its justifition onstrint (p=justif(j, )) (line 16). Additions of vlues re reursively propgted: this seond step proesses while RL is non empty. In this seond step, if tuple is dded when it
inludes vlues not in D euse we re not sure of the independne of the retrtion of these vlues, we dd it in list UL whih reords these "suspended" tuples (line 17). In the third step, we hek if these suspended tuples re relly sved (their killers were not independent, they hd not well-founded justifition) or if their killers re still present. In this ltter se, we kill gin the tuple nd remove it from the supports sets of the vlues it supports. During ll the proedure Init-Propg-Relx, eh time support set S jp of n dded vlue (j, ) is found empty, we put the onstrint-vlue pir (j,, p) in SL. proedure Init-Propg-Relx (in C m (i 1,,i q ): onstrint; in out SL: list); {Step 1: vlues with justifition equl to C m re dded to D nd put in RL for propgtion} 1 RL, ; 2 for ll i {i 1,,i q } do 3 for ll dom(i ) do 4 if justif(i, )=m then Append(RL, (i, )); justif(i, ), nil; D(i, ), true 5 Remove C m from ; {Step 2: onsequenes of the ddition to D of the vlues in RL re propgted } 6 while RL do 7 keep (RL, (i, )); 8 for ll C p in onstrining i do 9 for ll u T ip do 10 if u!d nd ( (j, ) u, justif(j, ) p) then 11 killer(u), find-killer(u); 12 Append(T killer(u)p, u ) else 13 killer(u ), nil; 14 for ll (j, ) u do 15 Append(S jp, u ); 16 if justif(j, )=p then Append(RL, (j, )); justif(j, ), nil; D(j, ), true 17 if u!d then Append(UL, u ); 18 T ip, ; 19 if S ip = then Append(SL, (i,, p )); {endwhile} {Step 3: "suspended" tuples re heked } 20 while UL do 21 keep(ul, u ); { let C p eing the onstrint inluding u } 22 killer(u ), find-killer(u ); 23 if killer(u ) nil then 24 Append(T killer(u)p, u ); 25 for ll (j, ) u do 26 Suppress(S jp, u ); 27 if D(j, ) nd S jp = then Append(SL, (j,, p )) prt 2. Propg-Suppress tkes onstrint-vlue pirs (i,, m) in SL nd removes gin from D vlues (i, ) whih still re without support on the onstrint C m (S im = ). These retrtions re propgted on the tuples nd on the other vlues: the lssi ronsisteny proess restrts. We develop here DnGAC4 on the DCSP of fig.1, to show the mehnism of justifitions nd killers (nottion: u pq is the qth tuple of the onstrint C p ). Add C 1. (2, ) nd (2, ) deleted: justif(2, ),1 nd justif(2, ),1 Add C 2. killer(u 21 ),(2, ) nd killer(u 22 ),(2, ). (3, ) nd (3, ) deleted: justif(3, ),2 ; justif(3, ),2 Add C 3. killer(u 31 ),(3, ) nd killer(u 32 ),(3, ). (4, ), (4, ), (5, ), (5, ) deleted: justif(4, ),3; justif(4, ),3; justif(5, ),3; justif(5, ),3 Add C 4. Add C 5. killer(u 41 ),(2, ) nd killer(u 42 ),(2, ). killer(u 51 ),(2, ). Relx C 1. (2, ) nd (2, ) re dded euse justif(2, )=1 nd justif(2, )=1. All tuples killed y (2, ) nd (2, ) re exmined. u 21, u 22, u 51 re restored ut not u 41 nd u 42 euse we n find nother killer for them without losing well-foundness. So, new killers re reorded: killer(u 41 ),(5, ) nd killer(u 42 ),(5, ). (2, ) nd (2, ) re without support on C 4 so we dd them to SL. The onsequene of u 21 nd u 22 rehilittion is the ddition of (3, ) nd (3, ) to D. So, u 31 nd u 32 re restored nd (4, ), (4, ), (5, ) nd (5, ) re dded to D. Then, u 41 nd u 42 re restored. The first prt of the relxtion proess is finished. The seond prt is the lssil r-onsisteny proess, exmining vlues in SL nd propgting deletions. (2, ) is in SL ut hs now support on C 4 so nothing is done. (2, ) is without support on C 5 so it is disrded nd justif(2, ),5. So, killer(u 21 ),(2, ) nd killer(u 41 ),(2, ). Then, (3, ) nd (5, ) re disrded (justif(3, ),2, justif(5, ),4). Then, killer(u 31 ),(3, ) nd (4, ) is disrded (justif(4, ),3). We hve the new mximl ronsistent domin. 3.3. Corretness of DnGAC4 We give here the properties true fter eh proedure of DnGAC4 whih re needed to prove the orretness of the lgorithm. For omplete proof we will see [8]. Bsi properties. (1) S ip ={u C p / (i, ) u nd u D} (2) T ip ={u C p / (i, )=killer(u)} Justifitions nd killers properties. (3) justif(i, )=p (i, ) D nd S ip = (4) {(i, ) D / justif(i, )=nil}=
(5) {(i,, p)/ S ip = nd (i, ) D} SL (6) killer(u)=(i, ) (i, ) u nd (i, ) D (7) u! D killer(u) nil (8) E dom\d: (i, ) E: justif(i, )=p nd u C p /(i, ) u: killer(u) E {well-founded property} From (5) we n dedue tht D is r-onsistent t the end of Propg-Suppress, so t the end of Add or Relx too. From Propg-Suppress onstrution we n see tht if D inludes the mximl r-onsistent domin t its egining, this remins true t its end. Now, we need only to prove tht when Propg-Suppress egins, we lwys hve D inluding the mximl r-onsistent domin. It is evident in Add, nd for Relx, we n prove this using properties (6), (7), (8) nd looking Init- Propg-Relx onstrution. 3.4. Complexity of DnGAC4 In DnGAC4, the igger dt strutures re the S ip nd T ip lists of tuples. They tke the sme spe s ll the onstrints C p in the CSP. This spe is liner in the sum of the lengths of ll the tuples of ll the onstrints (it is liner in the size of the prolem). The upper ound time omplexity of DnGAC4, like in GAC4, is liner in the size of the prolem sine the tomi opertions re first Append(S ip, u), nd then Suppress(S ip, u) (the totl size of the S ip sets eing ounded y the size of the prolem). But these opertions must e proessed in onstnt time. A suitle dt struture is shown in [4]. If we wnt to speify the omplexity of DnGAC4, we n sy tht, on one hnd, during restrition, DnGAC4 does little more proessing thn GAC4, uilding more omplex dt struture (for eh tuple killer is stored, nd for eh vlue we reord justifition). On the other hnd, during relxtion, DnGAC4 only heks vlues nd tuples needed to verify the wellfounded property of justifitions nd killers. GAC4 hndles ll the new CSP. 3.5. Performne omprison There re too mny prmeters in generl DCSPs to provide signifint tests on rndomly generted DCSPs ut it seems tht DnGAC4 on generl DCSPs works t lest s etter s DnAC-4 on inry DCSPs. If DnGAC4 is pplied on CSPs ontining only ternry onstrints, we n see tht it generlly outperforms GAC4 fter the first relxtion of onstrint, rehing gin of 35% (verge of the lsses of CSPs tested) on the sum of the running time of ll restritions plus the relxtion. More, if we modify the DCSP severl times, dding nd removing onstrints until we find "good" onsistent CSP (wht is done in ll design prolems) we remrk tht the gin of DnGAC4 fstly grows nd overtops 50% fter two or three relxtions. More hnges will e done, more the use of DnGAC4 will e interesting. DnGAC4 is now under implementtion on SYNTHIA [1]. 4. Conlusion We hve defined wht we ll Dynmi CSPs nd hve underlined tht there does not exist lgorithms inrementlly mintining r-onsisteny in generl DCSPs (there exists one only for inry DCSPs). We hve notied tht r-onsisteny is the most used filtering tehnique in CSPs, nd so, it is importnt to hve n inrementl lgorithm for ll DCSPs. Then, we hve provided n effiient lgorithm (DnGAC4) inrementlly hieving r-onsisteny in generl DCSPs. DnGAC4 n e useful for mny systems whih work in dynmi environment. Aknowledgements I would like to thnk prtiulrly Mrie-Ctherine Vilrem for the implementtion of my work on SYNTHIA nd Philippe Dvid who gives me onstrutive suggestions for the finl drft. Referenes [1] P. Jnssen, P. Jégou, B. Nouguier, M.C. Vilrem, B. Cstro: "Synthi: Assisted design of peptide synthesis plns"; New Journl of Chemistry, 14-12, 1990, 969-976 [2] C. Bessière: "Ar-Consisteny in Dynmi Constrint Stisftion Prolems"; Proeedings AAAI-91, Anheim CA, 221-226 [3] R. Dehter, A. Dehter: "Belief Mintenne in Dynmi Constrint Networks"; Proeedings AAAI-88, St Pul MN, 37-42 [4] R. Mohr, G. Msini: "Good Old Disrete Relxtion"; Proeedings ECAI-88, Münhen, FRG, 651-656 [5] U. Montnri: "Networks of Constrints: Fundmentl Properties nd Applitions to Piture Proessing"; Informtion Siene 7 (1974), 95-132 [6] A.K. Mkworth: "Consisteny in Networks of Reltions"; Artifiil Intelligene 8 (1977) 99-118 [7] E.C. Freuder: "Synthesizing Constrint Expressions"; Communitions of the ACM Nov. 1978 Vol.21 No.11, 958-966 [8] C. Bessière: "Algorithmes d'r-onsistne pour les CSP dynmiques"; Teh.Rep. 91-086, LIRMM Montpellier II, Frne, August 1991 (in Frenh)