First, the domain knowledge begins with the square(X,Y) relation.  The board starts with square(1,1) to square(8,8).  Thus, there are definitions for all 64 squares.  The next piece of domain knowledge is color relation with two facts – color(white) and color(black).  The piece relation has the following facts – piece(pawn), piece(knight), piece(bishop), piece(rook), piece(queen), and piece(king).  That is the basic knowledge in the domain.

The current state of each piece on the board will be defined as four tuple relation called state.  The state fact has four elements – color, piece, square, and position.  Upon close study, one can easily derive the state relation with the first three elements easily.  The state relation was first defined in Learning Chess Patterns (Morales 1992).  The color is an element of the set of {white, black}.  The piece is an element of the set of { pawn, knight, bishop, rook, queen, king }.  The square is the piece current location from the set of { square(1,1), square(1,2), …., square(8,7), square(8,8) }.  The last element state relation is the position number.  The position is an integer in the positive integer number set and allows a history of the positions.  Without this position information, the history of the previous position is lost after the move transition.

Example 1: Describe the state of the white king located at 4,4 and the black king located at 6,6.

state(color(white), piece(king), square(4,4), position(1)).
state(color(black), piece(king), square(6,6), position(1)).

Example 2: Using the position above, update the state after the white king moves to 4,5.

state(color(white), piece(king), square(4,5), position(2)).
state(color(black), piece(king), square(6,6), position(2)).

The state will have more state relations as their more pieces in the board.

;; Terminating condition
(defrule goal-rule
?init <- (square-is 2)
=>
(printout t “Reached the goal square.” crlf)
(halt))

The execution is the same:

CLIPS> (run)
Firing rule 1.
New square is 8.
Firing rule 13.
New square is 3.
Firing rule 5.
New square is 4.
Firing rule 7.
New square is 9.
Firing rule 15.
New square is 2.
Reached the goal square.

Why an interest in expert systems? Well, IBM Watson, the Jepoardy playing computer, is a high end expert system using statistical inference (possibly bayes net) to find questions to Jepoardy topics. I was also interest in Watson’s capabilities. Also, AL3 is an expert system as well as PARADISE. My interest is in designing a knowledge based chess playing program with the capability of playing like a human chess player using rule based knowledge to solve positions as well as adding new knowledge based on relational learning.

To begin I wrote a knight’s tour program for a 3×3 grid based on Luger’s example. Upon loading the file into CLIPS shell, I ran the reset command and the run command with the following output:

Firing rule 1.
New square is 8.
Firing rule 13.
New square is 3.
Firing rule 5.
New square is 4.
Firing rule 7.
New square is 9.
Firing rule 15.
New square is 2.
Reached the goal square.

This matches in the book. If you wish to follow which rules were under consideration, then use the (watch activations) option.

Below is the CLIPS version:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;  knight.clp - A simple knight's tour on a 3x3 grid.
;;;
;;;  This simple production system is based on Example 5.3.2 from
;;;  Luger and Stubblefield (1993) Artificial Intelligence:
;;;     Structures and Strategies for Complex Problem Solving.
;;;
;;;  Written by AIguy in CLIPS
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; Starting square
(deffacts initial-square
    (square-is 1))

;; Terminating condition
(defrule goal-rule
    ?init <- (square-is 2)
    =>
    (retract ?init)
    (printout t "Reached the goal square." crlf))

;; Knight moves rules
(defrule rule1
    ?init <- (square-is 1)
    =>
    (retract ?init)
    (assert  (square-is 8))
    (printout t "Firing rule 1." crlf)
    (printout t "New square is 8." crlf))

(defrule rule2
    ?init <- (square-is 1)
    =>
    (retract ?init)
    (assert  (square-is 6))
    (printout t "Firing rule 2." crlf)
    (printout t "New square is 6." crlf))

