Rapid Prototyping of a Structured Domain through Indexical Compilation

Transcription

1 Rapid Prototyping of a Structured Domain through Indexical Compilation Joseph D. Scott Uppsala University Abstract. We report on our experience with rapid prototyping for a new structured domain of bounded-length strings, automatically generating propagator source code from an extended indexical specification. 1 Introduction Many problems can be naturally modeled using structured objects, such as sets, multisets, graphs, strings, etc. Just as constraints afford a generic means of modeling common combinatorial subproblems, structured domains [2] provide for higher-level modeling of variable relations. For example, many problems are naturally modeled in terms of finite sets, which might be modeled ad hoc; instead, constraint solvers provide decision variables and constraints for sets [3, 5]. Developing a new structured domain includes writing all new propagator implementations. Implementing a propagator that is both correct and efficient is time-consuming; the relative complexity of structured domains exacerbates this issue. One way to ease the development process is to leverage the power of existing finite domain solvers, defining a domain variable as a composition of existing finite domain decision variables. For example, a graph decision variable [1] may be viewed as a combination of a set of nodes and a set of edges. Prototyping of a new domain may be accomplished by writing propagators which replace each instance of a variable in the new domain with a collection of decision variables; indeed, this appears to have been exactly the prototyping process in [1]. To further speed prototyping, [4] compiles propagators described in an extended indexical language into implementations for targeted constraint solvers. An indexical [7] is an expression of the form x σ restricting the domain of the decision variable x to the intersection of its current domain and the interval σ. [4] extends indexicals to include arrays and n-ary operators over them. This indexical language is used to write a checker for a constraint; a description for a propagator may then be automatically generated. Several solver-specific backends allow for compilation of this propagator into source code, which can be used as a prototype propagator, and possibly serve as a basis for further refinements. 2 Propagation for Bounded-Length Strings We consider a domain for strings of bounded, but not fixed, length. Specifically, we represent strings as a concatenation of bounded-length substrings: a prefix

2 substring, which starts at the beginning of the string, and a suffix substring, which starts at the end of the string. The suffix substring is the reversal of the second part of the string itself; this allows for inference to be made about both ends of the string, even when the length is unknown. The merits of this method are discussed elsewhere [6]; here, we consider only propagation on the domain. Such a bounded-length string variable may be represented as two arrays of finite domain variables, one to hold the characters of the prefix substring, and the other for the suffix substring. Since neither of these substrings has a fixed length, we include the length of these substrings as two integer variables; the arrays are large enough to hold the largest allowed substrings, and the length of the actual substrings is determined by the domains of the length variables. Also include is an integer for the total length of the string, which equals the sum of the substring lengths. We now describe a propagator for a constraint of string equality over this domain, using the extended indexical language of [4]. Listing 1. Indexical language description of propagator for string equality. 1 def STR_Equal(vint[] Px, vint Pnx, vint[] Sx, vint Snx, vint Lx, 2 vint[] Py, vint Pny, vint[] Sy, vint Sny, vint Ly){ 3 checker{ 4 val(lx) == val(ly) and val(lx) == (val(pnx) + val(snx)) 5 and val(ly) == (val(pny) + val(sny)) 6 and check(str_eqregion_u(px,pnx,py,pny,0)) 7 and check(str_eqregion_u(sx,snx,sy,sny,0)) 8 and check(str_eqregion_b(px,pnx,sy,sny,lx)) 9 and check(str_eqregion_b(sx,snx,py,pny,lx)) 10 } 11 } Listing 1 describes the constraint STR Equal, which states that a pair of strings have equal lengths, and the same characters at each position. Each string is represented by five variables: arrays for the prefix and suffix substrings (Px,Sx), integers for the lengths of the substrings (Pnx, Pny) and the length of the string (Lx). Lines 6 to 9 describe the requirement that the characters are equal in terms of two more primitive constraints, which ensure character-bycharacter equality over slices of a pair of substrings. Each of these constraints takes two substring arrays and their corresponding lengths, plus a variable Offset. STR EqRegion U ensures that the beginnings of the two prefixes (line 6) and of the two suffixes (line 7) are equal. Equality of string length does not imply equal length for the component substrings, however; if the prefix substring lengths are different, then the end of one of the prefix substrings might line up with the end of the suffix substring of the other string. These latter cases are handled by STR EqRegion B (lines 8 and 9); the B refers to the fact that a prefixsuffix pair is bidirectional, as opposed to unidirectional prefix-prefix pairs. The degree of overlap depends on the lengths of both the substrings and the strings; the value of Lx for the Offset variable specifies that the first character of the two substrings occur at a distance equal to the total length of the string.

