CS 221: Computational
Complexity
Fall 2002
SYLLABUS
Description  Topics 
Prerequisites
 Grading  Readings  Related
Courses
Instructor: Salil Vadhan (Maxwell Dworkin 337, office hours MF 12)
TF: Emanuele Viola (Maxwell Dworkin 138)
Assistant: Carol Harlow (Maxwell Dworkin 343, has handouts)
Room & time: MWF 1112, Pierce 209
Course email address (use for all questions): cs221@eecs.harvard.edu
Course website: http://www.courses.fas.harvard.edu/~cs221/
Course Description
Computational complexity aims to understand the fundamental limitations
and capabilities of efficient computation. For example, which
computational problems inherently require a huge running time to solve,
no matter how clever an algorithm one designs? This most basic question
of computational complexity is now understood to be both extremely difficult
and of great importance, as demonstrated by all the attention given to
the famous P vs. NP question. At the same time, however,
this is but one of many the fascinating issues addressed by complexity
theory (and covered in this course). First, running time will not
be the only computational resource we consider, but also space/memory,
nondeterminism, randomness, parallelism, communication, algebraic operations,
and quantum mechanics. We will also study a variety of types of computational
problems, such as decision, search, counting, optimization, and proof verification.
We will introduce an array of complexity classes to capture these resources
and problem types. We will use the powerful notions of reduction
and completeness to establish relationships between seemingly unrelated
problems, classes, and resources. Indeed, it is in discovering
such connections that complexity theory has had its greatest successes,
and we will conclude the course with one of the most surprising ones: the
equivalence between probabilistic verification of mathematical proofs (PCPs)
and the complexity of finding approximate solutions to optimization problems.
We will also examine various approaches to separating P and NP, and more
generally to proving lower bounds on complexity. Finally, we will study
what happens when one relaxes the requirement for an algorithm to be "correct",
for example from worstcase complexity to averagecase complexity or from
exact solutions to approximate solutions.
The material in this course can be of interest to a wide range of graduate
students and advanced undergraduates, ranging from those who plan to do
research in the theory of computation, to those working in other areas
of computer science and mathematics, to those interested in computational
aspects of other fields such as economics and physics.
Tentative List of Topics

Resources for computation (time, space, nondeterminism, randomness) and
their associated complexity classes.

Relationships among measures (P vs. NP and more)

Reductions & completeness

Provably intractable problems

Circuit complexity

Averagecase complexity

Interactive proofs & IP=PSPACE

Probabilistically checkable proofs (PCP) and nonapproximability

Algebraic complexity

Proof complexity

Quantum computation
Prerequisites
The prerequisite for this course is Computer Science 121 (or the equivalent
at another university) with a good grade (B+ or higher). If you do
not formally meet this requirement but still wish to take this course,
you must come to my office hours to discuss your background. The
most important topics that we will be assuming from CS 121 is comfort with
Turing machines, computability, asymptotic running time, and NPcompleteness.
General mathematical maturity, e.g. comfort with proofs, basic discrete
probability, & combinatorics, will also be assumed.
Grading & Problem Sets
The requirements of the course:

Biweekly problem sets. Your solutions must be typed and submitted
electronically.

Taking "scribe notes" for 13 lectures (depending on how many students
are in the class), and typing them up in LaTeX.

Takehome final exam.
The biweekly problem sets will typically be due on Thursday by 5 PM. You
are allowed 12 late days for the semester, of which at most 7 can be used
on any individual problem set. (1 late day = 24 hours exactly). For
an exception, you must have your senior tutor (for undergrads) or your
advisor (for graduate students) must contact me.
The problem sets will be challenging, so be sure to start them early.
You are encouraged to discuss the course material and the homework problems
with each other in small groups (23 people), as long as you list all discussion
partners on your problem set. Discussion of homework problems may include
brainstorming and verbally walking through possible solutions, but should
not include one person telling the others how to solve the problem.
In addition, each person must write up their solutions independently.
You may not look at another student's written solutions.
Readings
The required text for this course is:

C.H. Papadimitriou. Computational
Complexity. I've ordered it at the Coop, but you may be able
to find a better price online. This is an excellent introduction
to complexity theory. However, a fair amount of material from the
course (e.g. most of the second half) is not covered in Papadimitriou's
text, so it is crucial that you attend lectures.
The following texts are also on reserve in the library. Additional
references for advanced topics may be given later in the course.

J. L. Balcazar, J. Diaz, and J. Gabarro. Structural Complexity, Vols.
I & II.

M. Blum, F. Cucker, M. Shub, and S. Smale. Complexity and Real
Computation.

P. Burgisser, M. Clausen, and M.A. Shokrollahi. Algebraic Complexity
Theory.

D. Z. Du and K. Ko. Theory of Computational Complexity.

M. R. Garey & D. S. Johnson. Computers and Intractability:
A Guide to the Theory of NPcompleteness.

L. Hemaspaandra and M. Ogihara. Complexity Theory Companion.

J..E. Hopcroft and J.D. Ullman. Introduction to Automata Theory,
Languages, and Computation.

M.J. Sipser. Introduction to the Theory of Computation.

J. van Leeuwen, ed. Handbook of Theoretical Computer Science,
Volume A: Algorithms and Complexity.
Related Courses