Lecture 6-2 CS250: Intro to AI/Lisp

Programming in Your Favorite Language

Lecture 5-2February 11th, 1999

CS250

Lecture 6-2 CS250: Intro to AI/Lisp

“Get Your Red-Hot Lists Here!”• Conses are pairs of pointers

– First pointer is the car– Rest is the cdr

• Lists are conses in which:– First pointer is the first element– Second pointer is the rest of the list– No intermediate pointers makes last

expensiveUSER(104): (last (list 'a 'b 'c))(C)

Lecture 6-2 CS250: Intro to AI/Lisp

Box & Pointer• Represent a cons graphically

(list ‘a (list ‘b ‘c) ‘d)

Lecture 6-2 CS250: Intro to AI/Lisp

Some Things are More Equal than Others

• Lisp has multiple definitions of equality• Decreasing order of strictness

– eq, eql, equal

Lecture 6-2 CS250: Intro to AI/Lisp

eq

• True if its arguments are the same, identical object; otherwise, returns false

(eq 'a 'b) => false (eq 'a 'a) => true (eq 3 3) => true

OR => false (eq 3 3.0) => false

Lecture 6-2 CS250: Intro to AI/Lisp

eql• True of two objects, x and y, in the

folowing cases:1. If x and y are eq. 2. If x and y are both numbers of the same type

and the same value. 3. If they are both characters that represent the

same character.

(eql 'a 'b) => false (eql 'a 'a) => true (eql 3 3) => true (eql 3 3.0) => false (eql 3.0 3.0) => true (eql #c(3 -4) #c(3 -4)) => true (eql #c(3 -4.0) #c(3 -4)) => false

Lecture 6-2 CS250: Intro to AI/Lisp

equal

• Generally, returns true if two objects print the same

> (setf x (cons ‘a nil))(A)> (eql x x)T> (equal x (cons ‘a nil))T

Lecture 6-2 CS250: Intro to AI/Lisp

Mapping over lists

• Need to do something to every element in a list? Try a mapping function:– mapcar for using the car of successive

cdr’s– maplist for successive cdr’s themselves

Lecture 6-2 CS250: Intro to AI/Lisp

mapcar in Action

USER(115): (mapcar #'list '(a b c) '(1 2 3 4))

USER(116): (mapcar #'list '(a b c) '(1 2))

((A 1) (B 2) (C 3))

((A 1) (B 2))

Lecture 6-2 CS250: Intro to AI/Lisp

Creating an N-Queens Problem

(defun nqueens-initial-state (n &optional (explicit? nil) (complete? nil)) (let ((s (make-CSP-state

:unassigned (mapcar #'(lambda (var) (make-CSP-var :name var

:domain (iota n)))(iota n))

:assigned nil :constraint-fn (if explicit?

(let ((constraints (nqueens-constraints n))) #'(lambda (var1 val1 var2 val2) (CSP-explicit-check var1 val1 var2 val2 constraints)))

#'nqueens-constraint-fn)))) (if complete? (CSP-random-completion s) s)))

Lecture 6-2 CS250: Intro to AI/Lisp

Unassigned Variables

(mapcar #'(lambda (var)(make-CSP-var :name var

:domain (iota n)))(iota n))

USER(105): (iota 8)(0 1 2 3 4 5 6 7)

Lecture 6-2 CS250: Intro to AI/Lisp

Unassigned Variables II

((0 (0 1 2 3 4 5 6 7) NIL NIL) (1 (0 1 2 3 4 5 6 7) NIL NIL) (2 (0 1 2 3 4 5 6 7) NIL NIL) (3 (0 1 2 3 4 5 6 7) NIL NIL) (4 (0 1 2 3 4 5 6 7) NIL NIL) (5 (0 1 2 3 4 5 6 7) NIL NIL) (6 (0 1 2 3 4 5 6 7) NIL NIL) (7 (0 1 2 3 4 5 6 7) NIL NIL))

Lecture 6-2 CS250: Intro to AI/Lisp

Recursion Again• Recursive function = Base case +

Recursive step– Base case will be a conditional test, plus a

call that returns• Example: General-Search

(defun general-search-helper (problem nodes queuing-fn)

(let ((node (first nodes))) (if (null node) nil

:

Lecture 6-2 CS250: Intro to AI/Lisp

Recursive General Search

(if (goal-test problem (node-state node))node

(general-search-helper problem (funcall queuing-fn (rest nodes) (expand node problem)) queuing-fn)...)

If we’ve got a node, what do we do next?

What if it’s not the goal?

Lecture 6-2 CS250: Intro to AI/Lisp

Put it Together

(defun general-search-helper (problem nodes queuing-fn) (let ((node (first nodes))) (if (null node) nil (if (goal-test problem (node-state node))

node (general-search-helper problem

(funcall queuing-fn(rest nodes)(expand node problem))

queuing-fn)))))

Lecture 6-2 CS250: Intro to AI/Lisp

Getting it Started...

(let ((nodes (make-initial-queue problem queuing-fn))node)

(defun make-initial-queue (problem queuing-fn) (let ((q (make-empty-queue))) (funcall queuing-fn q

(list (create-start-node problem))) q))

From simple.lisp:General-Search function

How does Make-Initial-Queue work?

Lecture 6-2 CS250: Intro to AI/Lisp

Top-level Function

(defun general-search-recursive (problem queueing-fn) "Recursive version of general search" (general-search-helper problem

(list (create-start-node problem)) queueing-fn))

Lecture 6-2 CS250: Intro to AI/Lisp

BFS with a List

(defun breadth-first-search (problem) (general-search-recursive problem #'append))

What’s the rule for node exploration in BFS? How are new nodes added?

Lecture 6-2 CS250: Intro to AI/Lisp

Sets

• Sets let you treat lists as sets– Membership– Union, intersection– Set difference

Lecture 6-2 CS250: Intro to AI/Lisp

Sequences

• Sequences include more than just lists– Ordered series– Lists and vectors

• Many functions operate on sequences, not just lists:– length, sort, subseq, reverse, every, some, elt

Lecture 6-2 CS250: Intro to AI/Lisp

Structures

• Create records in Lisp• Define structures with the defstruct

macro:(defstruct point x y)

Lecture 6-2 CS250: Intro to AI/Lisp

“Big Sale on Constructors & Accessors!”

• Creating a structure creates:– Constructor (make-point)

• Arguments are passed by keyword– Copy constructor (copy-point)– Slot accessor functions (point-x, point-y)

– Type predicate (point-p)• New structures are new types

Lecture 6-2 CS250: Intro to AI/Lisp

Default Values for Structure Fields

• Add a default value

(defstruct midterm (difficulty (progn

(format t “How hard was it?”) (read))) (max-grade 54) (num-completed nil))

Lecture 6-2 CS250: Intro to AI/Lisp

Customize Automatic Functions

(defstruct (point (:conc-name p) (:print-function print-point))

(x 0) (y 0))

(defun print-point (p stream depth) (format stream “#<~A, ~A>” (px p) (py p)))