Journal of Artificial Intelligence Research 34 (2009) 499-520 Submitted 10/08; published 3/09 Exploiting Single-Cycle Symmetries in Continuous Constraint Problems Vicente Ruiz de Angulo Carme Torras ruiz@iri.upc.edu torras@iri.upc.edu Institut de Robòtica i Informàtica Industrial (CSIC-UPC) Llorens i Artigas 4-6, 08028-Barcelona, Spain. WWW home page: www.iri.upc.edu Abstract Symmetries in discrete constraint satisfaction problems have been explored and exploited in the last years, but symmetries in continuous constraint problems have not received the same attention. Here we focus on permutations of the variables consisting of one single cycle. We propose a procedure that takes advantage of these symmetries by interacting with a continuous constraint solver without interfering with it. A key concept in this procedure are the classes of symmetric boxes formed by bisecting a n-dimensional cube at the same point in all dimensions at the same time. We analyze these classes and quantify them as a function of the cube dimensionality. Moreover, we propose a simple algorithm to generate the representatives of all these classes for any number of variables at very high rates. A problem example from the chemical field and the cyclic n-roots problem are used to show the performance of the approach in practice. 1. Introduction Symmetry exploitation in discrete constraint satisfaction problems (CSPs) has received a great deal of attention lately. Since CSPs are usually solved using AI search algorithms, the approaches dealing with symmetries fall into two groups: those that entail reformulating the problem or adding constraints before search (Flener, Frisch, Hnich, Kiziltan, & Miguel, 2002; Puget, 2005), and those that break symmetries along the search (Meseguer & Torras, 2001; Gent, 2002). Permutations of variables, and interchangeability of values are commonly addressed symmetries for which a repertoire of techniques have been developed, most of them relying on computational group theory. On the contrary, symmetries have been largely disregarded in continuous constraint solving, despite the important growth in both theory and applications that this field has recently experienced (Sam-haroud & Faltings, 1996; Benhamou & Goualard, 2000; Jermann & Trombettoni, 2003; Porta, Ros, Thomas, & Torras, 2005). Continuous (or numerical) constraint solving is often tackled using Branch-and-Prune (B&P) algorithms (Hentenryck, Mcallester, & Kapur, 1997; Vu, Silaghi, Sam-Haroud, & Faltings, 2005), which iteratively locate solutions inside an initial domain box, by alternating box subdivision (branching) and box reduction (pruning) steps. Motivated by a molecular conformation problem, in this paper we deal with the most simple type of box symmetry, namely that in which some domain variables (i.e., box dimensions) undergo a single-cycle permutation leaving the constraints invariant. To be clear, if the cycle involves n variables, our algorithm handles the n − 1 symmetries (excluding the c 2009 AI Access Foundation. All rights reserved. Ruiz de Angulo & Torras identity) generated by this cycle by composition. Since the computational gain will be shown to be roughly proportional to n, the longest cycle appearing in the problem formulation should be chosen as input to our algorithm. This single-cycle permutation that leaves the constraints unchanged is a form of constraint symmetry in the terminology introduced by Cohen, Jeavons, Jefferson, Petrie, and Smith (2006). Note that any constraint symmetry is also a solution symmetry, but not the other way around. Thus, the symmetries we deal with are a subset of all possible solution symmetries; the advantage is that they can be assessed (although perhaps are difficult to find) from the problem formulation, therefore being operative. Our approach to exploit symmetries in continuous constraint problems requires the initial domain for the symmetric variables to be an n-cube, as it starts by subdividing this cube at the same point along all dimensions at once. Since box symmetry is a transitive relation, the subboxes resulting from the subdivision fall into equivalence classes. Then, a B&P algorithm (or any similar continuous constraint solver) is called on only the subboxes that are representatives of each symmetry equivalence class. Finally, for each solution found, all its symmetric ones are generated. Note that symmetry handling doesn’t interfere with the inside workings of the constraint solver. 2. Symmetry in Continuous Constraint Problems We are interested in solving the following general continuous Constraint Satisfaction Problem (continuous CSP): Find all points x = (x1 , . . . , xn ) lying in an initial box of Rn satisfying the constraints f1 (x) ∈ C1 , . . . , fm (x) ∈ Cm , where fi is a function fi : Rn → R, and Ci is an interval in R. The only particular feature that we require of a Continuous Constraint Solver (CCS) is that it has to work with an axis-aligned box in Rn as input. Also, we assume that the CCS returns solution boxes. Note that a CCS returning solution points is a limit case still contained in our framework. We say that a function s : Rn → Rn is a point symmetry of the problem if there exists an associated permutation σ ∈ Σm such that fi (x) = fσ(i) (s(x)) and Ci = Cσ(i) , ∀i = 1, . . . , m. We consider symmetry as a property that relates points that are equivalent as regards to a continuous CSP. Concretely, from the above definition one can conclude that • x is a solution to the problem iff s(x) is a solution to the problem. Let s and t be two symmetries of a continuous CSP with associated permutations σs and σt . It is easy to see that the composition of symmetries s(t(·)) is also a symmetry with associated permutation σs (σt (·)). An interesting type of symmetries are permutations (bijective functions of a set onto itself) of the components of x. Let D be a finite set. A cycle of length k is a permutation ψ such that there exist distinct elements a1 , . . . ak ∈ D such that ψ(ai ) = ψ(a(i+1)mod k ) and ψ(z) = z for any other element z ∈ D. Such a cycle is represented as (a1 , . . . ak ). Every permutation can be expressed as a composition of disjoint cycles (i.e, cycles without common elements), which is unique up to the order of the factors. Composition of cycles is represented as concatenation, as for example (a1 , . . . ak )(b1 , . . . bl ). In this paper we focus on a particular type of permutations, namely those constituted by a single cycle. In its 500 Exploiting Single-Cycle Symmetries simplest form1 , this is s(x1 , x2 , . . . xn ) = (xθ(1) , xθ(2) , . . . xθ(n) ) = (x2 , x3 ...xn , x1 ), where θ(i) = (i + 1) mod n. Example: n = 3, m = 4, x = (x1 , x2 , x3 ) ∈ [−1, 1] × [−1, 1] × [−1, 1], f1 (x) : x21 + x22 + x23 ∈ [5, 5] ≡ x21 + x22 + x23 = 5 f2 (x) : 2x1 − x2 ∈ [0, ∞] ≡ 2x1 − x2 > 0 f3 (x) : 2x2 − x3 ∈ [0, ∞] ≡ 2x2 − x3 > 0 f4 (x) : 2x3 − x1 ∈ [0, ∞] ≡ 2x3 − x1 > 0 There exists a symmetry s(x1 , x2 , x3 ) = (x2 , x3 , x1 ), for which there is no need of reordering the variables. The constraint permutation associated to s is σ(1) = 1, σ(2) = 3, σ(3) = 4, and σ(4) = 2. Generally there is not a unique symmetry for a given problem. If there exists a symmetry s, then for example s2 (x) = s(s(x)) is another symmetry. In general, using the convention of denoting s0 (x) the identity mapping, {si (x), i = 0 . . . n−1} is the set of different symmetries that can be obtained composing s(x) with itself, while for i > n we have that si (x) = si mod n (x). Thus, a single-cycle symmetry generates by composition n − 1 symmetries, excluding the trivial identity mapping. Some of them may have different numbers of cycles. Imagine for example that in a continuous CSP with n = 4 the permutation of variables (1 2 3 4) is a symmetry. Then, the permutation obtained by composing it twice, (1 3)(2 4), is also a symmetry of the problem, but has a different number of cycles, and the longest cycle has length two instead of four. Besides, the former permutation cannot be generated from the latter. The algorithm presented in this paper deals with all the compositions of a single-cycle symmetry, even if some of them are not single-cycle symmetries. The gain obtained with the proposed algorithm will be shown to be roughly proportional to the number of different compositions of the selected symmetry. Therefore, when several single-cycle symmetries exist in a continuous CSP problem, the algorithm should be used with that generating the most symmetries by composition, i.e., with that having the longest cycle. Note that the single-cycle permutations we are dealing with need not encompass all the problem variables, since the the remaining ones will be considered fixed (unitary cycles). 3. Box Symmetry Since continuous constraint solvers work with boxes, we turn our attention now to the set of points symmetric to those belonging to a box B ⊆ Rn . 2 Let s be a single-cycle symmetry corresponding to the circular variable shifting θ introduced in the preceding section, and B = [x1 , x1 ]×. . .×[xn , xn ] a box in Rn . The box symme1. In general, the variables must be arranged in a suitable order before one can apply the circular shifting. Thus, the general form of a single-cycle symmetry is s(x) = h−1 (g(h(x))), where h(x1 , . . . xn ) = (xφ(1) , . . . , xφ(n) ), φ ∈ Σn is a general permutation that orders the variables, and g(x1 , . . . , xn ) = (xθ(1) , . . . xθ(n) ) is the circular shifting above. Thus, the cycle ψ defining the symmetry can be expressed as ψ = φ−1 (θ(φ(·))). Since the reordering does not change substantially the presented concepts and algorithms, we have simplified notation in the paper by assuming that the order of the component variables is the appropriate one, i.e., that ψ = θ . 2. This set {s(x) s.t. x ∈ B} is also a box if s(x) = (s1 (x), . . . , sn (x)) = (g1 (xφ(1) ), . . . , gn (xφ(n) )), where si is the i-th component of s, φ is an arbitrary permutation, and gi : R → R is any function such that if I is an interval of R then {gi (x) s.t. x ∈ I} is also an interval of R. 501 Ruiz de Angulo & Torras try function S is defined as S(B) = {s(x) s.t. x ∈ B} = [xθ(1) , xθ(1) ] × . . . × [xθ(n) , xθ(n) ] = [x2 , x2 ] × . . . × [xn , xn ] × [x1 , x1 ]. The box symmetry function has also an associated constraint permutation σ, which is the same associated to s. S i will denote S composed i times. We say, then, that B1 and B2 are symmetric boxes if there exists i s.t. S i (B1 ) = B2 . Box symmetry is an equivalence relation defining symmetry equivalence classes. Let R(B) be the set of different boxes in the symmetry class of B, R(B) = {S i (B), i ∈ {0, . . . , n− 1}}. For instance, for box B 0 = [0, 4] × [2, 5] × [2, 5] × [0, 4] × [2, 5] × [2, 5], R(B 0 ) is composed of S 0 (B 0 ) = B 0 , S 1 (B 0 ) = [2, 5]×[2, 5]×[0, 4]×[2, 5]×[2, 5]×[0, 4] and S 2 (B 0 ) = [2, 5]×[0, 4]× [2, 5]×[2, 5]×[0, 4]×[2, 5]. Note that S 3 (B 0 ) is again B 0 itself and that subsequent applications of box symmetry would repeat the same sequence of boxes. We define the period P (B) of a box B as P (B) = |R(B)|. It is easily shown that R(B) = {S i (B), i ∈ {0, . . . , P (B) − 1}}. For example, for box B 0 , R(B 0 ) = {S 0 (B 0 ), S 1 (B 0 ), S 2 (B 0 )} and P (B 0 ) = 3. Box symmetry has implications for the continuous CSP, which are a direct consequence of the point symmetry case: • If there is no solution inside a box B, there is no solution inside any of its symmetric boxes either. • A box B∫ ⊆ B is a solution iff S i (B∫ ) ⊆ S i (B) is a solution box for all i ∈ {1 . . . P (B) − 1}. Sketch of proof for the first statement: Assume there is no solution inside B and there is some solution xsol inside S i (B). By definition of box symmetry there exists a point x0sol ∈ B such that xsol = si (x0sol ). Using the property highlighted in Section 2 we deduce that x0sol must be also a solution, which contradicts the hypothesis. Sketch of proof for the second statement: A solution box is a box with at least a solution point inside. Assume B∫ ⊆ B is a solution box containing the solution point xsol . Inside S i (B∫ ) there is the point si (xsol ) that, by the property highlighted in Section 2, must be also a solution. Conversely, assume now that S i (B∫ ) ⊆ B is a solution box. Thus it contains at least a solution point, xsol . By definition of symmetric box, this point has a symmetric point x0sol ∈ B∫ such that xsol = si (x0sol ). Using the property in Section 2 again we conclude that x0sol must be also a solution and, thus, B∫ is a solution box. Both statements can be rephrased as follows : • If the set of solution boxes contained in a box B is SolSet, the set of solution boxes contained in its symmetric box S i (B) is {S i (B∫ ) s.t. B∫ ∈ SolSet} This means that once the solutions inside B have been found, the solutions inside its symmetric boxes S i (B), i ∈ {1 . . . P (B) − 1} are available without hard calculations. In the following sections we will show how to exploit this property to save much computing time in a meta-algorithm that uses a CCS as a tool without interfering with it. 3.1 Box Symmetry Classes Obtained by Bisecting a n-cube The algorithm we will propose to exploit box symmetry makes use of the symmetry classes formed by bisecting a n-dimensional cube I n (i.e., of period 1) in all dimensions at the same time and at the same point, resulting in 2n boxes. We will denote L and H the two subintervals into which the original range I is divided. For example, for n = 2, we 502 Exploiting Single-Cycle Symmetries have the following set of boxes {L × L, L × H, H × L, H × H} whose periods are 1, 2, 2 and 1, respectively. And their symmetry classes are: {L × L}, {L × H, H × L}, and {H × H}. Representing the two intervals L and H as 0 and 1, respectively, and dropping the × symbol, the sub-boxes can be coded as binary numbers. Let SRn be the set of representatives, formed by choosing the smallest box in binary order from each class. For example, SR2 = {00, 01, 11}. Note that the cube I n to be partitioned can be thought of as the the set of binary numbers of length n, and that SRn is nothing more than a subset whose elements are different under circular shift. The algorithm for exploiting symmetries and the way it uses SRn are explained in the next section. Afterwards, in Sections 6 and 7, we study how many components SRn has, how they are distributed and, more importantly, how can they be generated. 4. Algorithm to Exploit Box Symmetry Algorithm 1: CSym1 algorithm. Input: A n-cube, [xl , xh ] × · · · × [xl , xh ]. A single-cycle box symmetry, S. A Continuous Constraint Solver, CCS. Output: A set of boxes covering all solutions. 5 SolutionBoxSet ← EmptySet x∗ ← SelectBisectionPoint(xl , xh ) foreach b ∈ SRn do B ← GenerateSubBox(b, xl , xh , x∗ ) SolutionBoxSet ← SolutionBoxSet ∪ ProcessRepresentative(B) 6 return SolutionBoxSet 1 2 3 4 The symmetry exploitation algorithm we propose uses the CCS as an external routine. The internals of the CCS must not be modified or known. The idea is to first divide the initial box into a number of symmetry classes. Next, one needs to process only a representative of each class with the CCS. At the end, by applying box symmetries to the solution boxes obtained in this way, one would get all the solutions lying in the space covered by the whole classes, i.e., the initial box. The advantage of this procedure is that the CCS would have to process only a fraction of the initial box. Assuming that the initial box is a n-cube covering the same interval [xl , xh ] in all dimensions, we can directly apply the classes associated to SRn . A procedure to exploit single-cycle symmetries in this way is presented in Algorithm 1. Since SRn is a set of codes —not real boxes— we need a translation of the codes into boxes for the given initial box. The operator GenerateSubBox(b, xl , xh , x∗ ) returns the box V = V1 × · · · × Vn corresponding to code b = b1 . . . bn when [xl , xh ] is the range of the initial box in all dimensions and x∗ is the point in which this interval is bisected: ( [xl , x∗ ] if bi = 0, Vi = (1) [x∗ , xh ] if bi = 1. 503 Ruiz de Angulo & Torras The point x∗ calculated by SelectBisectionPoint(xl , xh ) can be any such that xl < < xh , but a reasonable one is (xl + xh )/2. The iterations over line 4 generate a set of representative boxes such that, together with their symmetries, cover the initial n-cube. ProcessRepresentative(B) returns all the solution boxes associated to B, that is, the solutions inside R(B), or still in other words, the solutions inside B and inside its symmetric boxes. ProcessRepresentative(B) is based on the property stated at the end of Section 3, which allows to obtain all the solutions in the class of B by processing only B with the CCS. SolSet is the set of solutions found inside the representative box of the class, B. ApplySymmetry(SolSet, S i ) calculates the set of solutions of box S i (B) by applying S i to each of the boxes in SolSet. Since the number of symmetries of B is P (B), the benefits of exploiting the symmetries of a class representative is proportional to its period. x∗ Algorithm 2: The ProcessRepresentative function. Input: A box, B. A single-cycle box symmetry, S. A Continuous Constraint Solver, CCS. Output: The set of solution boxes contained in B and its symmetric boxes. 4 SolSet ← CCS(B) T otalSolSet ← SolSet for i=1: P (B) − 1 do T otalSolSet ← T otalSolSet ∪ ApplySymmetry(SolSet, S i ) 5 return T otalSolSet 1 2 3 The correctness of the algorithm is easy to check. The set of boxes in which it searches explicitly or implicitly (by means of symmetry) for solutions is U = {R(B) s.t. B is a representative}. In fact, U is the set of boxes formed by bisecting the initial box in all dimensions at the same time and at the same point. U covers the whole initial box and, thus, the algorithm finds all the solutions of the problem. Moreover, it finds each solution box only once, because the boxes in U do not have any volume in common (they share at most a “wall”). 4.1 Discussion on the Efficiency of CSYM1 The CSym1 algorithm launches the CCS algorithm on |SRn | small boxes instead of on only the original large one. Three factors affect its efficiency as compared to that of the standard approach: 1. Fraction of domain processed. Only a fraction of the original domain is directly dealt with by the CCS. This fraction is a function of the periods of the SRn components. One element of period p represents a class formed by p boxes, only one of which is processed with the CCS. Since all the boxes of the classes are of equal size, the above fraction can be calculated by dividing the number of representatives by the n| P |SRn | total number of boxes in the classes, |SR 2n = P (B) . The expected time gain P B∈SRn P (B) n is the inverse of this quantity, B∈SR denoted by IFDP (Inverse of the Fraction |SRn | of Domain Processed). When n grows (see Section 6), the majority of the elements 504 Exploiting Single-Cycle Symmetries of SRn have period n, and thus IFDP tends to n. However, for low n, IFDP can be significantly smaller than n. This is the main factor determining the efficiency of CSym1. 2. Smaller processed boxes. Since the CCS initial boxes using CSym1 are 2n times smaller than the original initial box, the average size of the boxes processed by the CCS is also smaller than in the standard case. Prune (box reduction or contraction) step is carried out more quickly on smaller boxes in Branch-and-Prune algorithms. In fact, best Branch-and-Prune algorithms have box contraction operators exhibiting second-order convergence, but this contraction rate requires small enough boxes to hold in practice. 3. Number of representatives. There is a disadvantage in fractioning excessively the initial domain. We can see this by noting that, using the original large initial box, if a contraction operator lowers the upper bound of a symmetric variable, this information could be used to lower the upper bound of the same variable in many representative boxes in SRn . As commented above, this contraction operator would act more strongly on the representatives themselves, but the “loss of parallelization” effect is anyway present. This factor is irrelevant for small-length cycle symmetries, say up to n = 6, because |SRn | is very small (see Section 6 again) as compared to the number of boxes that a CCS must process in general. However, when n approaches 20, the number of representatives begins to become overwhelming. 5. Two Illustrative Examples The two problems below have been solved with the Branch-and-Prune CCS presented by Porta, Ros, Thomas, Corcho, Canto, and Perez (2008). It is a polytope-based method similar to that of Sherbrooke E. C. (1993) with global consistency, which exhibits quadratic convergence. The machine used to carry out all the experiments in the paper is a 2.5 Ghz G5 Apple computer. 5.1 Cycloheptane Molecules can be modeled as mechanical chains by making some reasonable approximations. If two atoms are joined by a chemical bond, one can assume that there is a rigid link between them. Thus, the first approximation is that bond lengths are constant. The second one is that the angles between two consecutive bonds are also constant. In other words, the distances between the atoms in any subchain of three atoms are assumed to be constant. All configurations of the atoms of the molecule that satisfy these distance constraints, sometimes denoted rigid-geometry hypothesis, are valid conformations of the molecule in a kinematic sense. The constraints induced by the rigid-geometry hypothesis are particularly strong when the molecule topology forms loops, as in cycloalkanes. The problem of finding all valid conformations of a molecule can be formulated as a distance-geometry (Blumenthal, 1953) problem in which some distances between points (atoms) are fixed and known, and one must find the set of values of unknown (variable) distances that are compatible with the embedding of the points in R3 . The unknown distances can be found by solving a set 505 Ruiz de Angulo & Torras of constraints consisting of equalities or inequalities of determinants formed with subsets of the fixed and variable distances (Blumenthal, 1953). d2 d3 d1 d7 d5 d6 d4 Figure 1: Cycloheptane. Disks represent carbon atoms. Constant and variable distances between atoms are represented with continuous and dashed lines, respectively. Figure 2: Three-dimensional projection of the cycloheptane solutions. The lightest (yellow) boxes are the solutions found inside the representatives using the CCS (line 1 in Algorithm 2). The other colored boxes are the solutions obtained by applying symmetries to the yellow boxes (line 4 in Algorithm 2). Figure 1 displays the known and unknown distances of the cycloheptane, a molecule basically composed of a ring of seven carbon atoms. The distance between two consecutive atoms of the ring is constant and equal everywhere. The distance between two atoms connected to 506 Exploiting Single-Cycle Symmetries a same atom is also known and constant no matter the atoms. The problem in underconstrained, having an infinite number of solutions of dimensionality 1. The problem has several symmetries. We use one of them, s(d1 , . . . , d7 ) = (dθ(1) , dθ(2) , . . . , dθ(7) ) = (d2 , d3 . . . , d7 , d1 ). The length of the only cycle of this symmetry is n = 7, for which IFDP is 6.4. The number of boxes processed using the raw CCS without symmetry handling is 1269, while using CSym1 the total number is 196, giving a ratio of 6.47 ≈ IFDP. The problem is solved in 4.64 minutes using CSym1, which compares very favorably with the 31.6 minutes spent when using the algorithm of Porta et al. (2008) alone, a reduction by a factor of 6.81, slightly greater than IFDP. This means that, although the number of representatives begins to be relevant (|SR7 | = 20), factor 2 in Section 4.1 is more determining than factor 3 in the same section, since the (small) time overhead introduced by handling box symmetries is also included in the reported time. Figure 2 shows a projection into d1 , d2 and d3 of the solutions obtained using CSym1. The solutions were found inside five representative boxes of period seven, containing 16, 1, 4, 64 and 1 solution boxes, respectively, at the chosen level of resolution. The total number of solutions boxes is therefore 7(16+1+4+64+1)= 602. 5.2 Cyclic n-roots Problem The following polynomial equation system is the n = 5 instance of the so-called cyclic n-roots problem as described by Björck and Fröberg (1991). x1 + x2 + x3 + x4 + x5 = 0 x1 x2 + x2 x3 + x3 x4 + x4 x5 + x5 x1 = 0 x1 x2 x3 + x2 x3 x4 + x3 x4 x5 + x4 x5 x1 + x5 x1 x2 = 0 x1 x2 x3 x4 + x2 x3 x4 x5 + x3 x4 x5 x1 + x4 x5 x1 x2 + x5 x1 x2 x3 = 0 (2) x1 x2 x3 x4 x5 − 1 = 0 There are ten real solutions to this problem. The system has a single-cycle symmetry: s(x1 , . . . , x5 ) = (x2 , x3 , x4 , x5 , x1 ), as well as a multiple-cycle symmetry not considered in this paper. Thus, the cycle length is n = 5, |SR5 | = 8, and the IFDP is 4. When running the CCS alone using as initial box [−10, 10]5 , the number of processed boxes is 399, while exploiting the aforementioned symmetry with the CSym1 algorithm this number reduces to 66. In the last case, two solutions were found in a representative box of period 5, which through symmetry led to the ten solutions. Running times are 16.86 seconds (CCS alone) and 2.08 seconds (CSym1) giving a gain of more than eight. This is the double of the IFDP, which highlights the benefits that factor 2 in Section 4.1 can bring to the efficacy of the approach. The number of representatives is very small compared to the number of boxes processed by the CCS alone, making factor 3 in Section 4.1 irrelevant in this case. Table 1 contains the results for n=4 to n=8 of the cyclic n-roots problem in the [−10, 10]n domain, except for n=8 for which the domain was [−5, 5]8 . For n=4 and n=8 there is a continuum of solutions which, with the chosen resolution, produces 992 and 2435 solution boxes, respectively. Because of this, the number of processed boxes for n=5 is smaller than for n=4, but logically smaller also than for n=6 to n=8. Two observations can be 507 Ruiz de Angulo & Torras IFDP number of processed boxes CCS alone number of processed boxes CSym1 rate of processed boxes time CCS alone time CSym1 time gain CSym1 n=4 n=5 n= 6 n=7 2.7 1855 500 3.7 12.0 3.0 4.0 4.0 399 66 6.0 16.9 2.1 8.1 4.5 3343 510 6.6 642.0 95.8 6.7 6.4 38991 5070 7.7 20442.0 2689.7 7.6 n=8 (reduced domain) 7.1 108647 13304 8.2 227355.2 27296.5 8.3 Table 1: Results for the n-cyclic roots problem. Times are given in seconds. made. First, the time gains are always higher than the corresponding IFDP’s, implying a preponderance of factor 2 in Section 4.1 over factor 3. Second, the time gain follows rather accurately the rate between the number of processed boxes using the CCS alone and using CSym1. Tests on the cyclic n-roots problem using a classical CCSP solver, RealPaver (Granvilliers & Benhamou, 2006), have been carried out (Jermann, 2008). The results are preliminary and difficult to expose concisely, since there is a great variability depending on issues such as the pruning method used (RealPaver offers several options) and how the problem is coded (factorized or not). In every case, however, we have observed time gains greater than expected by the IFDP. 6. Analysis of SRn : Counting the Number of Classes Let us define some quantities of interest: -Nn : Number of elements of SRn . -FP n : Number of elements of SRn that correspond to full-period boxes, i.e., boxes of period n. -Nnm : Number of elements of SRn having m 1’s. -FP nm : Number of elements of SRn that correspond to full-period boxes having m 1’s. Polya’s theorem (Polya & Read, 1987) could be used to determine some of these quantities for a given n by building a possibly huge polynomial and elucidating some of its coefficients. We present a simpler way of calculating them and, at the same time, make the reader familiar with the concepts that will be used in our algorithm to generate SRn . We begin by looking for the expression of FP n . When any number of 1’s is allowed, the total number of binary numbers is 2n . The only periods that can exist in these binary numbers are divisors of n. Thus, the following equation holds: X p FP p = 2n . p∈div(n) Segregating p = n, 508 (3) Exploiting Single-Cycle Symmetries X n FP n + p FP p = 2n , (4) p FP p . n (5) p∈div(n), p<n and solving for FP n : FP n = 2n − n X p∈div(n), p<n This recurrence has a simple baseline condition: FP 1 = 2. Then, Nn follows easily from Nn = X FP p . (6) p∈div(n) Segregating p = n, a more efficient formula is obtained: Nn = 2n + n X p∈div(n), p<n n−p FP p . n (7) This formula is valid for n > 1. The remaining case is N1 = 2. n We will use similar techniques to obtain FP nm and Nnm . There are m binary numbers having m 1’s and n − m 0’s. Some of these binary numbers are circular shifts of others (like 011010 and 110100). The number of shifted versions of a binary number is the period of the box being represented by the binary number. For example, 1010, of period 2, has only another shifted version, 0101. A binary number representing a box of period p can be n seen as a concatenation of n/p numbers of length n/p = p and period p. This means that m these “concatenated” numbers are full-period, and they have n/p 1’s. Thus, the number of binary numbers of period p when shifted numbers are counted as the same (i.e., the number n m . Only common divisors of n and m, which we denote of classes of period p) is FP n/p n/p div(n, m), can be periods. Since there are p shifted versions of each binary number having period p, we can write X n n m = p FP n/p . (8) n/p m p∈div(n,m) With a change of variable f = n/p we get X f ∈div(n,m) n FP nf mf = f n . m (9) Note that the index of the summation goes through the same values as before. We can segregate the case f = 1 from the summand, X n n n FP nm + FP nf mf = , (10) f m f ∈div(n,m), f >1 and, finally, we obtain 509 Ruiz de Angulo & Torras FP nm = n m n FP nf mf X − f f ∈div(n,m), f >1 . (11) This is a recurrence relation from which FP nm can be computed using the following baseline conditions: ( 0 = 1 FP nn , FP n0 if n > 1 if n = 1 (12) Nnm is obtained adding up the number of classes of each period: Nnm = X FP nf mf . (13) f ∈div(n,m) Segregating again f = 1, a more efficient formula is obtained: Nnm = n + m X n )FP nf mf , f (14) (1 − p)FP p mp , (15) (1 − f ∈div(n,m), f >1 then carrying out the change of variable p = n/f : Nnm = n + m X n p∈div(n,m), p<n Note the change in the summation range. This equation is valid whenever m > 0 and m < n. Otherwise, Nnm = 1. It is possible to extend the concept of FP n (and FP nm ) to reflect the number of members p ): of SRn having period p (and m 1’s), which we denote Nnp (Nnm Nnp p Nnm ( 0 = FP p if p ∈ / div(n) otherwise ( 0 = FP p, mp n if p ∈ / div(n, m) otherwise (16) (17) Figure 3(a) displays the number of classes (Nn ) as a function of n. The curve indicates an exponential-like behavior. This is confirmed in Figure 3(b) using a larger logarithmic scale, in which the curve appears almost perfectly linear. Figure 4 is an example of the distribution of classes by period for n = 12. Figure 5 shows the percentage of full-period classes in SRn (100 Nnn /Nn ). One can see that the percentage of classes with period different from n is significant for low n, but approaches quickly 0 as n grows. Finally, Figures 6(a) and 6(b) display the distribution of the classes in SRn by number of 1’s for n = 12 and n = 100, respectively. The majority of the classes concentrates in an interval in the middle of the graphic, around n/2. This interval becomes relatively smaller when n grows. 510 number of classes of symmetric boxes 350 300 250 200 150 100 50 0 2 4 6 8 10 12 1x1011 1x1010 1x109 1x108 1x107 1x106 1x105 1x104 1x103 1x102 1x101 1 0 5 box dimensionality (i.e., number of variables) 10 15 20 25 30 (b) Figure 3: Number of elements of SRn as a function of n. 100 10 1 1 2 3 4 35 box dimensionality (i.e., number of variables) (a) number of classes of symmetric boxes number of classes of symmetric boxes Exploiting Single-Cycle Symmetries 5 6 7 8 9 10 11 12 box period Figure 4: Number of elements of SR12 distributed by period. 511 40 Ruiz de Angulo & Torras 7. Generating SRn , the Classes of Symmetric Boxes The naive procedure to obtain SRn would initially generate all boxes originated by bisecting a n-dimensional cube at the same point in all dimensions at the same time. Then, one should check each of the boxes in this set to detect whether it is a circular shift of some of the others. The complete process of generating SRn in this way involves a huge number of operations even for rather small dimensions. Although the SRn for a few n’s could be precomputed and stored in a database, we suggest here an algorithm capable of calculating SRn on the fly without significant computational overhead. percentage of full-period classes 100 80 60 40 20 0 2 4 6 8 10 12 14 16 18 20 box dimensionality (i.e., number of variables) Figure 5: Percentage of full-period elements in SRn as a function of n. number of classes of symmetric boxes number of classes of symmetric boxes As made for counting, we distinguish different subsets of SRn on the basis of the number of 1’s and the period: -SRnm : Subset of the elements of SRn having m 1’s. -SRpnm : Subset of the elements of SRn having m 1’s and period p. –SRpn : Subset of the elements of SRn having period p. From a global point of view, the generation of SRn is carried out as follows. First, SRn0 is generated, which is constituted always by a unique member. Afterwards, all SRnm 70 60 50 40 30 20 10 0 0 2 4 6 8 10 12 1x1027 8x1026 6x1026 4x1026 2x1026 0 0 20 40 60 80 100 number of 1´s in the code number of 1´s in the code (a) (b) Figure 6: Number of elements of SRn distributed by number of 1’s. (a) n =12. (b) n=100. 512 Exploiting Single-Cycle Symmetries for m = 1 . . . n are generated. The generation of SRnm is divided in each of the SRpnm , p ∈ div(n, m), that compose it. The algorithm ClassGen described below generates all full-period representatives for any given number of variables n > 1 and number of ones m > 0, i.e., it generates SRnnm . The representatives of a lower period p ∈ div(n, m) are obtained by concatenating one same block n/p = f times. Therefore, in order to obtain SRpnm , we generate SRpp m with our same algorithm, and then concatenate their elements f f times. Thus, without loss of generality, in what follows we describe the workings of the algorithm ClassGen when it computes codes of full period, namely n. We use a compact coding of the binary numbers representing the boxes consisting in ordered lists or chains of numbers. The first number of the code is the number of 0’s appearing before the first 1 in the binary number. The i-th number of the code for i > 1 is the number of 0’s between the (i−1)-th and the i-th 1’s of the binary number. For example, the number 0100010111 is codified as 13100. The length of this numerical codification is the number of 1’s of the codified binary number, which has been denoted by m. There are binary numbers that cannot be codified in this way, because their last digit is 0. But, except for the all zero’s case, there is always an element of its class that can be codified correctly (for example 0011 is an element of the class of 0110). As our objective is to have only a representative of each class, this is rather an advantage, because half of the boxes are already eliminated from the very beginning. The all zero’s box, SRn0 , is common to every n, and will be generated separately, as already mentioned. The codification allows to determine if a box is full-period in the same way as in the binary representation: the box has period n iff after a number of circular shifts lower than the length of the numerical chain the result is never equal to the original. For instance, the example above is full-period, but 22, corresponding to 001001, is not. The only difference is that, in the new representation, at most m shifts must be compared. The code of a box can be seen as a number of base n − m. In a full-period box, the m circular shifts of the code are different numbers, and can be arranged in strictly increasing numerical order. We will take as representative box of a class the largest element of the class when expressed as a code (which is the smallest when expressed as a binary number). For example, the class of 130 has two other elements that can be represented by our coding, 013 and 301, the latter being the chosen representative of the class. Note that a box belonging to SRnm has n − m 0’s or, equivalently, the sum of the components of the code is n − m. The output of the algorithm are all codes of length m, whose sum of components is n − m, and which are both representatives of a class and full-period. Codes of length m whose components sum up a desired number are rather easy to generate systematically. The representativeness and full-period conditions are more difficult to guarantee efficiently. We can handle them by exploiting the properties of our codes stated below, which make use of the definition of i-compability. We say that a code is i-compatible or compatible for position i if a sub-chain of it beginning at position i > 1 and ending at the last position m (thus of length m − i + 1) is strictly smaller in numerical terms than the sub-chain of the same length beginning at the first position. For example, 423423 is compatible for positions 2 and 3, but it is not 4-compatible. 513 Ruiz de Angulo & Torras Property 1 A code is a class representative and it is full-period iff it is i-compatible for all i s.t. 1 < i 6 m. Thus, instead of comparing chains of length m (i.e., the code and its shifted versions), we can determine the code validity comparing shorter sub-chains. A second property helps us to devise a still faster and simpler algorithm: Property 2 If a code is i-compatible and the sub-chain from position i to i + l is equal to the sub-chain from position 1 to 1 + l then the code is also compatible for positions i + 1 through i + l. Algorithm 3: CodeValidity algorithm. Input: A code of length m expressed as an array, A. Output: A boolean value indicating whether the code is valid, i.e., whether it is full-period and a class representative. 1 2 3 4 5 6 7 8 9 10 i←2 ctrol ← 1 V alidCode ← True while V alidCode & i < m do if A[i] > A[ctrol] then V alidCode ← F alse else if A[i] < A[ctrol] then ctrol ← 1 else ctrol ← ctrol + 1; i←i+1 /* A[i] = A[ctrol] */ if A[m] ≥ A[ctrol] then V alidCode ← F alse return ValidCode This property is interesting because it permits checking the validity of the code by travelling along it at most once, as shown in Algorithm 3. The trick is that when the decision of i-compatibility is being delayed because position i and the following numbers are the same as those at the beginning of the string, if it finally resolves positively, the compatibility for the intermediate numbers is also guaranteed. Hence, i-compatibility is either resolved with a simple comparison or it requires l comparisons. In the latter case, either the compatibility of l positions is also resolved (if the outcome is positive) or compatibility of intermediate positions doesn’t matter (because the outcome is negative and, thus, the code can be labelled non valid without further checks). A ctrol variable is in charge of maintaining the last index of the “head” sub-chain that is being compared in the current compatibility check. When examining the compatibility of the current position i, if its value is lower than that of the ctrol position, the code is for sure i-compatible and therefore we must only worry about (i + 1)-compatibility by back-warding ctrol to the first position. If the value of the ctrol position is equal to that of the current position i, the compatibility of position i is still to be ascertained, and we continue advancing the current and the ctrol positions until the equality disappears. In other words, the only condition that must be fulfilled for non rejecting as invalid a code at position i is that 514 Exploiting Single-Cycle Symmetries Algorithm 4: ClassGen algorithm. Input: The sum of the numbers that remain to be written on the right (from position pos to m), sum. The index of the next position to be written, pos. The index of the current control element, whose value cannot be surpassed in the next position, ctrol. The length of the code, m. Array where class codes are being generated, A. Output: A set of codes representing classes, SR. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 SR ← EmptySet if pos = m then if sum < A[ctrol] then A[m] ← sum SR ← {A}; /* otherwise, SR will remain EmptySet */ else if pos = 1 then LowerLimit = dsum/me U pperLimit ← sum else LowerLimit = 0 U pperLimit ← Minimum(A[ctrol], sum) for i = U pperLimit to LowerLimit do A[pos] ← i if i = A[ctrol]Sand pos 6= 1 then /* i = A[ctrol] = U pperLimit */ SR ← SR ClassGen(sum − i, pos + 1, ctrol + 1, m, A) else /* i < A[ctrol] or pos = 1 */ S SR ← SR ClassGen(sum − i, pos + 1, 1, m, A) 19 20 return SR A[i] 6 A[ctrol], (18) a condition that is transformed into A[i] < A[ctrol] when i = m to resolve the last of the pending compatibility checks. As an aside, note that our codes are more general than the raw binary numbers, and that representativeness and full-periodness are defined in the same way for both. Therefore, the three properties and the CodeValidity algorithm apply also to the raw binary numbers. A rather direct way to generate SRnnm would be to generate all the codes of length m whose sum of components is n − m (the number of zero’s when expressed as a binary number) and then filter each of them with CodeValidity. Instead, we have taken a more 515 Ruiz de Angulo & Torras efficient approach, generating only the codes that satisfy the conditions that need to be checked explicitly in CodeValidity. Therefore, Algorithm 3 (presented only for clarity purposes) is not used. Our main procedure to obtain all full-period representatives having m 1’s, i.e., SRnnm , is the recursive program presented in Algorithm 4. ClassGen(n − m, 1, 1, m, A), where A is an array of length m, must be called to obtain SRnnm , for any given n > 1, m > 0. Each call to the procedure writes a single component of the code at the position of A indicated by the parameter pos, beginning with pos = 1, which is subsequently incremented at each recursive call. The recursion finishes at the rightmost end of the code, when pos = m. The first parameter, sum, is the sum of the components of the code that remain to be written. The range of values written at each position pos is limited by LowerLimit and U pperLimit, except for the last position m. In the following we show the correctness of the algorithm by verifying that these limits are chosen to satisfy the two requirements of the code: • The sum of the numbers of any code completed by the algorithm must be n−m. First, recall that the initial call to the algorithm is done using a parameter sum = n − m. In any position 1 ≤ pos < m the number to be written must be greater than or equal to the sum of the numbers still to be written, quantity represented by sum, so that in subsequent positions it will be possible to write positive integers, or at least zeros. This condition is imposed to U pperLimit in line 9 for pos = 1 and in line 12 (juxtaposed to code validity conditions) for 1 < pos < m. The number written at pos is substracted from the sum parameter in the next recursive call. Finally, for pos = m, the only possibility to satisfy the sum condition is to assign the value of sum to the last element of the code. • The code validity conditions, just as in CodeValidity, are that the number to be written in position pos must be smaller than or equal to A[ctrol] for 1 < pos < m, and strictly lower than A[ctrol] for pos = m. These conditions are reflected in the U pperLimit assignments made in lines 12 and 3, respectively. LowerLimit is usually (pos < 1, line 4) set to the smallest possible element of the codes, 0. But at the beginning of the code (pos = 1, line 8) a more tight value can be chosen since, for a value lower than the upper rounded value dsum/me, there is no way to distribute what remains of sum among the other positions of the code without putting a value greater than the initial one, which would make any such code non-representative. The maintenance of the ctrol variable is similar to that within the CodeValidity algorithm: if we write in pos something strictly minor than A[ctrol], ctrol is back-warded to the first position. Otherwise, ctrol is incremented by 1 for the next recursive call to write pos + 1. The output of the algorithm is a list of valid codes in decreasing numerical order. For instance, the output obtained when requesting SR993 with ClassGen(6, 1, 1, 3, A) is: {600, 510, 501, 420, 411, 402, 330, 321, 312}. In this example, the only case in which the recursion arrives to pos = m without returning a valid code is the frustrated code 222, whose last number is not written because the code is not full-period. Figure 7 displays quantitative results that reflect the efficiency of ClassGen. The dashed line accounts for the complete times required to generate all the class representatives 516 Exploiting Single-Cycle Symmetries total time millions of representatives per second 1.4 20 1.2 1 15 0.8 10 0.6 total time (seconds) number of representatives (millions/second) 25 0.4 5 0.2 0 5 10 15 20 25 30 0 dimensionality (number of variables) Figure 7: Total time (dashed line) to generate SRn , and rates of generation (continuous line) of class representatives as a function of n. SRn for n = 2 to n = 30. It is worth noting that only SR30 requires more than a second to be entirely generated. The continuous line encodes the division of |SRn | by the time required to generate SRn , measured in millions of class representatives generated by second. It is evident that the efficiency of ClassGen is very high and that it even grows slightly with n. This behavior shows that the dead-ends in the recursion are statistically insignificant, which proves the tightness of the bounds used to enforce the values of the code numbers. 8. Conclusions We have approached the problem of exploiting symmetries in continuous constraint satisfaction problems using continuous constraint solvers. Our approach is general and can make use of any box-oriented CCS as a black-box procedure. The particular symmetries we have tackled are single-cycle permutations of the problem variables. The suggested strategy is to bisect the domain, the n-cube initial box, simultaneously in all dimensions at the same point. This forms a set of boxes that can be grouped in box symmetry classes. A representative of each class is selected to be processed by the CCS and all the symmetries of the representative are applied to the resulting solutions. In this way, the solutions within the whole initial domain are found, while having processed only a fraction of it —the set of representatives— with the CCS. The time savings obtained by processing a representative and applying its symmetries to the solutions tend to be proportional to the number of symmetric boxes of the representative. Therefore, symmetry exploitation is complete for full-period representatives, since they have the maximum number of symmetric boxes. Another factor that improves the efficiency above what could 517 Ruiz de Angulo & Torras be expected by these considerations is the smaller average size of the boxes processed by the CCS with our approach. We have also studied the automatic generation of the classes resulting from bisecting a n-cube and analyzed their numerical properties. The algorithm for generating the classes is very powerful, eliminating the convenience of any pre-calculated table. The numerical analysis of the classes revealed that the average number of symmetries of the class representatives tends quickly to n as the number of variables, n, grows. This is good news, since n is the maximum number of symmetries attainable with single-cycle symmetries of n variables, leading to time reductions by a factor close to n. Nevertheless, for small n there is still a significant fraction of the representatives not having the maximum number of symmetries. Another weakness of the proposed strategy is the exponential growth in the number of classes as a function of n. The problems with small and large n should be tackled with a more refined subdivision of the initial domain in box symmetry classes, which is left for near future work. We are also currently approaching the extension of this work to deal with permutations of the problem variables composed of several cycles. Another complementary research line is the addition of constraints before the search with the CCS. These constraints will be specific for each symmetry class. Finally, the extension to Branch-and-Bound algorithms for nonlinear optimization could be envisaged. Acknowledgments This is an extended version of work presented at CP 2007 (Ruiz de Angulo & Torras, 2007). The authors acknowledge support from the Generalitat de Catalunya under the consolidated Robotics group, the Spanish Ministry of Science and Education, under the project DPI200760858, and the “Comunitat de Treball dels Pirineus” under project 2006ITT-10004. References Benhamou, F., & Goualard, F. (2000). Universally quantified interval constraints. In Springer-Verlag (Ed.), CP ’02: Proceedings of the 6th International Conference on Principles and Practice of Constraint Programming, pp. 67–82. Björck, G., & Fröberg, R. (1991). A faster way to count the solutions of inhomogeneous systems of algebraic equations, with applications to cyclic n-roots. J. Symb. Comput., 12 (3), 329–336. Blumenthal, L. (1953). Theory and aplications of distance geometry. Oxford University Press. Cohen, D., Jeavons, P., Jefferson, C., Petrie, K. E., & Smith, B. M. (2006). Symmetry definitions for constraint satisfaction problems. Constraints, 11 (2-3), 115–137. Flener, P., Frisch, A., Hnich, B., Kiziltan, Z., & Miguel, I. (2002). Breaking row and column symmetries in matrix models. In CP ’02: Proceedings of the 8th International Conference on Principles and Practice of Constraint Programming, pp. 462–476. Springer. 518 Exploiting Single-Cycle Symmetries Gent, I. P. (2002). Groups and constraints: Symmetry breaking during search. In In Proceedings of CP-02, LNCS 2470, pp. 415–430. Springer. Granvilliers, L., & Benhamou, F. (2006). Realpaver: An interval solver using constraint satisfaction techniques. ACM Trans. on Mathematical Software, 32, 138–156. Hentenryck, P. V., Mcallester, D., & Kapur, D. (1997). Solving polynomial systems using a branch and prune approach. SIAM Journal on Numerical Analysis, 34, 797–827. Jermann, C., & Trombettoni, G. (2003). Inter-block backtracking : Exploiting the structure in continuous csps. In In: 2nd International Workshop on Global Constrained Optimization and Constraint Satisfaction, pp. 15–30. Springer. Jermann, C. (2008). Personal communication.. Meseguer, P., & Torras, C. (2001). Exploiting symmetries within constraint satisfaction search. Artif. Intell., 129 (1-2), 133–163. Polya, G., & Read, R. (1987). Combinatorial enumeration of groups, graphs and chemical compounds. Springer-Verlag. Porta, J. M., Ros, L., Thomas, F., Corcho, F., Canto, J., & Perez, J. (2008). Complete maps of molecular loop conformational spaces. Journal of Computational Chemistry, 29 (1), 144–155. Porta, J. M., Ros, L., Thomas, F., & Torras, C. (2005). A branch-and-prune solver for distance constraints. IEEE Trans. on Robotics, 21, 176–187. Puget, J.-F. (2005). Symmetry breaking revisited. Constraints, 10 (1), 23–46. Ruiz de Angulo, V., & Torras, C. (2007). Exploiting single-cycle symmetries in branchand-prune algorithms. In CP ’07: Proceedings of the 13th International Conference on Principles and Practice of Constraint Programming, pp. 864–871. Sam-haroud, D., & Faltings, B. (1996). Consistency techniques for continuous constraints. Constraints, 1, 85–118. Sherbrooke E. C., P. N. M. (1993). Computation of the solution of nonlinear polynomial systems. Computer Aided Geometric Design, 10, 379–405. Vu, X.-H., Silaghi, M., Sam-Haroud, D., & Faltings, B. (2005). Branch-and-prune search strategies for numerical constraint solving. Tech. rep. LIA-Report 7, Swiss Federal Institute of Technology (EPFL). 519

Download PDF

- Similar pages
- product file SYM-IB
- AMAG EN-7531HD IP cameras datasheet
- AMAG EN-7566HD IP cameras datasheet
- AMAG EN-7546HD IP cameras datasheet
- AMAG EN-7510HD IP cameras datasheet
- AMAG EN-7512HD IP cameras datasheet
- datasheet for NZ2520SG by Nihon Dempa Kogyo Co., Ltd. (NDK)
- Equip High Speed HDMI Cable
- Equip 1.8m HDMI m/m