Optimizing STR Algorithms with Tuple Compression

Transcription

1 Optimizing STR Algorithms with Tuple Compression Wei Xia and Roland H.C. Yap School of Computing National University of Singapore {xiawei, Abstract. Table constraints define an arbitrary constraint explicitly as a set of solutions (tuples) or non-solutions. Thus, space is proportional to number of tuples. Simple Tabular Reduction (STR), which dynamically reduces the table size by maintaining a table of only the valid tuples, has been shown to be efficient for enforcing Generalized Arc Consistency. The Cartesian product representation is another way of having a smaller table by compression. We investigate whether STR and the Cartesian product representation can work hand in hand. Our experiments show the compression-based STR can be faster once the tables compress well. Thus, the benefits of the STR2 and STR3 algorithms respectively are retained while consuming less space. Introduction Table constraints are the most general form of finite domain constraints where the table defines the solutions (or non-solutions) of the constraint. Two state-of-the-art GAC approaches for non-binary table constraints, STR [ 3] and mddc [4], incorporate some form of compression. In particular, STR uses dynamic compression which compresses the table during search by removing invalid tuples. Tables can also be compressed with the Cartesian product representation [5, 6] which was used before in the context of symmetry breaking and nogood learning. It was applied to compress table constraints in [7] and shown to improve the GAC-Schema+allowed algorithm. Compression of a table constraint using the Cartesian product representation for the tuples, which we call c-tuple(s), gives a static compression of the table. Dynamic compression in STR, on the other hand, compresses by reducing the table size by tabular reduction [] during search. However, the Cartesian product representation can inhibit tabular reduction. Thus, unlike GAC-Schema algorithms which use static tables where compression is likely to be beneficial, with STR there is interplay between both kinds of compression, changing their benefits respectively. A recent paper [8] proposed a more complex way to compress tables and applies STR on this compressed representation. However, their preliminary experiments showed that the revised algorithm to be competitive with STR [], but not faster than STR2 [2]. Ideally we want a compression schemes for STR where the overall benefits can outweigh the costs. In this paper, we return to the simple idea of Cartesian product compression and investigate whether static and dynamic compression approaches for GAC can be effectively combined on table constraints. We extend the STRx (STR2 [2] and STR3 [3])

2 algorithms to handle compression tuples [7]. We experiment with random and structured CSPs varying the degree of static and dynamic table compression. We find that compression is not always beneficial but when there is a reasonable amount of static compression, the compression algorithms, STR2-C and STR3-C are faster than STR2 and STR3 respectively. They also inherit the underlying properties of STR2 and STR3. 2 Background A constraint satisfaction problem (CSP) P = (X, C) consists of a finite set X of variables and a finite set C of constraints. Variables x i X only take values from a finite domain dom(x i ). An assignment (x i,a) denotes x i = a. An r-ary constraint C C on r distinct variables x,...,x r is a subset of the Cartesian product r i= dom(x i), denoted by rel(c), that restricts the values of the variables in C can take simultaneously. The scope is the set of variables denoted by var(c) and r is the arity of C. A set of assignments θ = {(x,a ),...,(x r,a r )} satisfies C iff (a,...,a r ) rel(c), also called a solution of C or tuple of C and θ[x i ] = a i. Solving a CSP is finding an assignment for each variable from its domain so that all constraints are satisfied. An assignment (x i,a) is generalized arc consistent (GAC) to P iff for every constraint C C such that x i var(c), there is a solution θ of C where (x i,a) θ and a dom(x i ) for every (x i,a) θ. This solution is called a support for (x i,a) in C. A variable x i X is GAC iff (x i,a) is GAC for every a dom(x i ). A constraint is GAC iff every variable in its scope is GAC. Finally, CSP P is GAC iff every constraint incis GAC. Definition. (C-tuple [5, 7]). Let C be an r-ary constraint. A compression tuple τ c = ({a,,a,2,...,a,k },...,{a r,,a r,2,...,a r,kr }) of C is the Cartesian product of a set of tuples. This compression tupleτ c is also called a c-tuple. A c-tuple admits any set of assignments that assigns one ofa,,...,a,k tox, one of a 2,,...,a 2,k2 to x 2, etc. Given a c-tuple τ c, τ c [x i ] denotes{a i,,...,a i,ki }. Fig (a) shows a table and Fig (c) shows its compressed form. A c-tuple can potentially represent an exponential number of tuples. We extend the concept of validity to c-tuples. Definition 2. (Validity of c-tuple). Let C be an r-ary constraint. A c-tuple τ c is valid onc iff x i var(c), a i τ c [x i ] such thata i dom(x i ). 3 STR2-C: STR2 on compression tuples STR2 [2], a refinement of STR, is shown to be one of the most efficient GAC algorithms for non-binary table constraints. In maintaining GAC during search, STR2 gets its efficiency by maintaining dynamically the table of valid tuples. When enforcing GAC on a table constraint, the validity of each tuple is checked. Once a tuple is found to be valid, the domains of the variables are updated with the consistent values belonging to the tuple. Otherwise, the tuple is removed from the table, thus, is not considered again as the search goes deeper. Upon backtracking, removed tuples will be added back to the table.

3 We now extend STR2 to work with table constraints on c-tuples which we call STR2-C. Like STR2, STR2-C maintains a table of valid c-tuples dynamically during search. The extension to STR2-C is straightforward, so we will describe it informally. When STR2-C identifies the validity of c-tuples, if a c-tuple is invalid, it will be removed from the table, otherwise, the values belonging to the c-tuples are used to update the domains of the variables. But unlike STR2, all the values belonging to a valid tuple are GAC-consistent, the valid c-tuples may contain inconsistent values. Thus additional value checks against the domains must be done when collecting the consistent values. For the same reason, the domain updating phase of STR2 can cause rechecking of inconsistent values. In order to save some rechecks, a cursor can be used for each variable to separate the inconsistent values with the unchecked values, then the values which are already detected to be inconsistent can be skipped and only the unchecked values will be checked against the variables domains. In STR2, one optimization is that once a variable s domain is found GAC-consistent, there is no need to seek supports for the variable. Such variables are skipped when the variables domains are updated in the second phase of STR2. This optimization can be amplified in STR2-C, as the value checks against the domains in the second phase of STR2-C can also be skipped. Compared to STR2, the potential runtime improvement of STR2-C is because the compressed table may be up to exponentially smaller than the original table. We could expect that gains in efficiency of STR2-C will depend on the size of the compression table to the original table. To illustrate this, consider the constraint: C d,r (x,x 2,...,x r ) [ r i= x i = {0,,...,d 2}] [ r i= x i = d ] The domain of each variable is 0,,...,d. The table representation of C d,r has (d ) r + tuples, while the c-tuple table has 2 c-tuples, which are {({0,,...,d 2},...,{0,,...,d 2}),({d },...,{d )})}. Enforcing GAC onc d,r using STR2 takeso(rd r ) time, while using STR2-C takeso(rd) time. However, there is also a drawback. Unlike STR2, which keeps valid tuples, STR2- C keeps the valid c-tuples that may still include invalid tuples. This will bring some rechecks of values which can slow down STR2-C compared with STR-2. 4 STR3-C: STR3 on compression tuples STR3 [3] is a fine-grained table reduction based GAC algorithm, but uses a different table representation. Conceptually, in the STR3 representation, each variable-value pair is mapped to its set of tuples. STR3 is path-optimal, as it avoids unnecessary traversal of tables. STR3-C extends STR3 to work on c-tuples. The STR3 and STR3-C representation is illustrated in Fig (see [3] for details). Fig (a) shows the original table representation and Fig (b) is the equivalent STR3 representation. Compressing Fig (a) with c-tuples gives Fig (c) and the final STR3-C representation is Fig (d). We briefly summarize some ideas from the STR3 algorithm, and refer to the details in [3]. For each constraint C, row(c,x,a) represents the set of tuples belonging to (X,a) in the equivalent table (e.g. Fig (b)). row(c,x,a) is associated with a cursor, represented by row(c,x,a).curr, to separate the untested and invalid tuples. In addition, each tuple τ is accompanied with a dependent list dep(τ) of variable-value

