Constraint Logic Programming, Solution and Optimization: Eternity II

Transcription

1 Constraint Logic Programming, Solution and Optimization: Eternity II António Jorge Ferreira Meireles Alpedrinha Ramos 1, Daniela Filipa Portela Dias 1 1 FEUP-PL, Turma 1MIEIC3, Grupo 03, Faculdade de Engenharia da Universidade do Porto Departamento de Engenharia Informática Roberto Frias Street, Porto, Portugal {ei06033, ei06025}@fe.up.pt Abstract This article focuses on a project proposed to us in the context of Logic Programming subject and describes an optimized method to solve Eternity II puzzles. This game is an edge matching puzzle. In this project the main goal was to create some sub puzzles and solve them efficiently using Constraint Programming and PROLOG as the implementation language and the module of constraints in finite domains, clp(fd). To achieve an optimized solver, that works more efficiently, there was developed more than one solving method and was create a benchmark that exhaustively tests the different implemented methods. Keywords: Prolog, Puzzle Solvers, Constraint Programming, Eternity II, Edge Matching Puzzles. 1 Introduction In the world as we know it today, people are more and more demanding which increases the importance of optimized methods in software, games, etc. This project s main goal consists of developing a program using Constraint Logic Programming that solves a NP-complete problem, like Eternity II. For this, it was used the developing system SICStus Prolog. First it s important to understand the concept of Constraint Programming, which is a programming paradigm in which relationships between variables are defined using constraints. Constraints don t specify steps of execution, but rather the properties of a solution to be found. The host language for this project is PROLOG, so it uses Logic Constraint Programming. The two paradigms share many important features, like logical variables and backtracking. Today most Prolog implementations include one or more libraries for constraint logic programming, like the module of constraints in finite domains, clp(fd) [1]. The constraint programming approach is to search for a state of the world in which all constraints are satisfied at the same time. The constraint program searches for values for all the variables.

2 2 António Ramos, Daniela Dias As it was said before the problem which had to be solved was Eternity II, for 9 to 64 pieces, and there is no higher motivation than to try to solve one of the most famous puzzles in the world. The game Eternity II comes after Eternity I which had thousands of fans, since 8 years ago a simple student won one thousand pounds for solving the puzzle in only 5 months. The Eternity II puzzle, which was created by Christopher Monckton, is an edgematching puzzle which involves placing 256 square puzzle pieces into a 16 by 16 grid. There are 22 colors, not including the gray edges. Opposite to other puzzles which have just one solution, Eternity II may have thousands of ways to be finished; however it is not easy and can take years. The number of possible configurations for the Eternity II puzzle, assuming all the pieces are distinct, and ignoring the fixed pieces with pre-determined positions, is 256! 4 256, approximately If taking into account the fixed piece in the center and the restrictions set on the pieces on the edge the number of configurations can be: 1 4! 56! 195! 4 195, roughly [2]. "Our calculations are that if you used the world s most powerful computer and let it run from now until the projected end of the universe, it might not stumble across one of the solutions." (Christopher Monckton, The Times, in 2005) Our goal was not to solve the real Eternity II puzzle, but rather solve similar and smaller puzzles, modifying the program to work more efficiently and improving the constraints used in search for better ways to select the variables to be processed each time. This article is divided in 9 sections: section 2 describes the problem proposed in the context of Logic Programming subject and the approach used to create the program; section 3 presents all the data files used on this project and section 4 presents the decision variables used; section 5 describes the constraints that were applied to this problem and its implementation; section 6 focuses on the labeling strategy that was developed, with particularly attention to the method which variables are chosen; section 7 shows how the solution is viewed by users on the main screen; section 8 demonstrates the statistics and results obtained and, finally, section 9 is a reflection about the work, what is concluded, the advantages and limitations of this proposition and how the developed work can be improved. 2 Problem Description As it was previously said, this article focuses on a program that solves reduced puzzles of the game Eternity II, using Constraint Logic Programming. It seems impossible to use a computer to solve the real game which has 256 pieces, so this method was created to be used only in smaller puzzles. The puzzle board has N by N pieces organized in a list and the number of colors used depends on the puzzle being solved.

