Phil/Psych 446

Cognitive Modelling

Week 1

1a, Introduction

What is cognitive modelling?

Cognitive science is the interdisciplinary study of mind and intelligence. Since its origins in the mid-1950s, computer models have been an indispensable part of theorizing about how the mind works. Cognitive modelling is the process of developing and testing computational models of thinking.

Why is cognitive modelling useful?

Theory development:

Computer models provide a vocabulary for describing the structures and processes required for human cognition.

Theory evaluation:

Computer models provide a way of seeing whether a cognitive theory's predictions conform to how people think.

Normative evaluation:

Philosophy and cognitive science can be concerned not only with how people do think, but also with how they should think. The former concern is descriptive, the latter is normative (prescriptive). Computer modelling can help to determine what kinds of reasoning are most feasible and effective.

How is cognitive modelling different from Artificial Intelligence?

AI aims to make machines intelligent, regardless of whether the processes they use are like those used in human thinking.

In cognitive modeling, the point of computional models is to increase understanding of human thinking.

Historically, however, some of the most important ideas in AI have come about because of cognitive modelling, e.g. rule-based systems and artificial neural networks.

Theories, models, and programs

A cognitive theory proposes that human thinking results from the application of a set of computational procedures to a set of mental representations.

A computational model specifies the mental representations as data structures and the computational procedures as algorithms.

A computer program implements the computational model in a particular programming language such as LISP or JAVA.

The theory can be tested by running the program to see whether it behaves like people.

What is the aim of this course?

Each student should learn how to develop, use, and evaluate the main kinds of cognitive models that have been important in cognitive science.

Assignment for next class:

Access one of the LISP environments indicated on the main page for this course, find the input window, and type in (+ 2 2).

1b, Introduction to LISP

Expressions

Atoms

• Numeric atoms, e.g. 999, 2.3
• Symbols, e.g. PAUL, JUSTICE, CONC1

Lists

• () - the empty list NIL
• (PAUL) - list containing one atom, PAUL
• ((PAUL) (MARY JOHN)) - list of 2 lists

Arithmetic

• (+ 2 3 4)
• (* 2 3 4)
• (/ 12 2)
• Note that the first atom in the list calls a built-in LISP procedure.

Procedures on lists

Assigning values to symbols

• (setf students '(david ray pascale))
• (setf professors '(paul))
• Note: the quote ' is crucial to stop evaluation of the list

Extracting information from lists

• (first students) --> DAVID
• (rest students) --> (RAY PASCALE)

Building lists

• Adding members: (cons 'doug students) --> (DOUG DAVID RAY PASCALE). Note: this does not change STUDENTS.
• Combining lists: (append professors students) --> (PAUL DAVID RAY PASCALE)
• To change list: (setf students (cons 'doug students)) --> (DOUG DAVID RAY PASCALE).
• Create list: (list 'a 'b 3) --> (A B 3)

Predicates

(equal 2 2) --> T i.e. true

(equal 2 3) --> NIL i.e. false

(equal '(a b) (cons 'a '(b))) --> T

(member 'david students) --> T

(member 'paul students) --> NIL

(and T T) --> T

(or NIL NIL T) --> T

(if (member 'paul professors) 'hello 'goodbye)

I.e. if paul is a member of professors, return hello, otherwise return goodbye.

Defining procedures

Find the second element in a list:

(defun second-member (list)
   (first (rest list))
)

Note: here "list" is a variable

Create a list of the first elements of two lists:

(defun pair-first (list1 list2)
   (list (first list1) (first list2))
)

Iteration

DO loops have 3 parts:

• define parameters
• state exit condition
• state what is to be repeated

E.g. write your own version of the procedure reverse that reverses a list:

(defun reverse* (list)
   (do ((lst list (rest lst))  ; first parameter
        (result nil)            ; second parameter
       )
       ; exit
       ((null lst) result)
       ; iterate
       (setf result (cons (first lst) result))
   )
)

E.g. write your own version of the procedure that calculates the length of the list:

(defun length* (list)
   (do ((lst list (rest lst))
        (result 0)
       )
       ; exit
       ((null lst) result)
       ; iterate
       (setf result (+ result 1))
   )
)

E.g. write a procedure that pairs up an atom with each element of a list.

e.g. (pair-up 'paul (students)) --> ((PAUL PASCALE) (PAUL RAY) (PAUL DAVID))

; PAIR-UP pairs up an atom with each element of a list

(defun pair-up (atom list)
  (do ((result nil) ; first parameter bound initially to nil
       (lst list (rest lst)) ; second parameter bound initially to list
                             ; at each iteration, it drops the first member
      )
     ; exit condition
    ((null lst) result) ; when done, return the result
    ; iterate
    (setf result (cons (list atom (first lst)) result))
  )
)

Assignment #1 is due January 20

Phil/Psych 446

Computational Epistemology Laboratory.

Paul Thagard

This page updated Jan. 10, 2005