3 Listing 2. Description of propagator for unidirectional regions. 1 def STR_EqRegion_U(vint[] X, vint Xn, vint[] Y, vint Yn, vint Offset){ 2 checker{ 3 and(i in (max({min(rng(x)),(min(rng(y)) + val(offset))}).. 4 min({((min(rng(x)) + val(xn)) + -1), 5 (((min(rng(y)) + val(offset)) + val(yn)) + -1)}))) 6 (val(x[i]) == val(y[(i + -val(offset))])) 7 } 8 propagator(gen)::dr{ 9 forall(i in (max({min(rng(x)),(min(rng(y)) + max(offset))}).. 10 min({((min(rng(x)) + min(xn)) + -1), 11 (((min(rng(y)) + min(offset)) + min(yn)) + -1)}))){ 12 X[i] in union(ii15 in ({i} + -dom(offset)))(dom(y[ii15])); 13 Y[(i + -val(offset))] in dom(x[i]); 14 Offset in (-rng(y) + {i}); 15 forall(ii8 in rng(y)){ 16 (dom(y[ii8]) inter dom(x[i])) == emptyset -> 17 Offset in (U minus {(-ii8 + i)}); 18 } 19 } 20 } 21 } The checker for STR EqRegion U (Listing 2) is an n-ary and statement. The bound variable i takes the indices of characters in X (given by the expression rng(x)) which line up with some character in Y, requiring the values of these characters to be equal. As described above, the Offset variable determines the distance between the first characters of the two substrings, which is always 0 for STR Equal. Offset is included for the sake of generality, as it is easy to imagine constraints in which two strings do not start at the same position. (The checker for STR EqRegion B is similar, but omitted for reasons of space.) From the provided checkers, the indexical compiler generates propagators. The generated propagator for STR EqRegion U (beginning at line 8 of Listing 2) is quite similar to propagation for the Element constraint, with the difference that there are two arrays instead of one. The generated propagator is correct, but can be improved with minor modification. The statement at line 14 is unnecessary. Furthermore, lines 12 and 13 should be similar: each X[i] is compared to the union of all the array elements in Y which it could be aligned with, and checking for Y should be symmetric. Instead, characters of Y are only compared to those in X once the Offset is fixed, a much weaker condition which is easily corrected manually. Lines disallow any offset which results in the alignment of a character form X and Y with disjoint domains. An additional run of the indexical compiler generates a propagator for STR Equal (Listing 3). In the generated code, the check statements in the STR Equal specification are replaced with the corresponding code from the primitive propagators, then simplified when possible; for example, on lines 3-8, the Offset between Px and Py is 0, so STR EqRegion U simplifies to X[i] == Y[i] for a range of i.

4 Listing 3. Indexical-based propagation for string STR Equal constraint. 1 propagator(gen)::dr{ 2 // restrictions on substring length omitted 3 forall(i in (max({min(rng(px)),min(rng(py))}).. 4 min({((min(rng(px)) + min(pnx)) + -1), 5 ((min(rng(py)) + min(pny)) + -1)}))){ 6 Px[i] in dom(py[i]); 7 Py[i] in dom(px[i]); 8 } 9 // symmetric loop for Sx,Sy omitted 10 forall(i in (max({min(rng(px)), 11 ((min(rng(px)) + max(lx)) + -min(sny))}).. 12 min({((min(rng(px)) + min(pnx)) + -1), 13 ((min(rng(px)) + min(lx)) + -1)}))){ 14 Px[i] in union(ii47 in (dom(lx) + {(-i + -1)}))(dom(Sy[ii47])); 15 Sy[((val(Lx) + -i) + -1)] in dom(px[i]); 16 Lx in (rng(sy) + {(i + 1)}); 17 forall(ii40 in rng(sy)){ 18 (dom(sy[ii40]) inter dom(px[i])) == emptyset -> 19 Lx in (U minus {((ii40 + i) + 1)}); 20 } 21 } 3 Preliminary Results and Future Work Preliminary results are quite promising. The method outlined here was used to prototype propagators of string equality, reversal, concatenation, and substring inclusion, all based on the pair of primitive constraints described here. From an indexical language specification of around 200 lines we generated propagators in Gecode (approximately 3000 lines of code). Generating the prototype in a highlevel language proved very useful in terms of catching logical errors. Moving all indexing calculations into the two primitive constraints was especially useful; these two, relatively short propagators are easily debugged, yielding reliable inlined code that occurs at roughly two dozen positions in the propagators. Current work is focused on refining the generated propagators in terms of efficiency. For example, in Listing 3 the union operation at line 14 is, of course, quite expensive. However, the range of elements in the union changes only slightly on each iteration of the loop at line 10, and can be more efficiently implemented. We also seek to add constraints for language membership and intersection. Future work includes extending the indexical language to directly support structured variables, possibly using an object model to separate a variable s implementation from its interface. Acknowledgements This work supported by grant of the Swedish Research Council (VR). The author would like to thank J-N. Monette for his many helpful comments, and for his frequent coding and debugging support.

5 References 1. Grégoire Dooms, Yves Deville, and Pierre Dupont. CP(Graph): Introducing a Graph Computation Domain in Constraint Programming. In: CP Ed. by Peter van Beek. Vol LNCS. Springer, 2005, pp Carmen Gervet. Constraints over Structured Domains. In: Handbook of Constraint Programming. Ed. by Francesca Rossi, Peter van Beek, and Toby Walsh. Amsterdam: Elsevier, Chap. 17, pp Carmen Gervet. New structures of symbolic constraint objects: sets and graphs. In: Workshop on Constraint Logic Programming (WCLP 93). Extended Abstract Jean-Noël Monette, Pierre Flener, and Justin Pearson. Towards Solver- Independent Propagators. In: CP Ed. by Michela Milano. Vol LNCS. Springer, Jean-François Puget. Set Constraints and Cardinality Operator: Application to Symmetrical Combinatorial Problems. In: Workshop on Constraint Logic Programming (WCLP 93) Joseph D. Scott, Pierre Flener, and Justin Pearson. Bounded Strings for Constraint Programming. In: Tools with Artificial Intelligence (ICTAI 2013). Forthcoming. IEEE, Pascal Van Hentenryck, Vijay A. Saraswat, and Yves Deville. Design, Implementation, and Evaluation of the Constraint Language cc(fd). In: Constraint Programming. Basics and Trends. Ed. by Andreas Podelski. Vol LNCS. Springer, 1995, pp