Ch 15. An Introduction to LISP

1
Ch 15. An Introduction to LISP

• 15.0 Introduction
• 15.1 LISP A Brief Overview
• 15.1.1 Symbolic Expressions, the Syntactic Basis
  of LISP
• 15.1.2 Control of LISP Evaluation quote and eval
• 15.1.3 Programming in LISP Creating New
  Functions
• 15.1.4 Program Control in LISP Conditionals and
  Predicates
• 15.1.5 Functions, Lists, and Symbolic Computing
• 15.1.6 Lists as Recursive Structures
• 15.1.7 Nested Lists, Structure, and car/cdr
  Recursion
• 15.1.8 Binding Variables Using set
• 15.1.9 Defining Local Variables Using let
• 15.1.10 Data Types in Common LISP

2
15.0 Characteristics of LISP

• Language for artificial intelligence programming
• Originally designed for symbolic computing
• Imperative language
• Describe how to perform an algorithm
• Contrasts with declarative languages such as
  PROLOG
• Functional programming
• Syntax and semantics are derived from the
  mathematical theory of recursive functions.
• Combined with a rich set of high-level tools for
  building symbolic data structures such as
  predicates, frames, networks, and objects
• Popularity in the AI community
• Widely used as a language for implementing AI
  tools and models
• High-level functionality and rich development
  environment make it an ideal language for
  building and testing prototype systems.

3
15.1 LISP A Brief Overview

• Syntactic elements of LISP
• Symbolic expressions S-expressions
• Atom basic syntactic units
• List
• Both programs and data are represented as
  s-expressions
• Atom
• Letters (upper, lower cases)
• Numbers
• Characters - / _at_ _ lt gt .
• Example
• 3.1416
• Hyphenated-name
• some-global
• nil
• x

4
List and S-expression

• List
• A sequence of either atoms or other lists
  separated by blanks and enclosed in parentheses.
• Example
• (1 2 3 4)
• (a (b c) (d (e f)))
• Empty list ( ) nil
• nil is the only s-expression that is considered
  to be both an atom and a list.
• S-expression
• An atom is an s-expression.
• If s1, s2,, sn are s-expressions,
• then so is the list (s1 s2 sn).

5
Read-Eval-Print

• Interactive Environment
• User enters s-expressions
• LISP interpreter prints a prompt
• If you enter
• Atom LISP evaluates itself (error if nothing is
  bound to the atom)
• List LISP evaluates as an evaluation of
  function, i.e. that the first item in the list
  needs to be a function definition (error if no
  function definition is bound for the first atom),
  and remaining elements to be its arguments.
• gt ( 7 9)
• 63

6
Control of LISP Evaluationquote eval

• quote
• prevent the evaluation of arguments
• (quote a) gt a
• (quote ( 1 3)) gt ( 1 3)
• a gt a
• ( 4 6) gt ( 4 6)
• eval
• allows programmers to evaluate s-expressions at
  will
• (eval (quote ( 2 3))) gt 5
• (list 2 5) gt ( 2 5)
• (eval (list 2 5)) gt 10

7
Programming in LISPCreating New Functions

• Syntax of Function Definition
• (defun ltfunction-namegt (ltformal parametersgt)
  ltfunction bodygt)
• defun define function
• Example
• (defun square (x) ( x x))
• (defun hypotenuse (x y) the length of the
  hypotenuse is
• (sqrt ( (square x) the square root of
  the sum of
• (square y)))) the square of the
  other sides.

8
Program Control in LISPConditionals
Predicates(1/2)

• Conditions
• (cond (ltcondition 1gt ltaction1gt) (ltcondition
  2gt ltaction 2gt) ...
• (ltcondition ngt ltaction n))
• Evaluate the conditions in order until one of the
  condition returns a non-nil value
• Evaluate the associated action and returns the
  result of the action as the value of the cond
  expression
• Predicates
• Example
• (oddp 3) whether its argument is odd or not
• (minusp 6)
• (numberp 17)

9
Conditionals Predicates(2/2)

• Alternative Conditions
• (if test action-then action-else)
• (defun absolute-value (x)
• (if (lt x 0) (- x) x))
• it returns the result of action-then if test
  return a non-nil value
• it return the result of action-else if test
  returns nil
• (and action1 ... action-n) conjunction
• Evaluate arguments, stopping when any one of
  arguments evaluates to nil
• (or action1 ... action-n) disjunction
• Evaluate its arguments only until a non-nil value
  is encountered

10
List as recursive structures

• Cons cell data structure to hold a list in LISP
• car - holds the first element.
• cdr - holds the rest in the list.
• Accessing a list
• (car (a b c)) gt a
• (cdr (a b c)) gt (b c)
• (first (a b c)) gt a
• (second (a b c)) gt b
• (nth 1 (a b c)) gt b
• Constructing a list
• (cons a (b c)) gt (a b c)
• (cons a nil) gt (a)
• (cons (a b) (c d)) gt ((a b) c d)

