COMMON LISP

Symbolic Expressions

• The syntactic elements of the LISP programming language are symbolic expressions.– Known as s-expressions.– Both programs and data are represented

as s-expressions.– S-expressions may be either an atom or a

list.

• LISP atoms are the basic syntactic units of the language and include both numbers and symbols.

• Symbolic atoms are composed of letters, numbers, and the following non-alphanumeric characters:

* - + / @ % ^ & _ M < > ~

• Examples of LISP atoms include:

3.1416

100

X

Hyphenated -name

*some-global*

nil

• A list is a sequence of either atoms or other

lists separated by blanks and enclosed in

parentheses. Examples of lists include:

(1 2 3 4)

(tom marry john joyce)

(a (b c) (d (e f)))

( )

• Lists may be elements of lists• The empty list, “( )”, plays a special role in the

construction and manipulation of LISP data structures and is given the special name nil.

• Nil is the only s-expression that is considered to be both an atom and a list. Lists are extremely flexible tools for constructing representational structures. For example, we can use lists to represent expressions in the predicate calculus:

(on block -1 table)

(likes bill X)

(and (likes george kate) (likes bill merry))

• An important feature of LISP is its use of LISP syntax to represent programs as well as data. For example, the lists,

( * 7 9 )

( - (+ 3 4 ) 7)

• With (* 7 9) representing the product of 7 and 9.

> (* 7 9 )

63

>

• When given a list, the LISP evaluator attempts-to interpret

the first element of the list as the name of a function and

the remaining elements as its arguments.

• The value printed by LISP is the result of applying the

function to its arguments.

> (+ 14 5)

19

> (+ 1 2 3 4)

10

> (- (+ 3 4) 7)

0

> (* (+ 2 5) ) (- 7 (/ 21 7))

28

> (= (+ 2 3 ) 5))

t

> ( a b c)

Error: invalid function:a

• In evaluating a function, LISP first evaluates its arguments and then applies the function indicated by the first element of the expression to the results of these evaluations.

• If the arguments are themselves function expressions, LISP applies this rule recursively to their evaluation.

• LISP uses the convention that numbers always evaluate to themselves. If, for example, 5 is typed into the LISP interpreter, LISP will respond with 5.

• Symbols, such as X, may have a value bound to them. If a symbol is bound, the binding is returned when the symbol is evaluated.

• If a symbol is unbound, it is an error to evaluate

that symbol.

• For example, in evaluating the expression

(+ (* 2 3 ) (* 3 5))

• LISP first evaluates the arguments, (* 2 3) and (* 3 5).

• In evaluating (* 2 3), LISP evaluates the arguments 2 and 3, which return their respective arithmetic values; these values are multiplied to yield 6.

• Similarly, (* 3 5) evaluates to 15)

• These results are then passed to the top-level addition, which is evaluated, returning 21.

• LISP includes a large number of functions that operate on lists.

• These includes functions:-

– To construct and combine lists

– To Access elements of lists

– To test various properties of lists.

• For example, list takes any number of arguments and constructs a list of those elements.

• ‘nth’ takes a number and a list as arguments and returns indicated element of the list.

• By convention, nth begins counting with 0.

• Examples of these and other list manipulation functions include:

> (list 1 2 3 4 5)

( 1 2 3 4 5)

> (nth 0 ‘(a b c d)

a

> (nth 2 (list 1 2 3 4 5)

3

> (nth 2 ‘((a 1) (b 2) (c 3) (d 4)))

(c 3)

> (length (a b c d))

4

> (member 7 ‘(1 2 3 4 5))

nil

> (null ( ))

t

• A form is an s-expression that is intended to be evaluated. If it is a list, the first element is treated as the function name and the subsequent elements are evaluated to obtain the function arguments.

• In evaluating an s-expression:

– If the s-expression is a number, return the value of the number.

– If the s-expression is an atomic symbol, return the value bound to that symbol; if it is not bound it is an error.

– If the s-expression is a list, evaluate the second through the last arguments and apply the function indicated by the first argument to the results.

• The function quote is to prevent evaluation of an s-expression that should be treated as data rather than an evaluable form.

• Quote takes one argument and returns that argument without evaluating it. For example:

> (quote (a b c))

(a b c )

> (quote (+ 1 3))

(+ 1 3)

Control of LISP Evaluationquote and eval

• Because quote is used so often, LISP allows it to be abbreviated by a single quotation mark. Thus, the preceding examples could be written:

> ‘(a b c)

(a b c)

> ‘(+ 1 3)

(+ 1 3)

• Consider the effect of quote in the

following calls to the list function:

> (list (+ 1 2) (+ 3 4)

(3 7)

> (list ‘(+ 1 2) ‘(+ 3 4))

((+1 2) (+ 3 4))

• As a complement to quote, LISP also provides a function, eval.

• Eval takes one s-expression as an argument: this argument is evaluated as is usual for arguments to function; however, the result is then evaluated again and this final result is returned as the value of the eval expression.

• Examples of the behavior of eval and quote include:

> (quote (+ 2 3))

(+ 2 3)

> (eval (quote (+ 2 3)))

5

> (list ‘* 2 5))

(* 2 5)

> (eval (list ‘* 2 5 )

10

• Common LISP includes a large number of built-in functions, including:

– A full range of arithmetic functions, integer, rational, real and complex arithmetic.

– A variety of looping and program control functions

– List manipulation and other data structuring functions.

– Input/output functions

– Forms for the control of functions evaluation.

– Functions for the control of the environment and operating system.

Creating New Functions

• In LISP, we program by defining new functions.

• These new functions are defined using defun, which is short for define function.

• Once a function is defined it may be used in the same fashion as functions that are built into the language.

• For example, the user would like to define a function called square that takes a single argument and returns the square of that argument. Square may be carried by having LISP evaluate the following expression:

(defun square (X)

(* X X))

• The first argument to defun is the name of the function being defined.

• The second is a list of the formal parameters for that function, which must all be symbolic atoms.

• The remaining arguments are zero or more s-expressions, which constitute the body of the new function, the LISP code that actually defines its behavior.

• In the above example, square is defined as a function that takes one argument and returns the result of multiplying that argument by itself.

More concisely, the syntax of a defun expression is:

(defun <function name> (<formal parameters>) <function body>)

• A newly defined function may be used just like any built-in function.

• For example, that we need a function to compute the length of the hypotenuse of a right triangle given the lengths of the other two sides. This function may be defined according to the Pythagorean theorem, using the previously defined square function along with the built-in function sqrt.

(defun hypotenuse (X Y) ;the length of the hypotenuse is

(sqrt (+ (square X) ; the square root of the sum of

(square Y))) ; the squares of the other sides

• LISP branching is also based on function evaluation: control functions perform test and, depending on the results, selectively evaluate alternative forms.

• For example, the following definition of the absolute value function

(defun absolute-value (x)

(cond ((< x O) (- x))

((>= x O) x )))

Program Control in LISPProgram Control in LISP Conditionals and Predicates Conditionals and Predicates

• The example uses the function cond, to implement a conditional branch. Cond takes as arguments a number of condition-action pairs:

(cond ((condition 1) (action 1))

((condition 1) (action 1))

((condition 1) (action 1))

… …

… …

((condition n) (action n)))

• Conditions and actions may be arbitrary s-expression

• It evaluates the conditions in order until one of them returns a non-nil value.

• When this occurs, it evaluates the associated action and returns this result a side value of the cond expression.

• None of the other actions and none of the subsequent conditions are evaluated.

• If all of the conditions evaluate to nil, cond returns nil.

• An alternative definition of absolute-value is:

(defun absolute-value (x)

(cond ((< x 0) (- x)) ; if X is less than O, return -X

( t x ))) ; otherwise, return X

unchanged

• This version notes that the second condition (>= X 0), is

always true if the first is false. The “t” atom in the final

condition of the cond statement is a LISP atom that

corresponds to “true”. T always evaluates to itself.

• This construct is extremely useful, as it provides a way of

giving a cond statement a default action that is evaluated

if and only if all preceding conditions fail.

• Although any evaluable s-expressions may be used as the conditions of a cond, generally these are a particular kind of LISP function called a predicate.

• A predicate is simply a function that returns a value of either true or false depending on whether or not its arguments possess some property.

• The most obvious examples of predicates are the relational operators typically used in arithmetic such as =, >, and >=.

• Here are some examples of arithmetic predicates in LISP;

> (= 9 (+ 4 5))

t

> (> = 17 4)

t

> (< 8 (+ 4 2 ))

nil

> ( oddp 3) ;oddp tests whether its argument is odd or not.

t

> (minusp 6) ; minusp tests whether its argument is less than 0

nil

> (numberp 17) ; numberp tests whether its argument is numeric

t

> (numberp nil)

nil

> (zerop 0) ; zerop is true it its argument is 0, nil otherwise

t

> (plusp 10) ; plusp is true if its argument is strictly greater than 0

t

> (plusp -2)

nil• Note that the predicates in the above examples return t or nil.

• If form takes three arguments.

– The first is a test. If evaluates the test.

– If it returns a non-nil value, the if form evaluates its second

argument and returns the result.

– Otherwise it returns the result of evaluating the third

arguments.

• For example, absolute-value could be defined using

the if form:

(defun absolute-value (x)

(if (< x 0) (- x) x))

And form, evaluates its arguments in left-to-right order, stopping when any

one of the arguments evaluates to nil or the last argument has been

evaluated. Upon completion, the and form returns the value of the last

argument evaluated.

(AND (arg1) (arg2)…(argn))

> (and (oddp 2) (print “second statement was evaluated”))nil

> (and (oddp 3) (print “second statement was evaluated”))second statement was evaluated

OR

Or form evaluates its argument only until a non-nil value

is encountered, returning this value as a result.

(OR (arg1) (arg2)…(argn))

> (or (oddp 3) ( print “second statement was evaluated”))

t

> (or (oddp 2) (print “second statement was evaluated”))

second statement was evaluated

• The basic functions for accessing the components of lists are car and cdr.

• car takes a single argument, which must be list, and returns the first element of that list.

• cdr also takes a single argument, which must be a list, and returns that list with its first argument removed.

• For example:

> (car ‘(a b c))

a

> (cdr ‘(a b c))

(b c)

Lists as Recursive Structures

> (car ‘((a b) (c d))) ; the first element of a list may be a list

( a b)

> (cdr ‘((a b) (c d)))

((c d))

> (car (cdr ‘ (a b c d)))

b

• Common LISP includes the predicate member,

which determines whether one s-expression is a

member of a list,

• And length, which determines the length of a list.

• We may define our own versions of these functions.

• My-member takes two arguments, and arbitrary s-

expression and a list.

• It returns nil if the s-expression is not a member of

the list

• Otherwise it returns the portion of the list containing

the s-expression as its first element:

(defun my-member (element list)

(cond ((null list) nil)

((equal element (car list)) list)

(t (my-member element (cdr list)))))

My-member has the behavior:

> (my-member 4 ‘ ( 1 2 3 4 5 6))

(4 5 6)

> (my-member 5 ‘ (a b c d))

nil

• Similarly we define our own versions of length and nth:

>(defun my-length (list)

(cond ((null list) 0)

(t (+ (my-length (cdr list)) 1))))

MY-LENGTH

>(my-length '(a b c d e f g))

7

>(defun my-nth (n list)

(cond ((zerop n) (car list))

(t (my-nth (- n 1) (cdr list)))))

MY-NTH

>(my-nth 4 '(11 22 33 44 55 66 77 88))

55

cons x y

cons is the primitive function to create a

new cons whose car is x and whose cdr is y.

For example:

(cons 'a 'b) => (a b)

(cons 'a (cons 'b (cons 'c '()))) => (a b c)

(cons 'a '(b c d)) => (a b c d)

>(cons '(1 2) '(3 4))

((1 2) 3 4)

• Function cons, takes two s-expressions as

arguments, evaluates them, and returns a list

whose car is the value of the first argument and

whose cdr is the value of the second:

> (cons 1 ‘(2 3 4))

(1 2 3 4)

> (cons ‘(a b) ‘ (c d e))

((a b) c d e)

• Cons bears an inverse relationship to car and cdr:

> (car (cons 1 ‘(2 3 4)))

1

> (cdr (cons 1 ‘(2 3 4)))

(2 3 4)

• Definition of the function filter-negatives, which takes a list of numbers

as an argument and returns that list with any negative numbers

removed.

(defun filter-negatives (number-list)

(cond ((null number-list) nil)

((plusp (car number-list)) (cons (car number-list)

(filter-negatives (cdr number-list))))

(t (filter-negatives (cdr number-list)))))

This function behaves:

> (filter-negatives ‘(1 -1 2 -2 3 -4))

( 1 2 3)

Append

(append '(a b c) '(d e f) '( ) '(g)) => (a b d e f g)

>(append '(1 2) '(3 4))

(1 2 3 4)

Length

>(length '(1 2 3))

3

>(length '((1 2) 3 (1 (4 (5)))))

3

Function to Count Number of Atoms in a List

>(defun count-atoms (list)

(cond (( null list) 0)

((atom list) 1)

(t (+ (count-atoms (car list))

(count-atoms (cdr list))))))

>(count-atoms '((1 2) 3 (1 (4 (5)))))

6

Function to Flatten an Arbitrary Structure

>(defun flatten (LIST)

(cond ((null LIST) nil)

((atom LIST) (list LIST))

(t (append (flatten (carLIST))(flatten (cdr LIST))))))

>(flatten '((1 2) 3 (1 (4 (5)))))

(1 2 3 1 4 5)

>(flatten '(a (b c) (((d) e f ))))

(A B C D E F)

Binding variable using SET/SETQ(Global scope)

set ‘symbol value/s-expression

>(set 'inc 0)0

>(defun f(x)(set 'inc(+ inc 1))(+ x inc))F

>(f 1)2

>(f 2)4

setq symbol value/s-expression

>(set 'x 0)0

>(setq x 0)0

Bound and Free variables>(setq inc 23)

>(setq x 100)

>inc

23

>x

100

>(defun f(x)

(setq inc 1)

(+ x inc))

F

>(f 0)

1

>inc

1

>x

100

Bound var

Free var

Defining Local Variable Using LET

(let (<local-variables>) <expressions>)Where elements of <local-variables> are:-

–Symbolic atoms–Pairs of the form:

(<symbol><expression>)

>(setq a 0)0

>(let ((a 3) b)(setq b 4)(+ a b))

7>a0

>berror

Data Types in Common LISP

•Integers•Ratios•Floating point numbers•Strings•Characters•Symbols•Lists•Arrays •Functions•Structures•Others

Higher-Order Functions. Functions that take other functions as parameters or return them as results.

Filters

>(defun filter-negatives(number-list)

(cond((null number-list) nil)

((plusp (car number-list))(cons (car number-

list)(filter-negatives (cdr number-list))))

(t (filter-negatives (cdr number-list)))))

FILTER-NEGATIVES

>(filter-negatives '(1 -1 2 -2 3 -4))

(1 2 3)

Filters

>(defun filter-evens(number-list)

(cond((null number-list) nil)

((oddp (car number-list))(cons (car number-list)

(filter-evens (cdr number-list))))

(t (filter-evens (cdr number-list)))))

FILTER-EVENS

>(filter-evens '(1 2 3 4 5 6 7 8 9 10))

(1 3 5 7 9)

Higher-Order Functions. Functions that take other functions as parameters or return them as results.

• Because two functions differ only in the name of

the predicates used to filter elements from the

list, these can be generalized into a single

function that takes the filtering predicate as a

second parameters.

• When a function is passed as a parameter it is

preceded by a #’.

• This is defined using a LISP form called FUNCALL.

(funcall <fn> <arg1> <arg2> ... <argn>)

• FUNCALL applies the function fn to the arguments

arg1, arg2, ..., argn.

>(funcall #'+ 1 2)

3

>(funcall #'car '(a b c))

A

>(defun filter(list-of-elements test)

(cond ((null list-of-elements) nil)

((funcall test (car list-of-

elements))(cons (car list-of-

elements) (filter (cdr list-

of-elements) test)))

(t (filter (cdr list-of-elements)test))))

FILTER

>(filter '(1 3 -9 5 -2 -7 6) #'plusp)

(1 3 5 6)

>(filter '(1 2 3 4 5 6 7 8 9 10) #'evenp)

(2 4 6 8 10)

>(filter '(1 a b 3 c 4 7 d) #'numberp)

(1 3 4 7)

APPLY

This applies function to a list of arguments.

(apply <fn> <(arg1, arg2, … , agn)>)

>(apply #'+ '(1 2))

3

>(apply #'car '((a b c)))

A

>(setq f '+)

>(apply f '(1 2))

3

>(setq f #'-)

>(apply f '(1 2))

-1

Higher-Order Functions

Maps

map result-type function sequence &rest more-

sequences

>(map 'list #'- '(1 2 3 4))

(-1 -2 -3 -4)

>(map 'list #'+ '(1 2) '(1 2))

(2 4)

>(map 'list #'evenp '(1 2 3 4 5 6 7))

(NIL T NIL T NIL T NIL)

>(map 'list #'minusp '(1 -2 3 4 -5 -6))

(NIL T NIL NIL T T)

mapcar function list &rest more-lists

mapcar operates on successive elements of the lists. First the function is applied to the car of each list, then to the cadr of each list, and so on.

>(mapcar #'abs '(3 -4 2 -5 -6))

(3 4 2 5 6)

>(mapcar #'cons '(a b c) '(1 2 3))

((a . 1) (b . 2) (c . 3))

>(mapcar #'1+ '(1 2 3 4 5 6))

(2 3 4 5 6 7)

>(mapcar #'+ '(1 2 3 4) '(5 6 7 8))

(6 8 10 12)

>(mapcar #'max '(3 9 1 7) '(2 5 6 8))

(3 9 6 8)

LAMBDA EXPRESSIONS

• In the preceding examples function arguments were

passed by their names and applied to a series of

arguments. This requires that the functions be

previously define in the global environment.

• Frequently it is desirable to pass function

definitions directly without first defining the

function globally. This is made possible through the

LAMBDA expression.

(lambda (<formal-parameters>) <body>)

• LAMBDA expression may be use in place of a function

name in a FUNCALL or APPLY.

LAMBDA EXPRESSIONS

>(funcall #'(lambda (x) (* x x)) 4)

16

>(apply #' (lambda (x y)(+ (* x x) y)) '(2 3))

7

>(funcall #' (lambda (x) (append x x)) '(a b c))

(A B C A B C)

>(funcall #' (lambda (x y) (append x y)) '(a b c)'(1 2 3))

(A B C 1 2 3)

LAMBDA EXPRESSIONS

>(funcall #'(lambda (x1 x2)(append (reverse x1) x2))

'(a b c)'(d e

f))

(C B A D E F)

>(mapcar #'(lambda(x)(* x x))'(1 2 3 4 5))

(1 4 9 16 25)

>(mapcar #'(lambda(x)(* x 2))'(1 2 3 4 5))

(2 4 6 8 10)

LAMBDA EXPRESSIONS

>(mapcar #'(lambda(x)(and (> x 0)(< x 10)))'(1 24 5 –9 8 23))

(T NIL T NIL T NIL)

>(mapcar #' (lambda (x) (list 'hi 'there x)) '(Sam Fred

George))

((HI THERE SAM) (HI THERE FRED) (HI THERE GEORGE))

LAMBDA EXPRESSIONS

>(setq y '(1 2 3))

(1 2 3)

>(setq a 100)

100

>(funcall #'(lambda (x) (* x 10)) a)

1000

>(mapcar #'(lambda (x) (* x 10)) y)

(10 20 30)

>(mapcar #'(lambda (x) (* x a)) y)

(100 200 300)

FARMER WOLF GOAT AND CABBAG PROBLEM

• A farmer comes with his wolf, goat and cabbage to the river bank he wishes to cross with above animals and vegetables.

• A boat is available to cross the river.

• Boat can carry only two things at a time including the farmer.

• If wolf is left alone with the goat, the wolf will eat the goat.

• If cabbage is left alone with the goat, the goat will eat the cabbage.

• The program searches the space in a depth-first fashion.

• States are represented as lists of four elements. Where each element denotes the location of the farmer, wolf, goat, or cabbage respectively.

• Farmer, wolf, goat and cabbage => (f w g c)

• Thus state (e w e w) represent:-

– Farmer is on the eastern bank

– Wolf is on the western bank.

– Goat is on the eastern bank.

– Cabbage is on the western bank.

;;; These functions define states of the world

;;; as an abstract data type.

(defun make-state (f w g c) (list f w g c))

(defun farmer-side ( state )

(nth 0 state))

(defun wolf-side ( state )

(nth 1 state))

(defun goat-side ( state )

(nth 2 state))

(defun cabbage-side ( state )

(nth 3 state))

;;; The function "opposite" takes a side and returns ;;; the opposite side of the river.

(defun opposite (side)

(cond ((equal side 'e) 'w)

((equal side 'w) 'e)))

;;; Safe returns nil if a state is not safe; it returns ;;;the state unchanged if it is safe.

(defun safe (state)

(cond ((and(equal(goat-side state)(wolf-side state))

(not (equal (farmer-side state) (wolf-side state)))) nil)

((and (equal (goat-side state) (cabbage-side state))

(not (equal (farmer-side state) (goat-side state)))) nil)

(t state)))

;;; These functions define legal moves in the state space

(defun farmer-takes-self (state)

(safe (make-state (opposite (farmer-side state))

(wolf-side state)

(goat-side state)

(cabbage-side state))))

(defun farmer-takes-wolf (state)

(cond ((equal (farmer-side state) (wolf-side state))

(safe (make-state (opposite (farmer-side state))

(opposite (wolf-side state))

(goat-side state)

(cabbage-side state))))

(t nil)))

(defun farmer-takes-goat (state)

(cond ((equal (farmer-side state) (goat-side state))

(safe (make-state (opposite (farmer-side state))

(wolf-side state)

(opposite (goat-side state))

(cabbage-side state))))

(t nil)))

(defun farmer-takes-cabbage (state)

(cond ((equal (farmer-side state) (cabbage-side state))

(safe (make-state (opposite (farmer-side state))

(wolf-side state)

(goat-side state)

(opposite (cabbage-side state)))))

(t nil)))

;;; The recursive path algorithm searches the space in a depth first

;;; fashion.

(defun path (state goal been-list)

(cond ((null state) nil)

((equal state goal)(reverse (cons state been-list)))

((not(member state been-list :test #'equal))

(or (path(farmer-takes-self state)goal(cons state been-list))

(path(farmer-takes-wolf state)goal(cons state been-list))

(path(farmer-takes-goat state)goal(cons state been-list))

(path(farmer-takes-cabbage state)goal(cons state been-list))))))

;;; solve-fwgc initiates the search.

(defun solve-fwgc (state goal) (path state goal nil))

THE STATE SPACEW W W W

W W E W

E E E W

E W W EE W E WE E W W E W W W

W W W W

W E W WW W E WW E E W

E W E EE W E W

W E W WW W W EW E W E

E E W EE E E WE E W W

E E E EE E W E

PATH = {(W W W W) (E W E W) (W W E W) (E E E W) (W E W W) (E E W E) (W E W E) (E E E E)}

Breadth First Search(setq *moves*

'(farmer-takes-self farmer-takes-wolf

farmer-takes-goat farmer-takes-cabbage))

(defun run-breadth (start goal)

(setq *open* (list start))

(setq *closed* nil)

(setq *goal* goal)

(breadth-first))

(defun breadth-first ()

(cond ((null *open*) nil)

(t (let ((state (car *open*)))

(cond ((equal state *goal*) 'success)

(t (setq *closed* (cons state *closed*))

(setq *open*(append (cdr *open*) (generate-descendants state *moves*)))

(breadth-first)))))))

(defun generate-descendants (state moves)

(cond ((null moves) nil)

(t (let ((child (funcall (car moves) state))

(rest (generate-descendants state (cdr moves))))

(cond ((null child) rest)

((member child rest :test #'equal) rest)

((member child *open* :test #'equal) rest)

((member child *closed* :test #'equal) rest)

(t (cons child rest)))))))

(run-breadth ‘(w w w w) ‘(e e e e))

SUCCESS

Depth First Search

(defun depth-first ()

(cond ((null *open*) nil)

(t (let ((state (car *open*)))

(cond ((equal state *goal*) 'success)

(t (setq *closed* (cons state *closed*))

(setq *open* (append (generate-descendants

state *moves*)(cdr *open*)))

(depth-first)))))))

Breadth First SearchWith Parent information Attached

(defun run-breadth (start goal moves) (declare (special *open*)) (declare (special *closed*)) (declare (special *goal*)) (setq *open* (list (build-record start nil))) (setq *closed* nil) (setq *goal* goal) (breadth-first moves))

;;; These functions handle the creation and access of (state parent) ;;; pairs.

(defun build-record (state parent) (list state parent))

(defun get-state (state-tuple) (nth 0 state-tuple))

(defun get-parent (state-tuple) (nth 1 state-tuple))

(defun retrieve-by-state (state list) (cond ((null list) nil) ((equal state (get-state (car list))) (car list)) (t (retrieve-by-state state (cdr list)))))

(defun breadth-first (moves) (declare (special *open*)) (declare (special *closed*)) (declare (special *goal*)) (cond ((null *open*) nil) (t (let ((state (car *open*))) (setq *closed* (cons state *closed*)) (cond ((equal (get-state state) *goal*)

(reverse (build-solution *goal*))) (t (setq *open* (append (cdr *open*) (generate-descendants

(get-state state)

moves))) (breadth-first moves)))))))

(defun generate-descendants (state moves) (declare (special *open*)) (declare (special *closed*)) (cond ((null moves) nil) (t (let ((child (funcall (car moves) state)) (rest (generate-descendants state (cdr

moves)))) (cond ((null child) rest) ((retrieve-by-state child rest) rest) ((retrieve-by-state child *open*) rest) ((retrieve-by-state child *closed*) rest) (t (cons (build-record child state)

rest)))))))

(defun build-solution (state) (declare (special *closed*)) (cond ((null state) nil) (t (cons state (build-solution (get-parent (retrieve-by-state state

*closed*)))))))

Best First Search

(setq *moves*

'(farmer-takes-self farmer-takes-wolf

farmer-takes-goat farmer-takes-cabbage))

(defun heuristic (state)

(heuristic-eval state *goal*))

(defun heuristic-eval (state goal)

(cond ((null state) 0)

((equal (car state) (car goal))

(heuristic-eval (cdr state) (cdr goal)))

(t (1+ (heuristic-eval (cdr state) (cdr

goal))))))

(defun insert-by-weight (children sorted-list)

(cond ((null children) sorted-list)

(t (insert (car children)

(insert-by-weight (cdr children) sorted-

list)))))

(defun insert (item sorted-list)

(cond ((null sorted-list) (list item))

((< (get-weight item) (get-weight (car sorted-

list)))

(cons item sorted-list))

(t (cons (car sorted-list) (insert item (cdr

sorted-list))))))

;;; These functions handle the creation and access of (state parent)

;;; pairs.

(defun build-record (state parent depth weight)

(list state parent depth weight))

(defun get-state (state-tuple) (nth 0 state-tuple))

(defun get-parent (state-tuple) (nth 1 state-tuple))

(defun get-depth (state-tuple) (nth 2 state-tuple))

(defun get-weight (state-tuple) (nth 3 state-tuple))

(defun retrieve-by-state (state list)

(cond ((null list) nil)

((equal state (get-state (car list))) (car list))

(t (retrieve-by-state state (cdr list)))))

(defun run-best (start goal)

(setq *goal* goal)

(setq *open* (list (build-record start nil 0 (heuristic

start))))

(setq *closed* nil)

(best-first))

(defun best-first ()

(print "open =") (print *open*)

(print "closed =") (print *closed*)

(cond ((null *open*) nil)

(t (let ((state (car *open*)))

(setq *closed* (cons state *closed*))

(cond ((equal (get-state state) *goal*) (build-

solution *goal*))

(t (setq *open* (insert-by-weight

(generate-descendants (get-state state)(1+

(get- depth state)) *moves*)(cdr *open*)))

(best-first)))))))

(defun generate-descendants (state depth moves)

(cond ((null moves) nil)

(t (let ((child (funcall (car moves) state))

(rest (generate-descendants state depth (cdr

moves))))

(cond ((null child) rest)

((retrieve-by-state child rest) rest)

((retrieve-by-state child *open*) rest)

((retrieve-by-state child *closed*) rest)

(t (cons (build-record child state depth

(+ depth (heuristic child))) rest)))))))

(defun build-solution (state)

(cond ((null state) nil)

(t (cons state (build-solution

(get-parent

(retrieve-by-state state *closed*)))))))