Constrained Decision Diagrams
Kenil C.K. Cheng and Roland H.C. Yap National University of Singapore 3 Science Drive 2, Singapore {chengchi,ryap}@comp.nus.edu.sg
Abstract site approach is to use an explicit representation where data structures are used to compress the solution set directly, i.e. A general n-ary constraint is usually represented explicitly as a set of its solution tuples, which may need exponential suffix or prefix sharing. These might not be practical when space. In this paper, we introduce a new representation for the solution set is huge (since its explicit) or difficult to com- general n-ary constraints called Constrained Decision Di- press. agram (CDD). CDD generalizes BDD-style representations In this paper, we introduce a new representation for so- and the main feature is that it combines constraint reason- lution sets and general n-ary constraints, called Constrained ing/consistency techniques with a compact data structure. We Decision Diagram (CDD). CDD is a hybrid which combines present an application of CDD for recording all solutions of the strengths of implicit and explicit approaches. On the one a conjunction of constraints. Instead of an explicit represen- hand, it can be explicit and generalizes BDD-style repre- tation, we can implicitly encode the solutions by means of sentations. It is also implicit, combining constraint reason- constraint propagation. Our experiments confirm the scala- bility and demonstrate that CDDs can drastically reduce the ing/consistency techniques with a compact data structure. space needed over explicit and ZBDD representations. Binary decision diagram (BDD) (Bryant 1986) is the state of the art representation for propositional logic, and CAD. Unlike BDD which only allows propositional variables (i.e. Introduction the only available constraints are x = 1 and x = 0), a CDD Many real-life combinatorial problems such as scheduling can use arbitrary constraints. We show how CDDs can be can be modeled as a constraint satisfaction problem (CSP). used to represent all solutions of a CSP where space savings Despite the vast improvements on search strategies and con- come because of the implicit representation and use of con- sistency algorithms for binary and specific constraints, rel- straint propagation. Our experiments show that CDDs can atively less efforts have been put into issues with general give 1-2 orders of magnitude space savings over explicit and n-ary constraints. In particular, this paper looks at the issue ZBDDs (Okuno, Minato, & Isozaki 1998) representations. of efficient representations of the solution space. This is im- We remark that for large solution spaces, memory usage can portant when we want to record all solutions to a CSP or as be the primary consideration. efficient representations of n-ary constraints which can be used with consistency algorithms. Preliminaries An efficient representation of all solutions is useful for some applications. For example, a configuration system A constraint satisfaction problem (CSP) is a triple P = may be interactive where real-time response is necessary. So hX, D, Ci, where X = {x1,...,xn} is a set of variables, finding the solutions of the CSP in advance and filtering that D = {D1,...,Dn} is a set of domains, and C is a set 1 against the user’s requirements is more efficient than solv- of constraints Each variable xi can only take values from ing from scratch. In this paper, we are interested in efficient its domain Di, which is a set of integers. A valuation and compact representations which can be used to represent θ is a mapping of variables to integer values, written as vars solution spaces during search. Moreover, we show how var- {x1 7→ d1,...,xn 7→ dn}. Let be the function that ious local consistencies and the constraint solver can be ex- returns the set of (free) variables appearing in a constraint ploited in the representation to get more compactness. or valuation. A k-ary constraint c ∈ C on an ordered set To represent the solutions of a CSP or a general n-ary con- of k distinct variables, sometimes written as c(x1,...,xk), straint compactly, one approach is an implicit representation is a subset of the Cartesian product D1 × · · · × Dk that re- using a symbolic relation, e.g. a logical formula involving stricts the values the variables in c can take simultaneously. arithmetic. While the implicit form can be very compact, A valuation θ satisfies c, a.k.a. a solution of c, if and only they can be difficult expensive to use and discover, espe- if θ ∈ c. Solving a CSP requires finding a value for each cially when constraints are dynamically created. The oppo- variable from its domain so that all constraints are satisfied. Copyright c 2005, American Association for Artificial Intelli- 1In this paper we use the terms “a set of constraints” and “a gence (www.aaai.org). All rights reserved. conjunction of constraints” interchangeably.
AAAI-05 / 366 Let Γ be a set of constraints. Two constraints c1 and c2 are x1 ≤ 5, c12 ≡ x1 ∈ {7, 9}, c2 ≡ x2 < x1, c3 ≡ x3 < x1 equivalent w.r.t. Γ, denoted by c1 ≡Γ c2, if and only if for and c4 ≡ x2 + x3 >x4. The constraint represented by G is any valuation θ, we have θ ∈ (Γ∧c1) ⇐⇒ θ ∈ (Γ∧c2). In Γ ∧ [[v1]] particular, when Γ is true, c1 and c2 are equivalent, written ≡ Γ ∧ (c11 ∧ [[v2]]) ∨ (c12 ∧ [[v3]]) as c1 ≡ c2, if and only if they define the same relation. ≡ Γ ∧ (c11 ∧ c2 ∧ [[v4]]) ∨ (c12 ∧ c3 ∧ [[v4]]) ≡ Γ ∧ (c11 ∧ c2 ∧ c4 ∧ [[1]]) ∨ (c12 ∧ c3 ∧ c4 ∧ [[1]]) Constrained Decision Diagrams ≡ Γ ∧ ((c11 ∧ c2) ∨ (c12 ∧ c3)) ∧ c4. A constrained decision diagram (CDD) G = hΓ, Gi con- A CDD G = hΓ, Gi rooted at the CDD node v = sists of a set of constraints Γ (named CDD constraints) and {(c1,u1),..., (cm,um)} is reduced if and only if each CDD a rooted, directed acyclic graph (DAG) G = (V ∪ T, E) ′ graph Gj rooted at uj is either a terminal or reduced, and (named CDD graph). We call a node v ∈ V ∪ T a CDD c ∧ c ≡Γ false (1) node (or simply node). The 0-terminal (0 ∈ T ) represents i j false and the 1-terminal (1 ∈ T ) represents true. G has ui 6≡Γ uj (2) at least one terminal. Every non-terminal node v ∈ V con- for all 1 ≤ i
AAAI-05 / 367 x1 1 2 3
x2 6= x1 x2 1 2 3 x2 1 2 3x2 1 2 3
3 1 3 2 x3 1 2 3 x3 1 2 3 x3 1 2 3 x 6= x ∧ x 6= x all distinct(x1, x2, x3)
1 0 1 1 (a) (b) (c)
Figure 3: Three different CDDs for x1 6= x2 ∧ x1 6= x3 ∧ x2 6= x3. (a) A MDD-like representation, all solutions are maintained explicitly. (b) A CDD with disequality constraints inside nodes. (c) A CDD with a single all distinct(x1,x2,x3).
x1, x2 ∈ {1, 2, 3}
x1 7→ 1 x1 7→ 3 x1 7→ 2 C
b x2 ∈ {1, 2, 3} x1 ∈ {1} x1 ∈ {2} x2 ∈ {3} x2 ∈ {2, 3} C a x2 7→ 3
x2 x2 7→ 3 × 7→ 2 x2 ∈ {1, 2} x1 ∈ {1, 2} x2 7→ 3 x2 7→ 1 x2 7→ 2 × × x1 7→ 1, x2 7→ 3 x1 7→ 2, x2 7→ 1 x1 7→ 2, x2 7→ 2 1 1 (a) (b) (c)
Figure 4: Let P = h{x1,x2}, {{1, 2, 3}, {1, 2, 3}}, Ci be a CSP with three solutions {x1 7→ 1,x2 7→ 3}, {x1 7→ 2,x2 7→ 1} and {x1 7→ 2,x2 7→ 2}. (a) A depth-first backtracking search tree T for P. A round rectangular node represents a search state. A double-edged round rectangular node represents a solution state (i.e. true). A cross (×) indicates a dead-end (i.e. false). A transition from a search state to another is shown as a directed edge labeled with the corresponding valuation xi 7→ d. (b) A CDD G1 that represents T . (c) A CDD G2 that “approximates” T .
Example 5 Let P = hX, D, Ci be a CSP where X = they actually do. For instance, consider node b again, if we {x1,x2} and D1 = D2 = {1, 2, 3}. We assume that there enforce singleton consistency (Debruyne & Bessiere` 1997) are some constraints C so that P has three solutions {x1 7→ on D2, the domain of x2, we can immediately remove 3 from 1,x2 7→ 3}, {x1 7→ 2,x2 7→ 1} and {x1 7→ 2,x2 7→ 2}. D2. Since then every value in D2 contributes to a solution of Figure 4(a) depicts the depth-first backtracking search tree P, a simpler constraint x1 = 2 is enough to represent these T for P. We will explain how to “compress” T into a CDD. two solutions. Figure 4(c) gives the corresponding CDD G2. First, we look at node a. After we have assigned 1 to x1, Note that it only has one node, while G1 has two. Of course, the domain of x2 is reduced to the singleton set {3}. Thus, as the original constraints do not achieve singleton consis- 2 we can determine the first solution by posing the constraint tency, G2 contains some shallow dead-ends, hence we say x1 = 1. Constraint propagation will do the rest. Next, con- it only “approximates” T . sider the situation if we have assigned 2 to x1. At node b, we This example shows the use of constraint propagation and can assign x2 with either 1 or 2, each corresponds to a so- approximating the search tree could reduce the amount of lution of P. However, x2 7→ 3 leads to a dead-end. We can represent the two solutions and exclude the dead-end with explicit information needed for representing solutions. We are ready present our cddFindall algorithm. Taking a the constraint x1 = 2 ∧ x2 ∈ {1, 2} There is no solution CSP P = hX, D, Ci as input, it compiles the solutions of P for the branch x1 7→ 3. To summarize, adding the implied constraint into a CDD G = hC, Gi. Each CDD node v is of the form {(xk ∈ r1,u1),..., (xk ∈ rm,um)} where r1,...,rm ⊂ (x1 = 1) ∨ (x1 = 2 ∧ x2 ∈ {1, 2}) Dk are pairwise disjoint (so as to satisfy Property (1) of a reduced CDD). Consequently, {r1,...,rm} is a partition of to C we can find the solutions without backtracking. The 2 corresponding CDD G1 is shown in Figure 4(b). We say a valuation xi 7→ d leads to a shallow (deep) dead- Very often, we can obtain a smaller CDD if we “assume” end if this dead-end can(not) be detected by enforcing singleton the constraints achieve a higher level of consistency than consistency on the domain of xi.
AAAI-05 / 368 mkNode (x , S, C) some non-empty subset of Dk. k // Global variable V contains all CDD nodes cddFindall X, , begin ( D C) ′ ′ 7 v := {(xk ∈ r, u) : d, d ∈ r ⇐⇒ hd, ui , hd ,ui ∈ S} begin ′ 1 vars // i.e. xk 7→ d and xk 7→ d point to the same node u if (C) = ∅ then ′ ′ 1 8 if ∃v ∈ V s.t. v ≡C v then return // 1-terminal ′ else return v 2 choose xk ∈ vars(C) else S := ∅ 9 V := V ∪ {v} ′ return v Dk := ∅ 3 foreach d ∈ Dk do ′ end C := C with all xk replaced by d ′ 4 if C is not locally inconsistent then Figure 6: mkNode u := cddFindall(X, D, C′) S := S ∪ {hd, ui} ′ ′ line 8, we check if there already exists a node v′ ∈ V such Dk := Dk ∪ {d} that v and v′ are equivalent w.r.t. C. If so, we will reuse v′. ′ Otherwise, we insert v to V (line 9) and return v. 5 if Dk = ∅ then return 0 // 0-terminal We are going to present two lemmas which allow efficient else equivalence checking and minimization for CDD. They are ′ generalizations of the reduction rules for MDDs. Because of 6 v := mkNode(xk, S, C ∪ {xk ∈ Dk}) return v the space constraint, proofs are omitted. Lemma 1 Suppose xk is variable with domain Dk, and Γ end a set of constraints. Let u and v be two CDD nodes. If Figure 5: cddFindall v = {(xk ∈ Dk,u)} then v ≡Γ u. Lemma 1 says v can be replaced by u because, by the Figure 5 gives the pseudo-code of cddFindall which definition of a CSP, a variable can only take values from uses singleton consistency (can be extended to other con- its domain. One reason to skip any singleton inconsistent sistencies). Its skeleton is a depth-first backtracking search values SI (line 4 of cddFindall) is that, the chance to algorithm. The control flow is as follows. If all variables apply this lemma will be higher if these easy-to-detect dead- have been assigned, i.e., a solution has been found, the 1- ends are not explicitly expressed as an extra branch (xk ∈ terminal will be returned (line 1). Otherwise, we select an SI, 0). uninstantiated variable xk (line 2). We also initialize two We will formalize the example below into Lemma 2. ′ empty sets: S will collect branches of a CDD node, and Dk Example 6 The left of Figure 7 depicts the scenario when a will be a singleton consistent domain of xk. Next, for each CDD node u can be “embedded” into another CDD node v. value d in the domain Dk (line 3) we make new constraints ′ ′ It is not difficult to verify that C that are equivalent to C ∧ (xk = d). If C is not incon- sistent, as determined by the constraint solver, (this makes x ∈ {2, 5} ∧ [[u]] ≡ x ∈ {2, 5} ∧ [[v]]. use of constraint propagation in the existing solver) (line 4) Intuitively speaking we use the domain of x to mask out we invoke cddFindall (recursively) to find a CDD node unwanted branches. u for the sub-problem hX, D, C′i, add the pair (d, u) to S3, ′ ′ Merging can occur more often if the domain of a variable and insert d to Dk. If Dk = ∅ (line 5) when the iteration is over, the 0-terminal will be returned as the constraints C is tight, say, singleton consistent. In fact, when there is no are unsatisfiable. Otherwise, mkNode is called (line 6) to CDD constraint, such as in BDD or MDD, the domains of find a CDD node v for the current (sub)-problem. (The rea- (uninstantiated) variables are invariant along any different ′ paths, and thus only identical sub-graphs can merge. sons for posing xk ∈ Dk, namely to make the domain of xk smaller or singleton consistent, will become clear when Lemma 2 Suppose G = hΓ, Gi is a CDD rooted at v. Let ′ we discuss the reduction rules for CDD.) Finally we return v be a CDD node and xk a variable with domain Dk. If for ′ ′ ′ v. The execution of cddFindall stops after traversing the every (xk ∈ r, u) ∈ v there exists (xk ∈ r ,u ) ∈ v such ′ ′ ′ entire search tree. that u = u and r = Dk ∩ r , we have v ≡Γ v . Figure 6 shows the pseudo-code of mkNode. The global Let G be the CDD graph returned by cddFindall for variable V maintains a set of all existing CDD nodes. At the CSP X, , . Clearly, the CDD , G line 7, an intermediate CDD node v is created in such a way P = h D Ci G = hC i satisfies Property (1). It also satisfies Property (2) of a re- that for every d ∈ r, x 7→ d leads to the same successor u. k duced CDD if mkNode finds equivalent CDD nodes in a Next, in order to satisfy Property (2) of a reduced CDD, at static order, say, a new node is always appended to the end 3Theoretically it is unnecessary to keep (d, u) when u is the of a list V , and mkNode always returns from V the first 0-terminal, i.e. a CDD needs not explicitly state xk 6= d. This, equivalent node. Finally, we show the correctness of our however, simplifies the implementation and our presentation. cddFindall algorithm:
AAAI-05 / 369 x ∈ {2, 5} x ∈ {2, 5, 8, 9} x ∈ {2, 5} x ∈ {2, 5, 8, 9}
u x ∈ {2} x ∈ {5} x ∈ {2} x ∈ {5, 8} x ∈ {9} v x ∈ {2} x ∈ {5, 8} x ∈ {9} v
G1 G2 G3 G1 G2 G3
Figure 7: Merging two CDD nodes (left) into a single one (right)
Theorem 1 Given a CSP P = hX, D, Ci, the BC (AC) means the no-attack constraints achieve bounds cddFindall algorithm returns a CDD graph G such that (arc) consistency. The columns under “CDD+BC/AC” show the CDD G = hC, Gi is reduced and preserves all solutions the time (t seconds) and the total memory (m MB) used of P, i.e. C ∧ [[v]] ≡C, where v is the root node of G. by cddFindall to find all solutions and save them into a CDD with nn nodes. To measure the compactness of a CDD Corollary 1 Given a CSP P = hX, D, Ci as input, cddFindall produces a CDD graph G such that, a solu- independent of the implementation details, which removes the overhead of dynamic clauses, we use the compression tion of P can be obtained from the reduced CDD G = hC, Gi ratio by doing a deep backtrack-free traversal from the root of G N · S to the 1-terminal, in the presence of the constraints C ∧ [[v]], cr = nn where v is the root node of G. Namely, the ratio of the number of cells in a (virtual) ta- ble that stores all the solutions to the number nodes of the Experimental Results CDD. Time, memory use and cr are reported up to 1 deci- We have implemented a prototype of cddFindall in SIC- mal place. Both labeling and cddFindall use static Stus Prolog 3.12.0. Our prototype represents CDD nodes as lexicographical variable and value ordering. dynamic clauses for ease of implementation. This effects the Firstly, regardless the consistency the no-attack con- efficiency as the number of CDD nodes increases. This is not straints achieve, cddFindall uses significantly less mem- important since we focus on the scalability of CDD in terms ory than findall, especially when N is large. For in- of its size and memory used. Experiments were run on a stance, when N = 14, 119 MB was used by findall, PC running Windows XP, with a P4 2.6GHz CPU and 1 GB compared to less than 10 MB by cddFindall. CDD is physical memory. Due to the lack of space, we only present also significantly superior to the combinatorial sets repre- the results on the N-queens problem. Finding a compact sentation using ZBDD5 (Okuno, Minato, & Isozaki 1998) representation for all the solutions of the N-queens problem where we found that ZBDDs cannot compress the solutions is challenging for two reasons. First, its permutation nature well. Also, the compression ratio increases with N, which implies compression methods by just suffix or prefix shar- indicates our CDD representation becomes more efficient (in ing on the solution set, such as to use a trie or a MDD, are terms of size) when the solution set grows. 4 doomed to failure. Second, its number of solutions grows Secondly, let us compare the memory consumed by exponentially with N, which makes scalability critical. cddFindall and findall when we strengthen the con- The N-queens problem is to place N queens on a N × N sistency (from BC to AC) that the no-attack constraints chess board such that no two queens attack each other. Our achieve. For cddFindall, its memory use decreases with model involves N variables x1,...,xN . Each variable has the increase of the level of consistency. In fact, when AC a domain Di = {1,...,N}. A valuation xi 7→ j means instead of BC is achieved, the size (number of nodes) of the the queen is placed in the i-th row and the j-th column. CDD (for the same N) is reduced by about 33% or more. We use all distinct(x1,...,xN ) that enforces gen- This is because the search tree shrinks, so does the CDD, eralized arc consistency, and a no-attack constraint when the consistency becomes stronger. However, the mem- findall |x − x |= 6 |i − j| ory used by is insensitive to the level of consis- i j tency. The reason is obvious as the number of solutions is for each pair of variables xi and xj. There are two ver- independent to the consistency the constraints achieve. sions of the no-attack constraints, one achieves bounds con- Our results justify the scalability of CDD for solutions sistency (BC) and the other achieves arc consistency (AC). recording, and the usefulness of combining constraints and Table 1 summarizes the results. N is the number of decision diagrams. Currently, cddFindall runs slower queens. S is the number of solutions. The columns under than findall for larger instances. However, we claim this “findall+BC/AC” show the execution time (t seconds) and is because of the excessive use of dynamic clauses. A better the total memory (m MB) used by the built-in predicates implementation should improve the runtime. labeling/2 and findall/3 to generate and store all 5 solutions. Note that findall stores the solutions in a list. We implemented their proposed operations using the (Z)BDD package CUDD 2.4.0 (http://vlsi.colorado.edu/ fabio/CUDD/). For 4Compressing the 14200 solutions of the 12-queens problem N = 12, the ZBDD has 45833 nodes, where each node encodes a using WinZip can only reduce its size from 403KB to 81KB. valuation xi 7→ j. Our PC ran out of memory for N > 12.
AAAI-05 / 370 N S findall+BC findall+AC CDD+BC CDD+AC t m t m t m nn cr t m nn cr 10 724 0.3 2.3 0.3 2.3 0.4 2.1 173 41.8 0.3 2.1 116 62.4 11 2680 1.7 3.6 1.4 3.5 1.8 2.3 564 52.3 1.4 2.1 389 75.8 12 14200 9.1 8.1 7.4 8.1 9.8 2.5 2187 77.9 7.1 2.3 1445 117.9 13 73712 44.6 21.7 37.5 21.7 59.9 3.6 9462 101.3 41.5 3.1 6291 152.3 14 365596 339.1 119.1 244.6 119.1 496.6 9.0 42877 119.4 307.7 6.7 28450 179.9
Table 1: Experimental results on the N-queens problem
Discussion and Related Work constant. However, they are tailor-made for specific appli- cations and do not apply (general) constraint solving. In this paper we have proposed a novel representation for We plan to implement a more efficient consistency algo- general n-ary constraints called constrained decision dia- rithm for general n-ary constraints (say, GAC) on top of a grams. We have demonstrated its use in maintaining all so- CDD. As a compact and efficient representation for a huge lutions of a CSP. Our experimental results confirm the scal- solution set, CDD might also benefit applications such as ability and compactness of our new representation. (no)-goods learning during search and CSP decomposition. There are two streams of related work: either to find a high-level description (say, an arithmetic relation) from a References solution set, e.g. (Apt & Monfroy 1999; Cheng, Lee, & Stuckey 2003; Dao et al. 2002), or to directly compress Apt, K., and Monfroy, E. 1999. Automatic generation the solution set, e.g. (Bartak´ 2001; Hubbe & Freuder 1992; of constraint propagation algorithms for small finite do- van der Meer & Andersen 2004; Okuno, Minato, & Isozaki mains. In Principles and Practice of Constraint Program- 1998; Weigel & Faltings 1999). We call the former the in- ming, 58–72. ductive approach and the latter the compression approach. Bartak,´ R. 2001. Filtering algorithms for tabular con- The inductive approach usually outputs a (symbolic) rep- straints. In Colloqium on Implementation of Constraint and resentation which is compact and efficient to process (by the Logic Programming Systems (CICLOPS), 168–182. constraint solver). However, it requires fairly expensive pre- Bryant, R. E. 1986. Graph-based algorithms for Boolean processing on the solution set and compilation of the rep- function manipulation. IEEE Trans. on Comp. 35(8):667– resentation into some program codes. Hence, scalability is 691. a problem and this approach is not suitable to process con- Cheng, C. K.; Lee, J. H. M.; and Stuckey, P. J. 2003. Box straints that are generated during CSP solving. constraint collections for adhoc constraints. In Principles The compression approach, in contrast, retains the set and Practice of Constraint Programming, 214–228. of solutions in its explicit form, but reduces its size via Dao, T.; Lallouet, A.; Legtchenko, A.; and Martin, L. 2002. compression techniques such as suffix or prefix sharing. Indexical-based solver learning. In Principles and Practice The compression process is incremental and needs no pre- of Constraint Programming, 541–555. processing. However, since the number of solutions could be Debruyne, R., and Bessiere,` C. 1997. Some practicable exponential and sharing might not be very common among filtering techniques for the constraint satisfaction problem. solutions (e.g. for permutation problems), dealing with so- In IJCAI, 412–417. lutions explicitly is sometimes impractical. One pitfall to both approaches is they treat the solutions of Hubbe, P. D., and Freuder, E. C. 1992. An efficient cross a CSP or a constraint solely as a set of data, just like there is product representation of the constraint satisfaction prob- no other constraint. In practice, however, a constraint rarely lem search space. In AAAI, 421–427. comes alone. As we have already presented, taking exist- Møller, J.; Lichtenberg, J.; Andersen, H. R.; and Hulgaard, ing constraints into account is indeed the key to a compact H. 1999. Difference decision diagrams. In Comp. Sci. representation for solution set. Logic. We consider CDD a bridge between the inductive and the Okuno, H.; Minato, S.; and Isozaki, H. 1998. On the prop- compression approaches. On the one hand, arbitrary con- erties of combination set operations. Information Process- straints can be used inside a CDD (node). In fact, by defi- ing Letters 66:195–199. nition, a CDD interacts with other constraints via constraint Srinivasan, A.; Kam, T.; Malik, S.; and Brayton, R. 1990. propagation. On the other hand, a CDD, just like MDD and Algorithms for discrete function manipulation. In Intl. other BDD variants, can represent individual solution and Conf. on CAD, 92–95. be constructed incrementally. Its dual nature makes CDD a van der Meer, E., and Andersen, H. R. 2004. Bdd-based very flexible and powerful representation for constraints. recursive and conditional modular interactive product con- We would like to point out that, there exists variants of figuration. In CSPIA Workshop, 112–126. BDD which use some restricted form constraints. For in- Weigel, R., and Faltings, B. 1999. Compiling constraint stance, in difference decision diagram (Møller et al. 1999) satisfaction problems. Art. Intell. 115(2):257–287. each node represents a constraint x AAAI-05 / 371