1. what we will do - LISP, AI techniques
   AI:
   • how to represent knowledge so that it can be
   • accessed and used

2. Why LISP - symbol processing - do we process symbols?
   • speak
   • communicate (write)
   • thoughts (?)
   Intelligence must be communicated
   Good representations make the right things explicit
   Research on representation
   Arguments: Turing computable and task/technique

   1. expert systems: build, enhance, and use
   2. commonsense reasoning
   3. learning
   4. natural language
   5. education and intelligent support systems (explanations)
   6. speech and vision
   more on Why LISP - page 4 and 5 of text

   COMMON LISP - standard
   CLOS - COMMON LISP Object System

3. Students: why did you take this course
   what backgrounds (AI, programming, LISP)

4. projects -
   • 2 small (out of book (?) - practice)
   • 1 medium
   • 1 large (either own or extension)

5. Syllabus - systems

6. LISP primitives: will reference, AI Programming Techniques, LISP 3rd Edition by Winston and Horn

LISP - List Processing

Part One: symbol manipulation and basic LISP

Part Two: advanced LISP

Part Three: programs using LISP - AI programming techniques

computers use bits - binary digits : 0 &1

to represent numbers

to represent characters -> words -> sentences

wordlike objects - atoms

groups of atoms - lists

just as: words form sentences --- sentences form paragraphs

atoms and lists are called symbolic expressions --- s-expressions

Structures:
   objects: block/university
      attribute/value pairs and identification

An aside: Suddenly this is "new" with XML and structure capabilities for HTML for "automated" reading. Ahhh, AI coming back

(arch (parts lintel post1 post2) (lintel must-be-supported-by post1) (lintel must-be-supported-by post2) (lintel a-kind-of wedge) (post1 a-kind-of brick) (post2 a-kind-of brick) (post1 must-not-touch post2) (post2 must-not-touch post1)) (mit (a-kind-of university) (location (cambridge massachusetts)) (phone 253-1000) (schools ( architecture business engineering humanities science)) (founder (william barton rogers)))

*) known objects - provide information

*) unknown: use rules to generate new information

(identify6 ((? animal) has pointed teeth) ((? animal) has claws) ((? animal) has forward eyes) ((? animal) is a carnivore))

LISP prompt:

If you do "something wrong" and a number in square brackets shows up before the prompt

comments: begin line with a semicolon ;

LISP is functional (procedure arguments),
i.e, a list with elements the first is always the function to be performed

(prefix)

and interpretive (vs compiled ...)

you type:

* (+ 3.14 2.71)

LISP responds:

5.85

SETF: Set Field

* (setf friends '(dick jane sally)) *friends (DICK JANE SALLY) (our option is not case-sensitive) * (setf enemies '(troll grinch ghost)) * (setf enemies (remove 'ghost enemies)) * (setf friends (cons 'ghost friends))

REMOVE, CONS construct

*enemies (TROLL GRINCH) *friends (GHOST DICK JANE SALLY)

Procedures:

(defun newfriend (name) (setf enemies (remove name enemies)) (setf friends (cons name friends))) *(newfriend 'ghost)

Terms:

procedure - task to be performed
primitive - procedure supplied by LISP
user-defined procedure
program - collection of procedures


names for primitives can be single characters: +, -, /, *

* (+  (* 2 2) (/ 2 2))			(old LISPs  (plus 2 2)
5

* 8
8

Numbers, t, nil (empty list or false) evaluate to themselves
• atoms -
  • indivisible objects, e.g., 27, +, FOO
  • numeric atoms - numbers
  • symbolic atoms - symbols
• list- left parenthesis, 0 or more atoms, right paren
  (some lisps evaluate when type the ) )
• expressions - both atoms and lists

pg 14, 515

nested lists examples

( (a d) f (d (s d))) (((a) (s)) (p))

write expressions for

(3*17) + (4*19) (exponent one)

FIRST (first '(a b d)) = A
(first '((a d) c (d b)))
REST (rest '(a b d)) = (B D)
(rest '(a (c d)))

QUOTE tells LISP how far evaluation process should go

NIL ()

' is a macro character for Quote, i.e. 'A becomes (QUOTE A)

(rest '(c)) returns NIL (first '(rest (a b c))) (rest (a b))

pg 20 : (2-2, 2-3, 2-4, do some)

CAR (non-destructive) (CADR CADDR second and third elements)
CDR
(CADDR '(a b c)) = (CAR (CDR (CDR '(a b c))))
= (FIRST (REST (REST '(a b c))))

SETF - binds (setf L '(a f)) (what if not quote?)


* L

LISP looks up value for atom L

• binding - process of reserving a place in memory to store a value for a symbol (setq vs setf - symbols and data types)
• assignment - process of storing a value in that place
• evaluation- process of recovering a value from that place the result of evaluating an s-expression is called the value of the s-expression

* (setf ab-list '(a b))
* ab-list
*'ab-list
* (first 'ab-list)
* (first ab-list)

* (setf  ab-list  '(a b)	(LISP returns last setf)
	  xy-list  '(x y))	(for odd number of arguments won't eval)

FIRST and REST (CAR and CDR) take apart
CONS, APPEND, LIST construct

CONS takes an expression and a list and returns a new list with the expression as the first element
CONS is like the inverse of FIRST with REST

(non-destructive)

* (setq x 'a) * (setq y '(b c)) * (cons x y) * x * y

CONSing requires storage and is expensive . It builds a completely new list => new storage

LISP dynamically allocates storage as need arises. When it runs out of room, LISP garbage-collects unused cons cells and re-uses them. Garbage-collection is computational and time expensive.

CAR - single microsecond

CONS - with garbage-collection - millisecond

moral: if possible, manipulate rather than build

APPEND combines the elements of two (or more) lists

* (append '(a c d) L1)

Note that it runs the elements of the lists together

* (append '(a c d) '(e f g)) evaluates to (a c d e f g) * (append '((a) (c) (d) ) '(e f g)) yields ((a) (c) (d) e f g)

LIST makes a list out of its arguments

* (list 'a 'b 'c) evaluates to (a b c) * (setf front 'a middle 'b back 'c) * (list front middle back)

pg 26, 27

NTHCDR trims off n elements from the first argument
(note: CDR (REST) trims off 1 from the first)

(NTHCDR n list)

BUTLAST trims off the last n elements

(BUTLAST list n)

(if no second argument, default is 1) expensive

LAST returns a list with all but the last element of the list element trimmed. (like FIRST except get a list) how can one get simply the last element? also expensive

Add an element to the end - no complement to CONS

(APPEND list1 (LIST element1))

LENGTH: counts the number of top-level elements

REVERSE: reverses the order of top-level elements (pg 31)

ASSOC: association list - consists of a list of sublists
first element is key; second element is value

(setf sarah '((height .54) (weight 4.4)))

* (in object-oriented programming, sarah might be an object and the keys are class or instance values)

Retrieve values by (ASSOC )
(assoc 'weight sarah) evaluates to (WEIGHT 4.4)(note sublist)


Numbers: (numeric atoms)

• Integers
• Ratios: rationals
• Floating Point: reals
  (/ arg1 arg2)
  if two floating points, returns floating point
  if one float then all convert to float
  if two integers, returns a ratio (/ 22 7) returns 22/7 (unless divide evenly)
  (float (/ 22 7)) returns 3.14286

ROUND: (round (/ 22 7)) returns (toward the even when midway)
3 :the nearest integer
1/7 : the remainder


MAX
MIN
EXPT
SQRT: give a negative, returns a complex #, data type
ABS