(defrule rule3
    ?init <- (square-is 2)
    =>
    (retract ?init)
    (assert  (square-is 9))
    (printout t "Firing rule 3." crlf)
    (printout t "New square is 9." crlf))

(defrule rule4
    ?init <- (square-is 2)
    =>
    (retract ?init)
    (assert  (square-is 7))
    (printout t "Firing rule 4." crlf)
    (printout t "New square is 7." crlf))

(defrule rule5
    ?init <- (square-is 3)
    =>
    (retract ?init)
    (assert  (square-is 4))
    (printout t "Firing rule 5." crlf)
    (printout t "New square is 4." crlf))

(defrule rule6
    ?init <- (square-is 3)
    =>
    (retract ?init)
    (assert  (square-is 8))
    (printout t "Firing rule 6." crlf)
    (printout t "New square is 8." crlf))

(defrule rule7
    ?init <- (square-is 4)
    =>
    (retract ?init)
    (assert  (square-is 9))
    (printout t "Firing rule 7." crlf)
    (printout t "New square is 9." crlf))

(defrule rule8
    ?init <- (square-is 4)
    =>
    (retract ?init)
    (assert  (square-is 3))
    (printout t "Firing rule 8." crlf)
    (printout t "New square is 3." crlf))

(defrule rule9
    ?init <- (square-is 6)
    =>
    (retract ?init)
    (assert  (square-is 1))
    (printout t "Firing rule 9." crlf)
    (printout t "New square is 1." crlf))

(defrule rule10
    ?init <- (square-is 6)
    =>
    (retract ?init)
    (assert  (square-is 7))
    (printout t "Firing rule 10." crlf)
    (printout t "New square is 7." crlf))

(defrule rule11
    ?init <- (square-is 7)
    =>
    (retract ?init)
    (assert  (square-is 2))
    (printout t "Firing rule 11." crlf)
    (printout t "New square is 2." crlf))

(defrule rule12
    ?init <- (square-is 7)
    =>
    (retract ?init)
    (assert  (square-is 6))
    (printout t "Firing rule 12." crlf)
    (printout t "New square is 6." crlf))

(defrule rule13
    ?init <- (square-is 8)
    =>
    (retract ?init)
    (assert  (square-is 3))
    (printout t "Firing rule 13." crlf)
    (printout t "New square is 3." crlf))

(defrule rule14
    ?init <- (square-is 8)
    =>
    (retract ?init)
    (assert  (square-is 1))
    (printout t "Firing rule 14." crlf)
    (printout t "New square is 1." crlf))

(defrule rule15
    ?init <- (square-is 9)
    =>
    (retract ?init)
    (assert  (square-is 2))
    (printout t "Firing rule 15." crlf)
    (printout t "New square is 2." crlf))

(defrule rule16
    ?init <- (square-is 9)
    =>
    (retract ?init)
    (assert  (square-is 4))
    (printout t "Firing rule 16." crlf)
    (printout t "New square is 4." crlf))

Because the current maze puzzle has only one solution, can the maze puzzle be modified to contain additional exit nodes so that the depth-first-search program can test for additional solutions?

To answer that question, a test file is generated as follows:

:- dynamic connect/2.

:- ['maze.pl'], ['search.pl'].

This file is loaded into the SWI-Prolog interpreter. The original puzzle works as expected. Then the following statement is performed to insert a new exit into the puzzle:

 assert(connect(12, finish)).

The depth-first-search program finds the new exit with the following solution:

[finish,12,18,24,30,36,35,34,28,27,26,20,14,15,21,22,16,10,4,3,9,8,2,start]

However, upon requesting additional solutions, the interpreter returns false, indication there are no additional solutions. Thus, this answers the original question. The depth-first-search program cannot find additional solutions.

After loading the programs (maze.pl and search.pl), run the search.  A brief description of the depth_first_search/4.  The first parameter is the name of the clause determining the nodes, the second argument is the name of the initial node, the third argument is the name of the terminating clause, and the fourth argument is the resulting Path in reverse order.