4 X Y Z a a a 2 a a b 3 b b c 4 b c c 5 c b c 6 c c c (a) Standard table X Y Z {a} {a} {a,b} 2 {b,c} {b,c} {c} (c) Standard compressed table X Y Z a {, 2} a {, 2} a {} b {3, 4} b {3, 5} b {2} c {5,6} c {4,6} c {3,4,5,6} (b) Equivalent table X Y Z a {} a {} a {} b {2} b {2} b {} c {2} c {2} c {2} (d) Equivalent compressed table Fig. : The table representation of STR3 and STR3-C. pairs which treat τ as a valid support. STR3 works as follows. Once a value (X,a) is removed, all the unchecked tuples in row(c, X, a) before the cursor will be checked. If a tuple is already invalid, there is no need to update its dependent list. Otherwise, the tupleτ is set to be invalid, then a new support should be found for each(y,b) dep(τ). If a supportτ 2 is found,(y,b) will be shifted todep(τ 2 ), otherwise(y,b) is inconsistent and removed. STR3-C works with c-tuples, i.e. the STR3 representation applied to the compressed c-tuple form of the original table. In STR3-C, row(c,x,a) is replaced by a set of c- tuples containing value(x, a). The dependent list is based on c-tuples, but is still composed of the variable-value pairs. The key for STR3-C is the detection of the validity of c-tuples. This is the main difference from STR3, as when(x,a) is removed, the c-tuple in row(c,x,a) may still be valid. The details of the algorithm is given in Fig 2. The inv(c) in Line is the set of invalid c-tuples of constraint C implemented as a sparse set. In theinv(c) structure,inv(c).members is the position of the last current element ininv(c) andinv(c).dense is the invalid c-tuples array. In Line 2,comprTable is the standard compressed table (e.g. Fig c) and comprtable[row(c, X, a)[k]][x] returns a set values of X appearing in the c-tuple row(c,x,a)[k]. Different from STR3, the standard compressed table is used to access the c-tuples. To check the validity of the c-tuple row(c,x,a)[k], if a consistent value belonging to the c-tuple under variable X exists, the c-tuple is valid, so no need to update the dependent list of the tuple. Otherwise the c-tuple becomes invalid, and will be added into inv(c). The save() function in Line 6 and Line 7 stores the states ofinv(c).members androw(c,x,a).curr into the stack statei and stater respectively for backtracking. From Line 5 to Line 8, which is the same as STR3, STR3-C updates the dependent list of the invalid c-tuples, and the inconsistent values will be removed. For example, consider a table constraintc(x,x 2,x 3 ) = {(0,0,0),(0,,0),(0,2,0), (2,2,2)} with domains {0,,2}. In STR3, when (x 2,0) is removed, the first tuple (0,0,0) becomes invalid. If (x,0) and (x 3,0) are in dep((0,0,0)), then (x,0) and (x 3,0) will be transferred to the second or third tuple by assuming (x 2,) and (X 2,2)