3 Constraint Logic Programming, Solution and Optimization: Eternity II Objective Eternity II s starts with an empty board and an amount of pieces randomly disposed. The main objective for this game is to place all the available pieces in the board, matching all the adjacent edges like it s shown in figure 1. Fig. 1 Simplified Representation of a complete 4 by 4, puzzle board and the original randomly disposed pieces (adapted from [5]) 2.2. Pieces Each puzzle piece has its edges on one side marked with different color combinations, each of which must match precisely with the respectively side of each adjacent piece when the puzzle is complete. Each piece can be used in only 4 orientations. The pieces which contain the color that is defined as border must be in the perimeter of the board. 3 Data Files To do the testing work that supports this article it were used some structured text files, adapted from the boards set available on [3] as follows: <N, NColors> <piece1color1, piece1color2, piece1color3, piece1color4> <piece2color1, piece2color2, piece2color3, piece2color4> <...> <piecenxncolor1, piecenxncolor2, piecenxncolor3, piecenxncolor4> Where: Dim is the dimension of the side of the grid. The board should have a Dim by Dim grid.

4 4 António Ramos, Daniela Dias NColors is the number of colors used in the puzzle. Each line corresponds to one piece and each integer before the comma is the color that identifies the respectively side of the piece. There should be written NxN pieces. 4 Decision Variables Using the right variables and the right domains is a big step for optimizing the problem s solution. So after thinking a lot about the program s structure it was decided that the variables used would be as follows and as it can be seen in figure 2: Rotation: It s a list that represents the rotation used for each piece. It has the size of the square dimension of the board used and its variables have a domain defined in the interval [0, 3]. Piece in Position: A list that contains the piece whose index position indicates its position in the board. The size of this list is the square dimension of the board and the domain of the variables is defined in the interval [0, Number of pieces minus 1]. Values: This list contains the colors of the pieces in their final position. These variables have a domain defined in the interval [0, Number of colors used] and its size is 4 times the square dimension of the board, because each piece is represented by its sequence of colored edges. Fig. 2 Simplified Representation of the Eternity II approach made in this project

5 Constraint Logic Programming, Solution and Optimization: Eternity II 5 5 Constraints To solve a problem in Constraint Logic Programming the most important step is to create the constraints because these steps do not only solve the puzzle but also can help optimizing the whole solution. The constraints used were: Constraint for the borders of the grid: Guaranteeing that the pieces which have the color that represent the border (gray) appear in the perimeter of the grid. Constraining Pieces to be different: Guaranteeing that do not appear any repeated pieces. Force adjacent edges to be equal: separated in to predicates that guarantee that the adjacent edges of the pieces match the exactly same color, horizontally and vertically. Association of values with the rotations of the same piece: this constraint makes sure that when a rotation is made it indicates the actual piece it was meant to refer to by associating the list with the pieces color values and the list of rotations. In this case, there is a list VPecas which has each piece represented in the following way, to make it easier to determine the rotation: [ ]. The first four elements represent the initial piece and to retrieve this piece with a rotation it s just increment the initial position of the color to the number of the rotation. Eliminating symmetries: guarantees that the solver doesn t give the same solution four times, where the only difference is that the puzzle appears each time in a rotated position. 6 Labeling Strategy In the search for optimization and more efficiency in solving the problem we have to strategies for labeling: Labeling Routine from clpfd module library: this strategy searches in the pieces in position list and in the rotations list for variables that respect all the constraints until it finds a solution. mylabel static Routine: this strategy is similar to the previously described but was implemented in a simpler way. mylabel ignores Routine: similar to mylabel static but ignores the variables defined by constraint spreading. mylabel dynamic Routine: this strategy uses a dynamic variables selection method. In variables selection options it is used the set Piece/Rotation so that when a piece is chosen into a variable, its respective rotation is also chosen. To decide the next variable to be defined, different ways were tested as the following:

6 6 António Ramos, Daniela Dias Static variables sorting using piece-rotation pair value attribution heuristics (natural list ordering, by diagonals order, by spiraling in and out of the board); Static variables sorting labeling rotations after all pieces are assigned (not ordered) A dynamic variable sorting (simple first fail and using first fail to select pairs (piece-rotation)). 7 Solution s Visualization To show the result in main screen of SICStus Prolog were the program was executed it was created a predicate desenha() that uses the lists with the colors and the pieces in the right position. The result is shown like below. desenha(+dim,+pecapos,+valores). Runtime: Results To achieve some conclusions about the methods developed there were made 25 tests for each method and each type of puzzle. In the table below we can see the average of times for each puzzle and method and in the graphic in figure 4 we can see the dispersion graphic for each method s average of times.