Note that I used SWI-Prolog for execution.

2 ?- depth_first_search(connected_to, start, end_node, Path), writeln(Path).
[finish,32,33,34,28,27,26,20,14,15,21,22,16,10,4,3,9,8,2,start]
Path = [finish, 32, 33, 34, 28, 27, 26, 20, 14|...] .

Enclosed is the modified maze.pl and search.pl programs.

% From the book
% PROLOG PROGRAMMING IN DEPTH
% by Michael A. Covington, Donald Nute, and Andre Vellino
% (Prentice Hall, 1997).
% Copyright 1997 Prentice-Hall, Inc.
% For educational use only

% MAZE1.PL
% Connectivity table for the maze in Figure 8.2

connect(start,2).        connect(1,7).
connect(2,8).            connect(3,4).
connect(3,9).            connect(4,10).
connect(5,11).           connect(5,6).
connect(7,13).           connect(8,9).
connect(10,16).          connect(11,17).
connect(12,18).          connect(13,14).
connect(14,15).          connect(14,20).
connect(15,21).          connect(16,22).
connect(17,23).          connect(18,24).
connect(19,25).          connect(20,26).
connect(21,22).          connect(23,29).
connect(24,30).          connect(25,31).
connect(26,27).          connect(27,28).
connect(28,29).          connect(28,34).
connect(30,36).          connect(31,32).
connect(32,33).          connect(33,34).
connect(34,35).          connect(35,36).
connect(32,finish).

% copied from maze.pl
connected_to(Location1,Location2) :- connect(Location1,Location2).
connected_to(Location1,Location2) :- connect(Location2,Location1).

% end_node test (borrell)
end_node(finish).

/*
* Artificial Intellegence Techniques in Prolog
* Chapter 2: Search
*/

/*
* Depth-first search
* Arguments: arc function(+), start node(+), goal predicate(+)
* solutions (i.e., path from the start node to a node satisfying the goal
*            predicate)-
*/

depth_first_search(Arc, Start, GoalPred, Sol) :-
dfs(Arc, [[Start]], [], GoalPred, Sol).

/*
* The second argument to the dfs is the OPEN stack.
* The third argument is the CLOSED stack.
*/

dfs(_,[[Node|Path]|_], _, GoalPred, [Node|Path]) :-
call(GoalPred, Node).

dfs(Arc, [[Node|Path]|MoreOPEN], CLOSED, GoalPred, Sol) :-
findall([Next, Node|Path],
(call(Arc, Node, Next),
\+(member([Next|_],[[Node|Path]|MoreOPEN])),
\+(member(Next, CLOSED))),
NewPaths),
append(NewPaths, MoreOPEN, NewOPEN),
dfs(Arc, NewOPEN, [Node|CLOSED], GoalPred, Sol).

Also, I am continuing studying and working problems using the Poisson process and Bayes Theorem.  After taking the break, I had not lost any concepts that I had learned earlier.  The book does have a table of Poisson probabilities, which does save time.

My current goals to finish what I have started in terms of Prolog, LISP, and Bayes Theorem as well continue to read interesting AI articles.

I want to thank my readers for supporting this blog.

From video lectures I have started watching an An Introduction to Statistical Relational Learning by Dr. Lise Getoor and Policy Gradient Reinforcement Learning by Dr. Douglass Aberdeen.  From the NIPS 2009 conference, I watched Bootstrapping from Game Tree Search, and consequently the article.

Of course, the 2010 ICML and COLT conferences were held in Haifa, Isreal.

From a blog statistical point of view, the number of hits started very hot, but then cooled off during final 18 days of the month.  This is the 13th month in a row in which this blog has over 300 hits.  Since this blog has been hosted by WordPress, the grand total of hits reached over 7,000.

Finally, I want to thank the readers for their positive comments, encouragement,  and subscription to this blog.