11
Nested lists, structure, car/cdr recursion

• More list construction
• (append (a b) (c d)) gt (a b c d)
• (cons (a b) (c d)) gt ((a b) c d)
• Counting the number of elements in the list
• (length ((1 2) 3 (1 (4 (5))))) gt 3

12
Binding variables set(1/2)

• (setq ltsymbolgt ltformgt)
• bind ltformgt to ltsymbolgt
• ltsymbolgt is NOT evaluated.
• (set ltplacegt ltformgt)
• replace s-expression at ltplacegt with ltformgt
• ltplacegt is evaluated. (it must exists.)
• (setf ltplacegt ltformgt)
• generalized form of set when ltplacegt is a
  symbol, it behaves like setq otherwise, it
  behaves like set.

13
Binding variables set(2/2)

• Examples of set / setq
• (setq x 1) gt 1 assigns 1 to x
• (set a 2) gt ERROR!! a is NOT defined
• (set a 2) gt 2 assigns 2 to a
• ( a x) gt 3
• (setq l (x y z)) gt (x y z)
• (set (car l) g) gt g
• l gt (g y z)
• Examples of setf
• (setf x 1) gt 1
• (setf a 2) gt 2
• ( a x) gt 3
• (setf l (x y z)) gt (x y z)
• (setf (car l) g) gt g
• l gt (g y z)

14
Local variables let(1/2)

• Consider a function to compute roots of a
  quadratic equation ax2bxc0
• (defun quad-roots1 (a b c) (setq temp (sqrt (-
  ( b b) ( 4 a c)))) (list (/ ( (- b) temp)
  ( 2 a)) (/ (- (- b) temp) ( 2 a))))
• (quad-roots1 1 2 1) gt (-1.0 -1.0)
• temp gt 0.0
• Local variable declaration using let
• (defun quad-roots2 (a b c) (let (temp)
  (setq temp (sqrt (- ( b b) ( 4 a c))))
  (list (/ ( (- b) temp) ( 2 a)) (/
  (- (- b) temp) ( 2 a)))))

15
Local variables let(2/2)

• Any variables within let closure are NOT bound at
  top level.
• More improvement (binding values in local
  variables)
