Maximum Density Still Life

Transcription

1 The Hebrew University of Jerusalem Computer Science department Maximum Density Still Life Project in course AI Mohammad Moamen

2 Table of Contents Problem description:... 3 Description:... 3 Objective Target:... 4 Examples of optimal solutions:... 4 Algorithms:... 5 Introduction & Problem Representation: Naïve Algorithm: Improved Naïve Algorithm: Weighted Approach Algorithm: Randomization Algorithm: Genetic Algorithm: Linear/Integer Programming Algorithm: Summary Naïve Algorithm: Improved Naïve Algorithm: Weighted Approach Algorithm: Randomization Algorithm: Genetic Algorithm: Linear/Integer Programming Algorithm: Appendix: Matrix validity checker: The Naïve way algorithm: Improved Naïve: Weighted Approach algorithm: Randomization Algorithm: Genetic Algorithms: Linear/Integer Programming Algorithm:... 25

3 Problem description: Description: This problem arises from the Game of Life, invented by John Horton Conway in the 1960s and popularized by Martin Gardner in his Scientific American columns. Game of Life is played on a squared board, considered to extend to infinity in all directions. Each square of the board is a cell, which at any time during the game is either alive or dead. A cell has eight neighbors: The configuration of live and dead cells at time t leads to a new configuration at time t+1 according to the rules of the game: if a cell has exactly three living neighbors at time t, it is alive at time t+1 if a cell has exactly two living neighbors at time t it is in the same state at time t+1 as it was at time t otherwise, the cell is dead at time t+1 A stable pattern, or still-life, is not changed by these rules. Hence, every cell that has exactly three live neighbors is alive, and every cell that has fewer than two or more than three live neighbors is dead. (An empty board is a still-life, for instance.)

4 Objective Target: What is the densest possible still-life pattern, i.e. the pattern with the largest number of live cells that can be fitted into an n x n section of the board, with all the rest of the board dead? Examples of optimal solutions: Maximum density still life board for 3x3 game board: Maximum density still life board for 8x8 game board:

5 Algorithms: Introduction & Problem Representation: The problem is represented for the algorithms as a two dimensional array that contains 0,1 where 0 represents a dead cell and 1 represents a live cell, and at the end of the algorithm execution all the remaining 1 s represent the immortal cells and all the 0 s represent the un revivable cells. Algorithms 1-5 use a board validity check that costs O(n*m) where n represents the board height and m represents the board width since they going over all the cells and validate that each one of them fulfill all the constraints of the game. Here are the algorithms we implemented and used for solving the Maximum Density still Life problem: 1. Naïve Algorithm: This algorithm behaves naively, where it goes over all the possible solutions for a given board and finds the maximum valid one. Going over all the possible solutions cost ( * ) 2 n m ( n* m) one costs O(n*m), so the cost of this algorithm is O( 2 * n* m ). and checking the validity of each 2. Improved Naïve Algorithm: This algorithm behaves like the Naïve algorithm but it adds some improvements in computing the possible solutions. It goes over only the possible solutions which have 1 s more than half of board cells, according to Bosch and Trick in their paper Constraint Programming and Hybrid Formulation for Life the maximum density in infinite boards is ½ so in finite boards it s more than ½ therefore the optimal solution for a finite board must

6 contain at least live cells for half of the board, so this algorithm discards all the possible solutions that contain live cells less than ½ of total number of cells. The complexity of this algorithm is the same of the Naïve algorithm, but its total run time is less than Naïve algorithm total run time. 3. Weighted Approach Algorithm: This algorithm behaves like the Naïve algorithm, but with some space cost optimizations. In the Weighted Approach algorithm the problem is represented using boards weights, each board is represented by a binary representation, i.e. each cell will have a weight according to its location by the formula i* m j 2 for cell (i,j) where i,j are 0 based indices, for example 3x3 board weights are as following: Each board is represented by the sum of all its live cells, so the board will be represented by an integer number instead of n*m array. The algorithm complexity is the same as Naïve algorithm, but its space complexity is much less that Naïve algorithm one.

7 Naïve Improved Naïve Weighted Cells x3 4x4 5x5 Comparison between Naïve, Improved Naïve, and Weighted Approach algorithms according to total run time in milliseconds as a function of matrix dimensions. 4. Randomization Algorithm: The Randomization algorithm generates specific number of boards randomly and finds the valid board with maximum live cells if any. This algorithm does not promise an optimal solution, but increasing iterations number (generated random matrices) will increase the probability of finding an optimal solution. For 3x3 matrix a 200 iterations will promise finding an optimal solution with a high confidence, for 4x4 matrix a iterations will promise finding an optimal solution with a high confidence, and square matrixes with dimensions more than 4x4 will find an optimal solution with a little chance. Complexity of this algorithm is k 2 2 * m * n where k is the number of iterations.

8 # Generated random boards Board Size Optimality (% optimal solutions found in all iterations) Time Average (ms) x % x4 0.99% x % x6 N/A x % x4 0.98% x5 N/A x6 N/A x3 64.4% x4 0.96% x5 N/A x6 N/A Statistics for 100 samples/executions of the Randomization algorithm: 5. Genetic Algorithm: The genetic algorithm selects a sub problems from the original problem by dividing the matrix rows to two parts, generates the randomization algorithm on each sub problem for some iterations, if it finds an optimal solution for the subproblems then it will merge by choosing the selection point as the cross-over point. Here are some measurements we did using our implementation that compares algorithm executions with different life board dimensions and different generations number, i.e. the solution quality is compared to the optimal solution in the appropriate number of generations.