5 STR3-C(C : Constraint,X : Variables,a : Value) prevmembers inv(c).members 2 for k 0 torow(c,x,a).curr do ifrow(c,x,a)[k] / inv(c) then 3 checkval[] comprtable[row(c,x,a)[k]][x] for v 0 tocheckval[].size do if checkval[v] dom(x) then break ifv = checkval[].size then 4 add row(c,x,a)[k] toinv(c) 5 if prevmembers = inv(c).members then return true 6 save(c,prevmembers,statei ) foreach i {prevmembers +,...,inv(c).members} do k inv(c).dense[i] foreach (Y,b) dep(c)[k] such thatb D C (Y)do p row(c,y,b).curr whilep 0 androw(c,y,b)[p] inv(c) dop p if p < 0 then removevalue(y, b) ifd C (Y) = then returnfalse else ifp row(c,y,b).curr then 7 save((c,y,b),row(c,y,b).curr,stater) row(c,y,b).curr p 8 returntrue move (Y,b) from dep(c)[k] todep(c)[row(c,y,b)[p]] Fig. 2: STR3-C algorithm are consistent. However, for STR3-C, the first three tuples are compressed into one. When (x 2,0) is removed, the c-tuple ({0},{0,,2},{0}) is still valid as (x 2,) and (x 2,2) are consistent, thus the dependent list will not be checked or updated. But this c-tuple may be checked again when (x 2,) or (x 2,2) is removed. Similar to STR2-C, the rechecks may potentially slow down STR3-C. The difference between STR3 and STR3-C mainly lies in the cost of detecting the invalid tuples. STR3-C takes at most additional d value checks for each c-tuple when checking its validity. However, as the compressed table can be exponentially smaller than the original table, STR3-C can still have runtime improvement. As STR3 collects the invalid tuples incrementally, let s consider the cost for the constraint C d,r, used in previous section, along a single search path of length m. For STR3-C, one c-tuple will become invalid after at most r d times validity checks along a single path, and each validity check is accompanied by at most d value checks. Assuming O() cost at each search node, STR3-C will takeo(rd 2 +m) time, while STR3 will takeo(rd r +m) [3] time forc d,r.

