Solving Sudoku Using Artificial Intelligence

Transcription

1 Solving Sudoku Using Artificial Intelligence Eric Pass BitBucket: Demo:

2 Background Overview Sudoku problems are some of the most recognizable and popular puzzle games played around the world. A standard Sudoku puzzle is a two dimensional square grid containing 81 cells which are well distributed in 9 rows and 9 columns. The grid is further divided into 9 smaller squares called units which contain 9 cells each. (Zhai and Zhang) For the discussion in this paper, we will denote a puzzle of size or order N to mean a Sudoku puzzle that has N columns, N rows and N units. Figure 1: A 9 by 9 Sudoku Puzzle with a unit highlighted in light blue. The rules of Sudoku are an extension of the rules used in the Latin Square puzzles. (Soedarmadji and Ouaknine) The rules for a general N by N Sudoku puzzle are: 1. All of the N*N squares must be assigned a single value from 1 to N. 2. Each row must contain each number from 1 to N exactly once. 3. Each column must contain each number from 1 to N exactly once. 4. Each unit must contain each number from 1 to N exactly once. Even though the rules of Sudoku are incredibly simple, the task of correctly completing a partially filled Sudoku puzzle is exceedingly difficult. Felgenhauer and Jarvis calculate in their paper Enumerating Possible Sudoku Grids that there are x valid 9 by 9 Sudoku puzzles.

