Artificial Intelligence (AI) is a branch of computer science concerned with the
construction of computer systems that "think." This course is an introduction
to the core ideas of AI through concrete, hands-on activity. We will use the Common
Lisp programming language to build working AI systems. We will study a range of techniques
and mechanisms, including pattern matching and production systems, semantic networks
and frame systems, heuristic search, genetic algorithms, resolution theorem proving,
STRIPS-style planning, symbolic learning algorithms, augmented transition networks,
and neural networks. We will also discuss the philosophical foundations of AI, alternative
approaches to AI (for example, symbolic, connectionist, and situated activity approaches),
and the implications of AI for cognitive science more broadly. The class will meet
twice weekly for one hour and twenty minutes.
Artificial Intelligence: A New Synthesis, by Nils J. Nilsson. San Francisco,
CA: Morgan Kaufmann Publishers, Inc. 1998.
ISBN 1-55860-467-7 (cloth)
ISBN 1-55860-535-5 (paper)
ANSI Common Lisp, by Paul Graham. Englewood Cliffs, NJ: Prentice Hall. 1996.
ISBN 0-13-370875-6
Computation & Intelligence: Collected Readings, edited by George F. Luger.
Menlo Park/Cambridge/London: AAAI Press/The MIT Press. 1995.
ISBN 0-262-62101-0
You will be evaluated on the basis of participation (including weekly code demonstrations)
and a web-based portfolio of Lisp code.
Participation includes contributions to discussions both in the classroom and
on the class e-mail list, along with the sharing of code via portfolios. You should
demonstrate through your participation that you have read and thought about the course
readings.
You will be expected to present a demonstration of new, running Lisp code, preferably
related to the topics covered recently in class, every Thursday (except for
the first day of class). The code that you demonstrate can be a new component of
an ongoing project, a new mini-project undertaken just for one week, a collection
of answers to code exercises from the Graham text, or anything else as long as it
is new, running Lisp code. One suggestion is to start with small exercises and mini-projects
at the beginning of the semester and to work up to a larger project (demonstrating
new components of the larger project each week) as the semester progresses. This
is only a suggestion, however, and you are free to work on large or small projects
as you wish.
Demos will be strictly limited to 5 minutes, with 1 minute set-up time. You should
be certain before class each Thursday that you can get all of the necessary
files in place and begin your demo within 1 minute of the start of your demo time.
You should also be certain that you can complete your demo within 5 minutes
after setup. Following are possible strategies for ensuring that you can set up your
demo in 1 minute:
- pre-test your code under Macintosh Common Lisp (which will be available on the
projected machine in the class),
- OR prepare your demo to run on the web (using a Lisp/web utility that will be
demonstrated in class),
- OR prepare your demo to run via Telnet (or VNC other network application) on
a reliable machine elsewhere on the net,
- OR prepare your demo to run on a laptop computer that you have verified will
work with the class projector and will require less than one minute reconfiguration
time,
- OR anything else that gets your demo started within one minute.
Your narrative evaluation for the course will include the following text:
Each student was expected to present a demonstration of new, running Lisp code
every week of the course. <NAME> successfully completed <X> of the <Y>
possible demonstrations. [where <NAME> is your name, <X> is the number
of demos you presented, and <Y> is the total number of demo days]
In other words, the demos are not optional! You are expected to produce
something new and running every week, and to demonstrate it within the time and technology
constraints; if you do not do so it will look bad on your evaluation.
The language we will be learning and using is ANSI Common Lisp, the most complete
and well-standardized dialect of the 50-year-old Lisp family tree (including CLOS,
the Common Lisp Object System). While it would also be fun to work in other dialects
(like elisp, which powers emacs, or Scheme, which combines power and elegance like
few other languages), your work for this course should be in ANSI Common Lisp. You
should also avoid the use of any platform-specific extensions except when absolutely
necessary (e.g. for graphics), and remember that your demos must run on the equipment
available in the classroom (or across the web; the key thing is that we must be able
to watch your demos run in class).
Your code portfolio should demonstrate facility with the Lisp language and engagement
with several of the class topics at the implementation level. You can do this in
a wide range of ways. Some of the sorts of things that you might want to include
in your portfolio include:
- exercises from the Graham book or from other textbooks
- new code for large or small projects of your own devising
- enhanced/modified versions of code presented by me or by other students in class
(with proper attributions)
- anything else you can think of as long as it involves you producing new, running
Lisp code.
Your code portfolio will be a public document, made available to the class
via the web. You should update your portfolio at least once per week, to include
(at least) the code covered in your demo.
Films related to the topics covered in class will be shown every Wednesday evening
from 7:00 to 9:00 PM in the ASH auditorium. Some of the films will be technical in
nature (for example, "Genetic Programming: The Movie"), while others will
provide cultural or social perspectives on artificial intelligence (for example,
the documentary "Fast, Cheap, and Out of Control," which profiles four
men including MIT roboticist Rodney Brooks). Still others will be shown mostly for
fun (for example "Pi" and particular episodes of the Twilight Zone and
Star Trek), though all of the films will highlight AI themes .
This course will not follow a rigid, pre-specified schedule but will instead be
paced to the progress and interests of the students. The basic sequence of topics
and readings is presented below but other topics and readings may also be added;
changes will be discussed and announced in class.
Coverage of the Lisp programming language will occur in parrallel with (and integrated
with) coverage of AI topics. We will cover Lisp in roughly the order that it is covered
in the Graham book. Except for Chapters 1 and 2, specific readings from the Graham
book are not listed in the table below; they will be announced in class.
| Topic |
Core Readings |
| Introduction to AI and Lisp |
Graham Ch. 1 (Introduction)
Nilsson Ch. 1 (Introduction)
Graham Ch. 2 (Welcome to Lisp)
Luger Ch. 2 (Turing)
Hearst, Hirsh et al. (Trends and Controversies)
Optional: Lem (The Washing Machine Tragedy)
Optional: Gat (Lisp
as an Alternative to Java)
Optional: Luger Ch.1 (Glymour et al.) |
| Stimulus-Response Agents |
Nilsson Ch. 2 (Stimulus-Response Agents)
Luger Ch. 13 (Brooks)
Luger Ch. 28 (Agre & Chapman)
Optional: Braitenberg (Vehicles) |
| Neural Networks |
Nilsson Ch. 3 (Neural Networks)
Luger Ch. 12 (McClelland)
Optional: Luger Ch. 29 (Minsky) |
| Genetic and Evolutionary Computation |
Nilsson Ch. 4 (Machine Evolution)
Spector et al. (Introduction
to Advances in GP 3)
Optional: Luger Ch. 11 (Holland) |
| Heuristic Search and Games |
Nilsson Ch. 7 (Agents that Plan)
Nilsson Ch. 8 (Uninformed Search)
Nilsson Ch. 9 (Heuristic Search)
Nilsson Ch. 12 (Adversarial Search)
Luger Ch. 15 (Samuel)
Hirsh et al.(Playing with AI)
Optional: Luger Ch. 4 (Newell & Simon) |
| Logic, Knowledge, and Planning |
Nilsson Ch. 13 (The Propositional Calculus)
Nilsson Ch. 14 (Resolution in the Propositional Calculus)
Nilsson Ch. 18 (Representing Commonsense Knowledge)
Luger Ch. 16 (Newell & Simon)
Nilsson Ch. 22 (Planning)
Optional: Luger Ch. 9 (Schank)
Optional: Luger Ch. 17 (Fikes & Nilsson) |