• (defun quad-roots3 (a b c)(let ((temp (sqrt (-
  ( b b) ( 4 a c)))) ((denom (2 a)))
  (list (/ ( (- b) temp) denom) (/ (-
  (- b) temp) denom))))

16
For Homework

• Representing predicate calculus with LISP
• ?x likes (x, ice_cream)
• (Forall (VAR X) (likes (VAR X) ice_cream))
• ?x foo (x, two, (plus two three))
• (Exist (VAR X) (foo (VAR X) two (plus two
  three)))
• Connectives
• S (nott S)
• S1 ? S2 (ANDD S1 S2)
• S1 ? S2 (ORR S1 S2)
• S1 ? S2 (imply S1 S2)
• S1 S2 (equiv S1 S2)
• Do not use the builtin predicate names.

17
For Homework

• ??? ???? ?? ??? ?? predicate?? atomic sentence??
  ????.
• true, false
• likes (george, kate) likes (x, george)
• likes (george, susie) likes (x, x)
• likes (george, sarah, tuesday)
• friends (bill, richard)
• friends (bill, george)
• friends (father_of(david), father_of(andrew))
• helps (bill, george)
• helps (richard, bill)
• equals (plus (two, three), five)

18
For Homework

• (DEFUN atomic_s (Ex)
• (cond ((member Ex (true false)) T)
• ((member (car Ex) (likes ))
• (Test_term (cdr Ex)))
• (T nil)))
• (DEFUN Test_term (ex1)
• (cond ((NULL ex1) T)
• ((member (car ex1) (george ..)
• (test_term (cdr ex1)))
• ((VARP (car ex1)) (test_term (cdr
  ex1)))
• ((functionp (car ex1)) (test_term
  (cdr ex1)))
• (T nil)))

19
Recursion Templates

• Recursion template
• A few standard forms of recursive Lisp functions.
• You can create new functions by choosing a
  template and filling in the blanks.
• Recursion templates? ??
• ? Double-Test Tail Recursion
• ? Single-Test Tail Recursion
• ? Single-Test Augmenting Recursion
• ? List-Consing Recursion
• ? Simultaneous Recursion on Several Variables
• ? Conditional Augmentation
• ? Multiple Recursion
• ? CAR/CDR Recursion

20
Double-Test Tail Recursion

• Template
• (DEFUN func (X) (COND (end-test-1
  end-value-1)
• (end-test-2 end-value-2)
• (T (func reduced-x))))
• Example
• Func ANYODDP
• End-test-1 (NULL X)
• End-value-1 NIL
• End-test-2 (ODDP(FIRST X))
• E nd-value-2 T
• Reduced-x (REST X)
• (defun anyoddp (x)
• (cond ((null x) nil)
• ((oddp (first x)) t)
• ((t (anyoddp (rest x))))

21
Single-Test Tail Recursion

• Template
• (DEFUN func (X) (COND (end-test end-value)
• (T (func reduced-x))))
• Example
• Func FIND-FIRST-ATOM
• End-test (ATOM X)
• End-value X
• Reduced-x (FIRST X)
• (defun find-first-atom (x)
• (cond ((atom x) x)
• ((t (find-first-atom (first
  x))))

22
Single-Test Augmenting Recursion(1/2)

• Template
• (DEFUN func (X) (COND (end-test end-value)
• (T (aug-fun aug-val)
• (func reduced-x))))
• Example1
• Func COUNT-SLICES
• End-test (NULL X)
• End-value 0
• Aug-fun
• Aug-val 1
• Reduced-x (REST X)
• (defun count-slices (x)
• (cond ((null x) 0)
• (t ( 1 (count-slices (rest
  x))))))

23
Single-Test Augmenting Recursion(2/2)

• Example2 The Factorial Function
• (defun fact (n)
• (cond ((zerop n) 1)
• (t ( n (fact (- n
  1))))))

24
List-Consing Recursion(A Special Case of
Augmenting Recursion)

• Template
• (DEFUN func (N)
• (COND (end-test NIL)
• (T (CONS new-element
• (func reduced-n)))))
• Example
• Func LAUGH
• End-test (ZEROP N)
• New-element HA
• Reduced-n (- N 1)
• (defun laugh (n)
• (cond ((zerop n) nil)
• (t (cons ha (laugh (- n
  1))))))

25
Simultaneous Recursion on Several
Variables(Using the Single-Test Recursion
Template)

• Template
• (DEFUN func (N X)
• (COND (end-test end-value)
• (T (func reduced-n
  reduced-x))))
• Example
• Func MY-NTH
• End-test (ZEROP N)
• End-value (FIRST X)
• Reduced-n (- N 1)
• Reduced-x (REST X)
• (defun my-nth (n x)
• (cond ((zerop n) (first X)
• (t (my-nth (- n 1) (rest
  x)))))

26
Conditional Augmentation (1/2)

• Template
• (DEFUN func (X)
• (COND (end-test end-value)
• (aug-test (aug-fun aug-val
• (func reduced-x)))
• (T (func reduced-x))))
• Example
• Func EXTRACT-SYMBOLS
• End-test (NULL X)
• End-value NIL
• Aug-test (SYMBOLP (FIRST X))
• Aug-fun CONS
• Aug-val (FIRST X)
• Reduced-x (REST X)

27
Conditional Augmentation (2/2)

• (defun extract-symbols (X)
• (cond ((null x) nil)
• ((symbolp (first x))
• (cons (first x)
• (extract-symbols
  (rest x))))
• (t (extract-symbols (rest
  x)))))

28
Multiple Recursion(1/2)

• Template
• (DEFUN func (X)
• (COND (end-test1 end-value-1)
• (end-test2 end-value-2)
• (T (combiner (func
  first-reduced-n)
• (func second-reduced-n)))))
• Example
• Func FIB
• End-test-1 (EQUAL N 0)
• End-value-1 1
• End-test-2 (EQUAL N 1)
• End-value-2 1
• Combiner
• First-reduced-n (- N 1)
• Second-reduced-n (- N 2)

29
Multiple Recursion(2/2)

• (defun fib (n)
• (cond (equal n 0) 1)
• (equal n 1) 1)
• (t ( (fib (- n 1))
• (fib (- n 2))))))

30
CAR/CDR Recursion(A Special Case of Multiple
Recursion)(1/2)

• Template
• (DEFUN func (X)
• (COND (end-test-1 end-value-1)
• (end-test-2 end-value-2)
• (T (combiner (func CAR
  X))
• (func (CDR X))))))
• Example
• Func FIND-NUMBER
• End-test-1 (NUMBERP X)
• End-value-1 X
• End-test-2 (ATOM X)
• End-value-2 NIL
• Combiner OR

31
CAR/CDR Recursion(A Special Case of Multiple
Recursion)(2/2)

• (defun find-number (x)
• (cond ((numberp x) x)
• ((atom x) nil)
• (t (or (find-number (car
  x))
• (find-number (cdr
  x))))))

32
????

• VECTORPLUS X Y
• Write a function (VECTORPLUS X Y) which takes
  two lists and adds each number at the same
  position of each list.
• ?) (VECTORPLUS (3 6 9 10 4) (8 5 2))
• ? (11 11 11 10 4)
• ?)
• (DEFUN VECPLUS (X Y)
• (COND
• ((NULL X) Y)
• ((NULL Y) X)
• (T (CONS ( (CAR X)
  (CAR Y)
• (VECPLUS (CDR X) (CDR Y))))))