3 (Felgenhauer and Jarvis) Since the state space is so enormous, considerable effort has to go into developing algorithms which will yield a correct solution in a reasonable amount of computing time. Complexity of Sudoku In 2002, Yato and Seta at The University of Tokyo proved, by reducing Sudoku into a Latin square completion problem, that Sudoku is NP-Complete. (Yato T. and Seta) The assertion that Sudoku is NP- Complete indicates that it is possible to reduce Sudoku in polynomial time to another NP-Complete problem. Two common and natural reductions are reducing Sudoku to an exact cover problem and reducing Sudoku to a Boolean satisfiability problem. Sudoku as an Exact Cover Donald Knuth in his Dancing Links paper explains the exact cover problem very intuitively. The problem statement is: Given a matrix of 0s and 1s, does it have a set of rows containing exactly one 1 in each column? For example, the matrix Figure 2: An example exact cover problem matrix from Donald Knuth s paper Dancing Links. has such a set (rows 1, 4, and 5. (Knuth) Sudoku can be reduced to an exact cover problem; for a 9 by 9 puzzle, the matrix has 729 rows and 324 columns. The rows of this matrix encode information about what value is assigned to a given row and column. Since, for a 9 by 9 puzzle, there are 9 possible values which could occupy any of the 9 columns and any of the 9 rows we have a total number of 9*9*9 = 729 rows in this matrix. The columns of this matrix encode the four constraints of the problem that each cell must be assigned a single value between 1 and 9 and every row, column and unit must contain exactly one instance of each number between 1 and 9. This means there is a total of 4*9*9 = 324 columns in this matrix. Once Sudoku has been reduced to an exact cover problem, one can use various algorithms like Donald Knuth s Algorithm X which utilize the Dancing Links technique to solve these problems.

4 Sudoku as a SAT Problem Sudoku can just as easily be encoded as a Boolean Satisfiability Problem (SAT). In order to represent Sudoku as a SAT problem, one will need a considerable number of propositional variables. We will denote S i,j,z to be assigned true if and only if the cell at row i and column j is assigned value z. This means for a 9 by 9 Sudoku puzzle we will need 729 different propositional variables, the same as the number of rows in the Exact Cover reduction. Adding the constraints that each cell must contain a single value from 1 to 9 and that each row, column and unit must contain exactly one instance of each value from 1 to 9, the size of both the minimal and extended encoding can be shown to be O(n 4 ) where n is order of the Sudoku puzzle. (Lynce and Ouaknine) As explained by Lnyce and Ouaknine in their paper Sudoku as a SAT Problem the minimal encoding for a Sudoku puzzle is: By encoding Sudoku as a SAT problem, one can use various SAT solving algorithms such as the famous Davis-Putnam-Logemann-Loveland (DPLL) algorithm to solve a Sudoku puzzle. Objectives The objective of this project was to develop an interactive Sudoku solver generalized to handle N by N Sudoku puzzles in addition to creating a powerful and intuitive graphical user interface (GUI) that can be used to compare the efficiency of different Sudoku solving algorithms against a wide array of Sudoku puzzles differing in size and complexity. Overall, I met these goals by creating five different Sudoku solvers, all of which can handle N by N Sudoku puzzles, although they might not produce a solution in a reasonable amount of time. Each of the solvers can be tested interactively with a GUI I adapted and enhanced from Gilbert Le Blanc. While using the GUI, the user can manually enter in the starting clues,

5 load a puzzle from the database of a given difficulty, or generate a new puzzle specifying how many clues the puzzle should contain. Over the course of this project, I was able to experiment with different design patterns such as the Singleton, Strategy, and MVC design pattern as well as implement features that I did not intend to such as a database to load and save puzzles to. Additionally, my project can be run from the command line without a GUI as a tool to provide data, such as the number of nodes needed to explore and the time it took to find the solution, in order to analyze the performance of an AI against a large sample of Sudoku puzzles. Overall, my project which spanned 27 classes for a total of 2351 lines of code, turned out to be an enjoyable exploration into larger scale software development and an investigation into techniques to solve Sudoku puzzles utilizing artificial intelligence. Software Written Overview I utilized the Model View Controller design pattern to organize this project and create a robust GUI. There are four main packages: model, view, controller, and solvers. The state of the Sudoku puzzle is maintained in the model package comprising of two classes: SudokuPuzzle and SudokuCell. The model package also contains the implementation of the Singleton used to interface with the database in addition to other classes and enumerations such as PuzzleEntity, which is class abstracting a puzzle record in the database, and SudokuPuzzleSize, which is an enumeration of supported sizes for Sudoku puzzles encapsulating drawing logic per puzzle size. Most interestingly, the model package contains the implementation of the the puzzle generator whose implementation and performance will be discussed later in this paper. The controller and view packages contain all the code related to presenting and updating the Sudoku puzzle. These two packages are entirely GUI oriented and was written using Java Swing. If the reader interested in these details, they encouraged to view the actual code via the BitBucket link listed on the cover page of this paper. The last package is solvers, which is the home for my implementation of the five different Sudoku solvers. The solvers I implemented are all general backtracking algorithms and each will be discussed individually in terms of implementation and performance in the Solvers section. In the solvers package, I utilized the strategy design pattern to create an abstract class of a SudokuSolver of which each implementation of solver is forced to extend. The three abstract methods in SudokuSolver are the two methods for solving a Sudoku puzzle with and without a GUI to update, and a function to return the name of the solver.

6 The Sudoku Puzzle Abstraction For my implementation of a Sudoku puzzle, I chose to use a two dimensional array of SudokuCell objects. This was accomplished by having a private field in SudokuPuzzle called cells which was a two dimensional array of SudokuCell objects. The general abstraction function states that given a puzzle P where r denotes the row and c denotes the column the value of the cell P r,c, where r=0 and c=0 is the topmost left column, is represented by SudokuCell at cells[c][r] whose value is equal to P r,c. If the value of P r,c is not known then the value of the SudokuCell at cells[c][r] is set to 0. The SudokuCell object also keeps track of whether this cell was a given value in the puzzle as well as encapsulates all the logic necessary to present the cell in the GUI. Choosing a two dimensional array to represent a Sudoku puzzle was a natural abstraction. This implementation made it very easy and efficient to traverse and interact with the model. However, because I chose to use a two dimensional array, I was unable to utilize Donald Knuth s Dancing Links technique, which requires an exact cover matrix whose cells are all connected in in doubly linked list. If I had implemented the model as a matrix of doubly linked lists, I could have utilized Donald Knuth s Algorithm X which is an efficient recursive, non-deterministic, depth-first, backtracking algorithm for solving the exact cover problem. The Database and Puzzle Generation Generating a Sudoku puzzle solver was a surprisingly difficult task. My initial hope was that there would exist a general Sudoku puzzle generator which could generate puzzles of a given difficulty and size. Unfortunately, such an instrument does not exist. Stephen Ostermiller s qqwing was the closest tool available. Qqwing is a very robust Sudoku generator and solver; however, it is limited in that it can only generate 9 by 9 Sudoku puzzles. One very nice feature of qqwing is that it can generate puzzles of a specified difficulty. This is important because some Sudoku puzzles are inherently harder to solve than others and it is generally difficult to tell if a given puzzle will be trivial or hard solve. Qqwing grades a puzzle on basis of how many different Sudoku solving techniques are needed to solve that given puzzle. These techniques are used by advanced Sudoku players to solve puzzles by hand. Qqwing s grading system is based on the premise that the more techniques needed to solve a puzzle, the harder the puzzle is to solve. An interesting concept discussed in Ansotegui, et al s paper Generating Highly Balanced Sudoku Problems as Hard Problems is that certain properties such as how balanced the holes of a puzzle are distributed contributes to how hard a Sudoku puzzle is to solve. (Ansotegui, et al) Unfortunately, my generator does not utilize counting the number of different techniques to solve the puzzle nor the interesting properties such as singly, doubly and fully balanced Sudoku puzzles opting

7 instead for the naive approach of randomly generating a solved Sudoku puzzle then inserting holes into the puzzle arbitrarily. While this approach does not yield any insight to the difficulty of the puzzle, my generator can generate random puzzles for 16 by 16 Sudoku puzzles and qqwing cannot. Generating Sudoku puzzles takes a non-trivial amount of computational resources because in order to create a new puzzle, you must first solve an empty puzzle. This was the primary motivation for creating a database to store generated puzzles. Also the existence of a database also makes it easy to compare different solvers because you can ensure that they are facing the same puzzles. My database is a MySQL database with two tables PUZZLES and RUNS. I interact with the database through the DatabaseManangerSingleton class which resides in the model package. Solvers Overview For this project, I implemented five different solvers all of which are backtracking algorithms. From least sophisticated to most sophisticated, I implemented a simple backtracking algorithm, a backtracking algorithm with forward checking, an implementations of a backtracking algorithm using the minimum remaining heuristic, an implementation of a backtracking algorithm with a probabilistic heuristic, and finally a backtracking algorithms using constraint propagation. The only algorithm I can performed superbly was the constraint propagation algorithm which was able to solve an empty 25 by 25 Sudoku puzzle, which none of the algorithms other could manage. Presentation of Results Each algorithm was tested on a 2014 MacBook Pro with a 2.8 GHz Intel Core i7 processor and 16 GB of memory. Each algorithm faced the exact same puzzles in the same order. Each algorithm was presented with 200 simple, easy, intermediate and 400 expert Sudoku puzzles generated and graded by qqwing. The maximum amount of nodes for any given puzzle a solver was allowed to evaluate was 10,000,000. If a solution was not found before reach 10,000,000 nodes explored the search was aborted and the solver moved onto the next puzzle.

8 Simple Backtracking This algorithm unsurprisingly faired miserably. Simple backtracking could only solve the most basic of 9 by 9 puzzles and was almost always at magnitude of orders higher in terms of nodes explored than the other algorithms. Figure 3: Graph showing time vs. difficulty for simple backtracking algorithm. Figure 4: Graph showing number of nodes explored vs. difficulty for simple backtracking algorithm. As we can see from the two graphs, it was rare for simple backtracking to return a solution to problem of any difficulty in under 10,000,000 million nodes explored. My implementation of this simple backtracking algorithm, which is consistent with Russle and Norvig s backtracking algorithm presented on page 215 of the third edition of Artificial Intelligence a Modern Approach, enumerates all the possible values for a cell and for each assignment checks to see if this does not violate any of the constraints. If the assignment does violate a constraint, then the enumeration continues until either a valid assignment is found or all possibilities are exhausted. If a valid assignment is not identified, then the algorithm backtracks to the previous assignment and the enumeration process continues from that previous node. The fundamental problem with this algorithm is that it fails to use all of the information available. In visiting the exact same number of nodes, the simple backtracking algorithm can be dramatically improved by finding all the valid assignments of this cell and only trying those instead of checking to see if a given assignment is valid. This is exactly what is done in the forward checking backtracking solver. Overall, simple backtracking was able to solve 69% of simple puzzles, 66% of easy puzzles, 65% of intermediate puzzles, and 68% of expert puzzles exploring in an average of 2,516,820 nodes and 4,807,164 nanoseconds.

9 Forward Checking Solver The first improvement made to the simple backtracking solver was to employ forward checking. This solver is almost the exact same as the simple backtracking solver except that it only assigns values to cells it knows will preserve the consistency of the puzzle instead of checking each possible assignment. Like the simple backtracking algorithm, if a correct assignment does not exist, the algorithm backtracks to the previous cell. Figure 5: Graph showing time vs. difficulty for forward checking solver. Figure 6: Graph showing number of nodes explored vs. difficulty for forward checking solver. As a result of the improvement of forward checking, many more Sudoku puzzles can be solved; however,we are still unable to solve slightly less than 10% of each difficulty. Furthermore, we see a speedup in the time to find a solution when compared to simple backtracking by a little greater than 25%.

10 Minimum Reaming Values Heuristic The first heuristic I investigated was the minimum reaming values heuristic (MVR). This heuristic orders the search to check the puzzle from the most constrained cells, the cells with the fewest possible legal assignments, to the most unconstrained cells. By selecting the most constrained cell, you are effectively picking the variable that is most likely to cause a failure, thereby pruning the search tree. (Russell and Norvig, 216) I implemented MVR using a PriorityQueue where the cells the fewest possible assignments had the highest priority. Figure 7: Graph showing time vs. difficulty for MVR solver. Figure 8: Graph showing number of nodes explored vs. difficulty for MVR solver. The performance of the MVR solver was surprisingly good. It was able to solve all the simple puzzles, 98% of the easy puzzles and 97% of the intermediate and expert puzzles. More impressively, MVR was able to cut down the number of nodes it needed to visit in half and produced a speed up of 25% when compared to forward checking.

11 Probabilistic Heuristic The second heuristic I investigated was using a probabilistic heuristic in which out of the valid assignments for a cell, it would choose the enumerate from the least frequently assigned value to the most frequently assigned value in this puzzle. The logic for this is you know that for a N by N puzzle you need exactly N instances of every number from 1 to N. Therefore, it is more likely that the assignment of this cell falls into a less frequently assigned value than a more frequently assigned value. Figure 9: Graph showing time vs. difficulty for probabilistic solver. Figure 10: Graph showing number of nodes explored vs. difficulty for probabilistic solver. As seen above, this algorithm did not perform any better, and may be a little worst than the forward checking solver. Due to its additional memory needs and complexity, one cannot justify using this over forward checking. Constraint Propagation The last solver I implemented utilized constraint propagation. This was by far the most technically challenging solver with many small details to overlook. My implementation in addition to using constraint propagation used the MVR heuristic. The heart of this algorithm is again a PriorityQueue which contains the current valid assignments for every cell with the priority being those cells which have the fewest possible assignments. If this queue is empty, then we have found a solution to the puzzle. If the queue is not empty, then we poll the first cell off the queue and begin to enumerate through its valid assignments. It is important that before starting to go through the enumerations, that you have captured the old state of the puzzle before the start of the enumeration. After selecting a valid assignment for this

12 cell, you then traverse the puzzle and get the new possible assignments for all the cells that were effected by this assignment. You then iterate through each new assignment making sure that there is no cell that has been left without a valid assignment. If one is identified, you restore the state to before the original assignment and restart the enumeration. If an effected cell after this assignment is left with only one valid assignment, you then assign that value to that cell and collect those updates from that assignment. You continue this way until there are no more assignments or you reach a cell with no valid assignment. Figure 11: Graph showing time vs. difficulty for constraint propagation solver. Figure 12: Graph showing number of nodes explored vs. difficulty for constraint propagation solver. The performance of this algorithm was astounding as it was able to solve every 9 by 9 puzzle effortlessly averaging only 2,433 nodes explored and taking only on average only 1,478,335 nanoseconds to complete. Also, this algorithm was able to solve 16 by 16 puzzles better than all the other algorithms and it was the only algorithm able to solve an empty 25 by 25 grid. Final Thoughts This project was a fun exploration into attempting to solve the very hard and ubiquitous Sudoku puzzle. My entire project is versatile as it can be used to test Sudoku solving algorithms, draw and experiment with large Sudoku puzzles, as well as play and solve Sudoku problems by hand. My five algorithms overall did a good job and the last solver I implemented, the constraint propagation solver, is incredibly exciting. The overall performance of my algorithms are depicted in the three figures below.

13 Figure 13: Graph showing percentage solved for each solver subdivided by difficulty of the puzzle. Figure 14: Graph showing average number of nodes explored while solving a puzzle.

14 Figure 15: Graph showing average number of time for a solver to solve a Sudoku puzzle.

15 References Ansotegui C, Bejar R, Fernandez C, Gomes C, Mateu C. Generating Highly Balanced Sudoku Problems As Hard Problems. J Heuristics 2011;17: Felgenhauer B, Jarvis F. Enumerating Possible Sudoku Grids. Dresden. Sheffield, UK: University of Sheffield June 20, Dresden, Germany: TU Knuth DE. Dancing Links. arxiv:cs.ds 1, Lynce I, Ouaknine J. Sudoku as a SAT Problem. Lisbon, Portugal: Technical University of Lisbon. Oxford, UK: Oxford University Russell, Stuart J, Peter Norvig, and Ernest Davis. Artificial Intelligence: A Modern Approach. Upper Saddle River, NJ: Prentice Hall, Print. Soedarmadji E, McEliece R. Iterative Decoding for Sukoku and Latin Square Codes. Pasadena, CA: California Institute of Technology; Yato T, Seta T. Complexity and Completeness of Finding Another Solution and its Application to Puzzles. Tokyo, Japan: University of Tokyo; Zhai G, Zhang J. Solving Sudoku Puzzles Based on Customized Information Entropy. International Journal of Hybrid Information Technology. Jan 2013;6(1):77-91.