;;
;; Method
;; ======
;; A 'square' is a box containing a number or blank. The grid is 9x9 squares.
;; A 'box' is a sub-grid of 3x3 squares. The grid is 3x3 boxes.
;;
;; Each square on the grid is given a row, a column and a Box
;; Rows and columns 1 - 9 and the boxes are:
;;  
;;
;; +-------+-------+-------+
;; |       |       |       | 
;; |   A   |   B   |   C   | 
;; |       |       |       | 
;; +-------+-------+-------+
;; |       |       |       | 
;; |   D   |   E   |   F   | 
;; |       |       |       | 
;; +-------+-------+-------+
;; |       |       |       | 
;; |   G   |   H   |   I   | 
;; |       |       |       | 
;; +-------+-------+-------+
;;
;; This makes it easy to retrieve boxes rows and columns
;; without continually calculating the position.
;;
;; Each box is given a list of possibles. Namely: (1 2 3 4 5 6 7 8 9)
;;
;; Setting a number
;; ================
;; As a number is set in a square, it's row, column and box are all retrieved
;; and each square has the number removed from it's list of possibles.
;; So if a '3' is set in a square, then the squares in the relevent
;; box, row, column will have the possibles set to:
;; (1 2 4 5 6 7 8 9)
;;
;; That is the basis of it.
;;
;; So the algorithm is.
;; Start out with blank squares and set all with possibles: (1 2 3 4 5 6 7 8 9)
;;
;; 1. Set the given squares first, which removes many possibles.
;;
;; 2. After this, some squares may have only 1 possible (definites), check for 
;;    this and set if found. (see: 'Setting a number')
;;
;; 3. Now we go through each box, column and row and for 1 to 9,
;;    find any numbers where there is only 1 valid possible square
;;    If so set the number in that square.
;;
;; 4. Check to see boxes to see if a number occurs only in one row or
;;    column, if so can discount the row or column from other boxes.
;;
;;
;;
;;
;; eg:
;; +-------+-------+-------+
;; |       |       |       | 
;; |       |       |       | 
;; |       |       |       | 
;; +-------+-------+-------+
;; |       |       |       | 
;; |       |       |       | 
;; |       |       |       | 
;; +-------+-------+-------+
;; |       |       |       | 
;; |       |   3   |   3   |  ---->  can discount this row for 3 in other 
;; |       |       |       |         boxes with the same row
;; +-------+-------+-------+
;;
;;  Go back to step 2.
;;
;; Most are solved in < 3 Iterations.
;;
;; Guessing
;; ========
;; If it cannot be solved logically then we move on to guess work:
;; The guess goes by selecting blank squares in order of least possibles.
;;
;; The first number of the first square on the list is set and the logical
;; attempts at solution are tried. If it stalls, it guesses another for 
;; the next square.
;;
;; If the guessed number causes an invalid grid (an exception is thrown)
;; then we wind back and remove that possibility from the grid.
;;
;; Usually, there will be blanks with only two possibilities.
;; So this greatly reduces the amount of guesswork needed. 
;; If a square has possibles of (1,3) say, that's only two guesses
;; (it MUST be 1 or 3 otherwise it's an invalid puzzle)
;; One guess usually re-starts the puzzle enough to solve it.
;;
;; Guessing does not produce multiple solutions, only the first one found.
;; As this program was designed primarily as a logical rather than random
;; solution, producing multiple solutions is not of considered.
;;