7 Constraint Logic Programming, Solution and Optimization: Eternity II 7 Fig. 3 Table with the average of time results for the 25 test of each method and puzzle. Fig.4 Graphic that represents the dispersion values for the method average of times

8 8 António Ramos, Daniela Dias We also evaluated methods by the number of backtrack steps so, in the table below we can see the average of backtracks for each puzzle and method and in the graphic in figure 6 we can see the dispersion graphic for each method s average of backtrack. Fig. 5 Table with the average of backtrack results for the 25 test of each method and puzzle.

9 Constraint Logic Programming, Solution and Optimization: Eternity II 9 Fig.6 Graphic that represents the dispersion values for the method average of backtracks Fig. 7 Graphic that represents the best methods for each puzzle and each color by time efficiency

10 10 António Ramos, Daniela Dias The largest bits of the graphic correspond to methods 5, 4 and 8 which proved to be the most efficient. Some tests revealed to be completely ineffective so they were ignored. Method 1: labeling by natural order. Method 2: labeling by spiral in. Method 3: labeling by diagonal. Method 4: labeling with no order. Method 5: mylabel by natural order. Method 6: mylabel by spiral in. Method 7: mylabel by diagonal. Method 8: mylabel dynamic with first fail (Piece-Rotation). Based on the developed tests we can evaluate the board by its size and number of colors, and choose the best method to solve that particular puzzle. 9 Conclusions and Future Work There is an important relationship between the board s dimension and the number of colors used, which can be used to study the problem in a way to achieve knowledge about edge matching puzzles. We were able to realize that some methods work better in some cases and others prove to be more efficient in other cases. Dynamic selection of pieces (first fail heuristics) proves to be better in cases where there is a small amount of colors in larger puzzles, because the constraint spreading is not very effective in such cases, on the other hand the sorting cost is too heavy in cases where constraint spreading is more effective, that is, puzzles with more colors. It was very difficult to prove which labeling strategy is the best, our own label creates to much backtracking, on the other hand, works faster than labeling, the reason we cannot determine, being a predefined method. The basic first fail heuristic is not a good method in solving this kind of puzzles, because in almost all cases the rotations domain is the shortest one, and rotations are the first variables to be defined, and is not effective, although, with a small tweak, first fail strategy showed impressive results when applied to a (piece-rotation) set. The piece-rotation heuristic in static selection, makes the most sense when a person is solving the puzzle, but in this case, it was proved to be wrong, and also made our tests frustrating, because we were using that heuristic in most of the static selection cases, this was proven because the no order case was more effective in puzzles with pieces that have repeated colors, this happens due to the fact that is more likely to find a piece to match an edge, if that is not defined by the rota-

11 Constraint Logic Programming, Solution and Optimization: Eternity II 11 tion, letting a wide field of possibilities, and in most cases, when the next piece is set, the rotation is limited to only one value and does not require any additional backtracking due to wrong rotation values. In this project we focused in the variables selection more than in the values selection because it seems that this process would produce more random results, and not much conclusive, but in the future that is something that can be explored by searching for the best sorting of the values. There s also another relationship that can be studied in the future that is the relationship between the spread cost and the gain in the constraining domains for different constraints and also a study about de dynamic sort cost as a way to achieve a better connection between the sorting cost and the decrease of backtracking steps that the dynamic sort may generate. In the matter of solving the original puzzle there is a possible method that caught our attention, this matter is discussed in a specific message of a discussion group [6], that is to divide eternity in smaller puzzles, to find some subsets of the original puzzle that are not the path to achieve a possible solution in order to narrow the search, it could be studied further, using this paper as a developing base. References 1. Wikipedia, Constraint Programming: 2. Wikipedia, Eternity II Puzzle, 3. Discussion group about solving eternity: 4. Eugénio Oliveira, Luís Paulo Reis, Materiais da Disciplina de Programação em Lógica, available online: 5. Eternity II: 6. Louis Verhaard, in a discussion group about solving eternity: