Artificial Intelligence and Lisp Lecture 6 LiU Course TDDC65 Autumn Semester, 2010 http://www.ida.liu.se/ext/TDDC65/

List processing (in CEL) Recursively nested sequences as the only composite expressions, with symbols, strings, numbers as elements Functions on sequences (no side-effects!) (e1 <a b c>) = a (e2 <a b c>) = b (en 4 <a b c d e f>) = d (t1 <a b c>) = <b c> t2, tn similarly (cons g <a b c>) = <g a b c> Notice: (cons (e1 .x) (t1 .x)) = x

List processing (in CEL) Predicates on lists [equal <a b c> <a b c>] = true Control operators, for example (if [equal .a <>] .b .a) Other necessary function (type-of .a) The value is either symbol, string, integer, real, sequence Other functions can be defined in terms of these, for example and, or, not

List Processing - Recursive Functions (length .s) == (if [equal .s <>] 0 (+ 1 (length (t1 .s)))) (replace .a .b .s) == (if [equal .s .a] .b (if [atom .s] s (cons (replace .a .b (e1 .s)) (replace .a .b (t1 .s)) ))) (append .a .b) == (if [equal .a <>] b (cons (e1 .a)(append (t1 .a) b)) )

S-expression Style Examples: color.red "Yes or no: " 421 (walkto busstop-4) (walk :from home :to busstop-4) (seq (walkto busstop-4)(takebus Lkp-C)) (set busstop-4 busstop-7 busstop-12) (+ (timefor (walkto busstop-d)) (timefor (waitfor (some (and bus (going-to Lkp-C)) ))) (timefor (go bus busstop-4 Lkp-C)) )

S-expression Style 1. Nested parenthesized expressions (lists) 2. Convention: operator as first element in list 3. Convention: use of tags e.g. :from, :to 4. Convention, sometimes: variables as ?vbl Can be used for programming language, but also for plain data, for logic, and for alternative languages S-expression-based programming languages: Lisp, Scheme

Lisp Programming Lisp uses S-expression style, all data are formed as recursively nested expressions with round parentheses Using function names such as e1 and t1, rewrite as follows (e1 <a b c>) (e1 (quote (a b c))) ssv .a <red green> (setq a (quote (red green))) (e1 .a) (e1 a) General rule: a list (g a b c) is considered as a term with g as a function and the rest as arguments, except for a small number of special operators, such as quote, if, ... This results in the simplest possible system, but at some expense of readability. KRE / CEL is closer to the standard notation of logic and mathematics.

Lisp Recursive Function Definitions (defun length (s) (if (equal s nil) 0 (+ 1 (length (t1 s)))) ) (defun replace (a b s) (if (equal s a) b (if (atom s) s (cons (replace a b (e1 s)) (replace a b (t1 s)) )))) (defun append (a b) (if (equal a nil) b (cons (e1 a)(append (t1 a) b)) ))

Other Lisp Control Primitives (cond (c1 v1)(c2 v2) ...) same as (if c1 v1 (if c2 v2 ... )) (dolist (x '(a b c)) (...)) allows x to range over a, b, c and performs (...) (dotimes (n 10) (...)) allows n to range from 0 to 9 and performs (...) (let ((a 5)(b 10)) (...)) binds a and b and evaluates (...) with those bindings (let* ((a 5)(b (- a 1))) (...)) binds a and b successively and then evaluates (...) The expressions in (...) may read, print, assign, etc.

Lisp Systems - Data Structure (red green blue) represented as nil red green blue The e1 and t1 operations follow a pointer (but they are actually called car and cdr in Lisp) The cons operation constructs a new 'yellow' cell This was the origin of the method of garbage collection.

Performance in Alternative Definitions (defun reverse (a) (if (null a) nil (append (reverse (t1 a)) (list (e1 a))) )) Note: nil is the same as (), (null a) is (equal a nil), (list a b c...) forms a list, (list a) is (cons a nil) (defun reverse (a)(rev2 a nil)) (defun rev2 (a b) (if (null a) b (rev2 (t1 a)(cons (e1 a) b))) ) Compare the number of allocated cons cells for the computation as a function of the length of the argument

Definitions as Propositions in Logic (defun reverse (a) (if (null a) nil (append (reverse (t1 a)) (list (e1 a))) )) Compare: (reverse nil) = nil (reverse (cons a b)) = (append (reverse b)(list a)) Evaluation of (reverse '(red green blue)) Rewrite as (reverse (cons 'red '(green blue))) Rewrite as (append (reverse '(green blue)) (list 'red)) and so on... (append '(blue green) (list 'red)) Then apply the function append directly, or evaluate it in the same way. -- Possible but inefficient (?)

Program Correctness Proof Specification of the reverse function: (reverse nil) = nil (reverse (cons a b)) = (append (reverse b)(list a)) Implementation of that specification: (defun reverse1 (a)(rev2 a nil)) (defun rev2 (a b) (if (null a) b (rev2 (t1 a)(cons (e1 a) b))) ) Desired to prove: (reverse a) = (reverse1 a) for all a Make proof by induction over a: 1. (reverse nil) = nil (reverse1 nil) = (rev2 nil nil) = nil 2. (reverse (cons x y)) = (append (reverse y)(list x)) = (append (reverse1 y)(list x)) according to ind.hyp. (reverse1 (cons x y)) = (rev2 (cons x y) nil) = (rev2 y (list x))

Program Correctness Proof Specification of the reverse function: (reverse nil) = nil (reverse (cons a b)) = (append (reverse b)(list a)) Implementation of that specification: (defun reverse1 (a)(rev2 a nil)) (defun rev2 (a b) (if (null a) b (rev2 (t1 a)(cons (e1 a) b))) ) Desired to prove: (append (reverse y)(list x)) = (rev2 y (list x)) Try for more general: (append (reverse y) x) = (rev2 y x) Make proof by induction over y: 1. (append (reverse nil) x) = x (rev2 nil x) = x 2. (append (reverse (cons u v)) x) = ... (rev2 (cons u v) x) = (rev2 v (cons u x))

Program Correctness Proof Specification of the reverse function: (reverse nil) = nil (reverse (cons a b)) = (append (reverse b)(list a)) Implementation of that specification: (defun reverse1 (a)(rev2 a nil)) (defun rev2 (a b) (if (null a) b (rev2 (t1 a)(cons (e1 a) b))) ) Desired to prove: (append (reverse y)(list x)) = (rev2 y (list x)) Try for more general: (append (reverse y) x) = (rev2 y x) Make proof by induction over y: 1. (append (reverse nil) x) = x (rev2 nil x) = x 2. (append (reverse (cons u v)) x) = (append (append (reverse v) (list u)) x) = (append (reverse v) (list u) x) = (append (reverse v) (append (list u) x)) = (rev2 v (append (list u) x)) = (rev2 v (cons u x)) (rev2 (cons u v) x) = (rev2 v (cons u x))

Program Property Proof Specification of the append function: (append nil c) = c (append (cons a b) c) = (cons a (append b c)) Desired to prove: (append (append a b) c) = (append a (append b c)) Make proof by induction over a: 1. (append (append nil b) c), (append b c) (append nil (append b c)), (append b c) 2. (append (append (cons x y) b) c) (append (cons x (append y b)) c) (cons x (append (append y b) c)) (append (cons x y)(append b c)) (cons x (append y (append b c))) Equality is obtained using the induction hypothesis.

Principles illustrated by this proof example Use the combination of a specification (clean, simple, expressed in logic, has recursive counterpart that is often quite inefficient) and an implementation (takes performance into account, therefore often more complex, requires correctness proof using the specification) Correctness proofs are almost always induction proofs Finding the induction proof sometimes comes naturally from the structure of the two definitions, but sometimes it requires some thinking to find the right induction hypothesis

Side-Effect Functions in Lisp nil red green blue (rplaca a b) assumes a is a cons cell. It replaces the e1 pointer in a so that (e1 a) becomes b, and returns a. (rplacd a b) is similar but with respect to the t1 pointer. Here rplaca is “replace car”, rplacd is “replace cdr”.

Side-effect Oriented Functions (setq vbl value) Used above (prog2 a b) Evaluates a and b and returns the value of b (progn a b ... d) Evaluates arguments in order and returns value of last arg Example (“destructive append”): (defun nconc (a b)(if (null a) b (nconc2 a a b))) (defun nconc2 (aa a b) (if (null (t1 a)) (progn (rplacd a b) aa) (nconc2 aa (t1 a) b) ))

Iterative Function Definitions The definitions of rev2 and nconc2 are examples of recursive definitions that are iterative A recursive function definition is iterative if the function itself only occurs on the top level of then and else branches (second and third argument of if), recursively, but not in subexpressions of these branches and not in the if branch (first argument of the if operator) For systems of several recursive functions that invoke each other, this must hold for all the definitions Iterative function definitions can be executed particularly efficiently since there is no need to build the execution stack. This applies in both interpreted and compiled mode. Notice that the definitions above that avoid unnecessary cons operations also happen to be iterative. (This is a tendency but not a general rule).

The implicit progn (defun foo (a b) (fie a)(fum b)) is the same as (defun foo (a b)(progn (fie a)(fum b))) (cond ((foo a b)(fie a)(fum b)) (t (fie b)(fum a)) ) (cond ((foo a b)(progn (fie a)(fum b))) (t (progn (fie b)(fum a))) ) Similar implicit progn is used e.g. in let expressions

Evaluation order for and and or The Lisp functions and and or consider nil as 'false' and everything else as 'true' Therefore (and a b) is nil if some argument is nil and (or a b) is nil if all arguments are nil These functions evaluate their arguments in order, and only as many as are needed Therefore (and a b) is not necessarily the same as (and b a), if a and b are subexpressions, and similarly for or Example: (or (progn (setq a 5) t) (setq a 6)) Example: Suppose (faculty -1) goes into infinite loop, and compare (or (faculty 1)(faculty -1)) with (or (faculty -1)(faculty 1))