9 Board Size Optimal solution size Generations 1000 Generations Total time (for generations) Total time (for 1000 generations) 3x % 100% 5 0 4x % 100% x % 81% x % 70.8% Using the method generate (i.e. dividing the board into two parts). Board Size Optimal solution size Generations 1000 Generations Total time (for generations) Total time (for 1000 generations) 3x % 100% 2 0 4x % 29% x % 98% x % 78.3% x % 48.67% x % 52% Using the method generate2 (i.e. dividing the board into 4 sub boards):

10 6. Linear/Integer Programming Algorithm: In Linear/Integer Programming algorithm the problem we are trying to optimize is formulated as an integer programming problem. Game constraints can be formulated according to the following formulations: Life [i,j] = 1 Life [i,j] = 0 Life is a 0-1 matrix which is 1 if the cell is living and 0 otherwise. Neighbor is a set of a set giving the offsets to find the neighbors of a cell. These two formulations which are represent the game constrains can be formulized as integer programming constraints as follows according to Bosch in the paper Integer programming and Conway's game of Life: 1. Let x(ij) be 1 if cell (i,j) is alive and 0 otherwise. Let N(i,j) represent the cells that are neighbors of (i,j). 3x ij x kl ( k, l) N ( i, j) 6 This constraint enforces the "death by overcrowding condition": if a cell is alive, then at most 3 of its neighbors are alive. It is straightforward to see that if the cell is dead, then at most six of its neighbors are alive (otherwise another cell would be overcrowded). 2. to handle the "death by isolation condition", the following constraint suffices: 2x ij x kl ( k, l) N ( i, j) 0 If a cell is alive then at least two of its neighbors are also alive.

11 3. To prohibit violations of the birth rule, we need a somewhat more complicated constraint. Let S be a 3 element subset of N(i,j). then we need: x ij x kl ( k, l) S x kl ( k, l) N ( i, j) S 2 In other words, if all of S is alive, then either (i,j) is alive or some element of N(i,j)-S is alive. This formulation is sufficient to define an integer programming formulation for this problem. 4. Since the problem is formulated as integer programming then life(i,j) = 0 or 1, in other words this is a binary integer programming. 5. Each cell in life matrix is a variable in the integer programming problem, and each variable is binary according to (4). Max 6. The objective function is x ij ( i, j) board Note: We solved the integer programming problem in our code using third party libraries: Name License Brief info Link LP_Solve LGPL User-friendly linear and integer programming solver. Also provides DLL for program integration.

12 Linear Programming x3 4x4 5x5 6x6 7x7 8x8 9x9 10x10 Linear Programming algorithm results: total run time in milliseconds as a function of matrix dimensions.

13 Summary Before we start analyzing each approach and heuristics we first show few numbers to know how the problem we dealing with is hard. Let s suppose that m = n (for simplicity and w.l.o.g), then if the board size is n*n there is 2 2 n possible boards. Board Size Possible Situations 3x x x x x * 10 8x * 10 9x * 10 10x * Naïve Algorithm: The Naïve approach, as it is called, naïve. However, this approach is not useful and according to that table it is impossible to solve when the board of size 7x7 (we hadn t try 6x6 since it is need few days according to the naïve time complexity). The only advantage in this approach, that the implementation is easy and can solve limited problems. 2. Improved Naïve Algorithm: Even if it is called improved, it is still naïve. However, there is an improvement in the total run time compared to the Naïve algorithm. But it s still not helpful larger problems.

14 3. Weighted Approach Algorithm: There is nothing special in the running comparing to the algorithms in 1 and 2, but the only advantage that the space complexity is linear comparing to the last two cases. This approach implements a nice idea of encoding and decoding the matrices, it is not very useful in our problem, but we believe it might be useful and helpful in some other problems. 4. Randomization Algorithm: Why randomization? Randomization generates quick optimal solutions for small boards, faster than the three last approaches. We have used the approach to find optimal or sub optimal solutions in small boards quickly to be used in the genetic algorithm. In the other hand, it is hard to find a solution for big boards (5x5 or bigger). Main advantage, low complexity (depends on the loops number multiplied by the board size) and constant space. 5. Genetic Algorithm: We believe that genetic algorithms is a powerful tool to solve problems, usually, it doesn t provide optimal solutions but it provides solutions that almost optimal. In our small research in the genetic approach, we believe that this approach is fast and provides good sub optimal solutions in a constant memory. The running time is determined according to the generation we wish to generate. How to divide the big matrix into sub matrices and where to merge (depends on the original matrix size) this is important parts in the solution.

15 6. Linear/Integer Programming Algorithm: The constraints of our problem as a SCP problem can expressed by an Integer programming problem by defining each cell in the life board as a binary variable to be optimized for finding optimal solution. For each cell we defined 3 constraints in addition to binary constraint (that variables are binary and can get only 0 or 1), so we have total of 3*n*m constraints and n*m variables. Linear programming finds only optimal solutions, and not sub-optimal. Also it is faster than previous algorithms since there are many known algorithms for solving linear and integer programming like Simplex algorithm. Using the Linear/Integer algorithm we could run our implementation and get an optimal solution for matrixes of dimensions up to 10x10 within a few minutes, matrices with larger dimensions can be solved using this algorithm but with more total run time.