6 Table : Statistics for the benchmarks. Series #tuples Cr Series #tuples Cr Series #tuples Cr rand rand-5-2-2x mdd rand rand-5-2-4x mdd rand rand-5-2-8x mdd cril ramsey-a ruler ramsey-a ruler chesscolor 78 5 Table 2: The average runtime (in seconds) for random benchmarks. Series #instances STR2 STR2-C STR3 STR3-C rand rand rand rand-5-2-2x rand-5-2-4x rand-5-2-8x MDD MDD MDD Experiments We prototype STR2-C and STR3-C in Abscon which has implementations of STR2 and STR3. Experiments were run on an Intel on 64-bit Linux. We investigate the performance of STRx algorithms under different table compression ratios with random and structured benchmarks given in Table. 2 In order to have sufficient variation in table compression, we also generate another two series of random CSPs. The first is MDD-p which generalises the mdd-half benchmark (p = 0.5) by building an MDD in a post-order manner with probability p that a previously created sub-mdd is reused [4]. Another series is modified from rand-5-2 where the constraints have high tightness. 3 We decrease the tightness by randomly adding tuples such that the table is 2X (twice), 4X and 8X the size of rand-5-2. As some tables become quite large, half the constraints are removed. The average table size and table compression ratio based on series of benchmarks are given in Table wherecr = #c tuples #tuples. We use dom/ddeg and lexico as the variable and value ordering respectively when solving the CSPs to ensure the search space is the same [2]. Table 2 shows the average CPU time to solve the instances of different groups of random CSPs with the fastest across algorithms in bold and the fastest per column underlined. The cursor optimiza- Available from lecoutre/research/tools 2 The benchmarks are available from lecoutre 3 The tightness of a table is defined as t d r, where t is the number of tuples in the table, d is the domain size of the variables and r is the arity of the constraint.

7 runtime (in seconds) of STR2-C Cr=0.05 Cr=0.050 Cr=24 Cr=3 Cr=38 Cr=0.243 Cr=0.45 Cr=0.602 Cr=0.684 x=y x=20y runtime (in seconds) of STR3-C Cr=0.05 Cr=0.050 Cr=24 Cr=3 Cr=38 Cr=0.243 Cr=0.45 Cr=0.602 Cr=0.684 x=y x=20y runtime (in seconds) of STR2 (a) runtime (in seconds) of STR3 (b) Cr=0.09 Cr=0.026 Cr=0.094 Cr=5 Cr=0.25 Cr=33 Cr=0.026 Cr=0.094 Cr=5 Cr=0.25 Cr=33 y=x 00 y=x 00 runtime (in seconds) of STR2-C 0 runtime (in seconds) of STR3-C runtime (in seconds) of STR2 runtime (in seconds) of STR3 (c) (d) Fig. 3: (a) and (b) shows the runtime of STRx and STRx-C for random CSPs; (c) and (d) shows the runtime of STRx and STRx-C for structured CSPs with a max number of search nodes. (A smaller value of Cr indicates higher compression) tion is used in the STR2-C column which we found to give a small improvement on average. However, in some instances, the added overhead makes it slightly slower. We found STRx-C, on average, is faster than the corresponding STRx algorithm. In particular, for the series MDD-0.9, STR2-C and STR3-C are up to 9 times faster than STRx respectively. For the structured CSPs, most of the problem instances take longer than the time out ( hour), thus, we give the average runtime up to a maximum number of search nodes: 00 nodes for ramsey, chessboardcolor and cril, and 0 nodes for golombruler (in Fig 3 (c) and (d)). Fig 3 details the runtime of STRx and STRx-C for each instance under different compression ratios. From Fig 3 (a) and Fig 3 (c), we see that STR2-C could be more than 20 times faster than STR2 for some instances. When the compression ratio is small enough, STR2-C becomes faster than STR2. Thus, the more the table is compressed, the faster STR2-C gets. Fig 3 (b) and Fig 3 (d) show a similar comparison between

8 STR2/STR3 STR2-C/STR3-C 0.9 STR2-C/STR2 STR3-C/STR average table size avgerage table size ratio runtime ratio runtime ratio (a) (b) Fig. 4: (a) The runtime ratio of STR2/STR3 and STR2-C/STR3-C versus the average table size during search; and (b) The runtime ratio of STR2-C/STR2 and STR3-C/STR3 versus the average table size ratio during search. STR3-C and STR3. We also find that STR3-C is faster when Cr is small. However, the slowdown or speedup of STR3-C on STR3 is less than STR2-C on STR2. STR3 was shown to be faster than STR2 when table reduction does not drastically reduce the table during search [3]. We also investigate whether this property is inherited by STR2-C and STR3-C. As Fig 4 (a) shows, STR3-C is also faster than STR2-C when the average compressed table size is large. We see that among the instances, STR2 is up to 4 times slower than STR3, while STR2-C is up to 6 times slower than STR3-C. This suggests that the difference between STR2 and STR3 is more pronounced after compression. Fig 4 (b) shows that STR2-C is fast as the average table size of the compression table is small enough, otherwise STR2-C is slower than STR2. We also observed that the average table size ratio during search of STR2-C over STR2 decreases as the compression ratio decreases. This is reasonable as when the table cannot be compressed much, the original table and the c-tuple table are close in size, so the table reduction during search becomes similar. Thus, the compression ratio becomes the basic determinant to the performance of the STRx-C algorithms and can be used to identify cases when STRx-C is beneficial. We also compared with c-tuples on GAC-schema+allowed. On average, the speedup or slowdown of c-tuples is greater with STR2 than with GACschema+allowed. To summarize, our experiments show that our STR algorithms on compressed tables are competitive when the table can be compressed enough. For random CSPs, as the table compression ratio drops to 25%, the STRx-C algorithms become more efficient. This illustrates that static and dynamic table compression can cooperate well in practice even though the use of c-tuples has drawbacks in that it reduces the amount of table reduction and has some (small) overheads. We also show that the properties of STR2 and STR3 can be inherited by their compressed version algorithms.

9 References. Ullmann, J.R.: Partition Search for Non-binary Constraint Satisfaction. Information Science 77 (2007) Lecoutre, C.: STR2: Optimized Simple Tabular Reduction for Table Constraints. Constraints 6 (20) Lecoutre, C., Likitvivatanavong, C., Yap, R.H.C.: A Path-Optimal GAC Algorithm for Table Constraints. In: Proceedings of the Twentieth European Conference on Artificial Intelligence (ECAI). (202) Cheng, K., Yap, R.: An MDD-based Generalized Arc Consistency Algorithm for Positive and Negative Table Constraints and Some Global Constraints. Constraints 5 (200) Focacci, F., Milano, M.: Global Cut Framework for Removing Symmetries. In: Proceedings of the Seventh International Conference on Principles and Practice of Constraint Programming (CP). (200) Katsirelos, G., Bacchus, F.: Generalized Nogoods in CSPs. In: Proceedings of the Twentieth National Conference on Artificial Intelligence (AAAI). (2005) Katsirelos, G., Walsh, T.: A Compression Algorithm for Large Arity Extensional Constraints. In: Proceedings of the Thirteenth International Conference on Principles and Practice of Constraint Programming (CP). (2007) Gharbi, N., Hemery, F., Lecoutre, C., Roussel, O.: STR et Compression de Contraintes Tables. In: Journées Francophones de Programmation par Contraintes (JFPC). (203) 43 46