Faculty of Computer Science

Master of Science in Computer Science

**[M1]** *Introduction to Automata Theory, Languages,
and Computation (3rd edition).* J.E. Hopcroft, R. Motwani,
J.D. Ullman. Addison Wesley, 2007.
**[M2]** *Lecture Notes for
Theory of Computing*. Diego Calvanese. 2009. Available as
scanned pages in pdf.
**[M3]** *Languages and Machines (3rd edition).*
Thomas A. Sudkamp. Addison Wesley, 2005.
Only Chapter 13.
**[M4]** *Complexity Theory.* Ingo Wegener.
Springer, 2005.
Only Chapter 14.
**[M5]**
*Exercises on Theory of
Computing*. Available as scanned pages in pdf.

**Topics**[M2: Part 1]- course presentation
- basic definitions about sets

**What you should know after the lecture**- the basic definitions regarding sets, relations, and their properties

**Review of**basic proof techniques [M2: Part 0]- deductive proofs
- proving equivalences of sets
- proof by contradiction
- proof by induction

**Topics**[M2: Part 1]- basic definitions about relations and functions
- cardinality of a set, countable and uncountable sets, Cantor's theorem

**What you should know after the lecture**- the definition of cardinality of a set
- the difference between countable and uncountable sets
- Cantor's diagonalization argument

**Topics**[M2: Part 2]- basic definitions about languages
- the Turing Machine
- instantaneous description of a Turing Machine

**What you should know after the lecture**- the formal meaning of alphabet, string, language
- how a Turing Machine is formally defined
- design Turing Machines that recognize some simple languages

**Exercises on**deterministic Turing Machines [M5: Exercise 02]

**Topics**[M2: Part 2]- recursive and recursive enumerable languages
- examples of Turing Machines
- programming techniques for Turing Machines
- storage in the state
- multiple tracks
- subroutines and procedure calls

**What you should know after the lecture**- how one can program a TM easier by imposing structure on states and tape symbols
- how one can implement a procedure call with a TM

**Topics**[M2: Part 2]- multi-tape Turing Machines
- running time of a Turing Machine
- nondeterministic Turing Machines

**What you should know after the lecture**- how a multi-tape TM can be simulated by a single-tape TM
- how a nondeterministic TM can be simulated by a multi-tape TM (and hence also by a single-tape TM)
- the cost of simulating a nondeterministic TM by a deterministic TM

**Topics**[M2: Part 3]- classes of languages/problems
- recursive/decidable languages
- recursively enumerable (R.E.) languages
- non-R.E. languages

- Church-Turing Thesis

- classes of languages/problems
**What you should know after the lecture**- how languages/problems can be classified
- the Church-Turing Thesis and its implications

**Topics**[M2: Part 3]- closure properties of recursive and R.E. languages
- encoding Turing Machines as binary strings/integers

**What you should know after the lecture**- how to prove closure properties of recursive and R.E. languages
- how to encode a Turing Machine as a binary string

**Topics**[M2: Part 3]- enumerating binary strings/Turing Machines
- showing languages to be non-recursive/non-R.E.
- a non-R.E. language: the diagonalization languages
- a non-recursive language: the universal language
- Universal Turing Machines
- the notion of reduction between problems/languages

**What you should know after the lecture**- how to prove that the diagonalization language is non-R.E.
- how to prove that the universal language is non-recursive
- what a reduction is

**Exercises on**non-deterministic Turing Machines and further Turing Machines extensions. Exercises on the correspondence between function computation and language recognition by Turing Machines. [M5: Exercise 03]

**Topics**[M2: Part 3, Part 4]- Rice's theorem
- Primitive recursive functions

**What you should know after the lecture**- how to prove Rice's theorem
- the definition of primitive recursive functions
- how to construct some simple primitive recursive functions

**Topics**[M2: Part 4]- examples of primitive recursive functions
- showing computability of primitive recursive functions

**What you should know after the lecture**- how to prove that every primitive recursive function is Turing computable

**Exercises on**reductions between problems. [M5: Exercise 04]

**Topics**[M2: Part 4]- bounded operators and bounded minimization
- Gödel numbering
- course-of-values recursion

**What you should know after the lecture**- how to define primitive recursive functions using bounded minimizations
- how to encode and decode a sequence of numbers by means of a single number
- how to define functions by means of course-of-values recursion, and how to show that they are primitive recursive

**Exercises on**Turing Machines computing functions [M5: Exercise 05]

**Topics**[M2: Part 4]- total computable functions that are not primitive recursive
- mu-recursive functions

**What you should know after the lecture**- how to prove the existence of computable functions that are not primitive recursive
- the definition of mu-recursive functions

**Exercises on**primitive recursive functions [M5: Exercise 06]

**Topics**[M2: Part 4]- arithmetization of Turing Machines

**What you should know after the lecture**- how to define a (primitive) recursive function that computes the trace of a Turing Machine computation
- how to define a mu-recursive function that simulates the computation of a Turing Machine computation

**Exercises on**the topics of the midterm exam [M5: Exercise 07]

**Topics**[M2: Part 5]- tractable and intractable problems
- the classes P and NP
- a problem in NP: SAT
- SAT and CSAT
- poly-time reductions

**What you should know after the lecture**- how the classes P and NP are defined
- how to show a problem to be in NP
- how to polynomially reduce one problem to another

**Topics**- Turing Machines
- decidability and undecidability
- recursive and recursively enumerable languages
- recursive functions

**Topics**[M2: Part 5]- NP-hardness and NP-completeness
- Cook's theorem

**What you should know after the lecture**- how to show a problem to be NP-hard
- how to prove Cook's theorem

**Topics**[M2: Part 5, Part 6]- coNP-complete problems
- oracle Turing Machines
- the polynomial hierarchy

**What you should know after the lecture**- how NP and coNP are related to each other
- what an oracle TM is
- how complexity classes based on oracle TMs are defined
- how the polynomial hierarchy is defined

**Exercises on**the reduction from 3SAT to CSAT [M5: Exercise 08]

**Topics**[M2: Part 6]- quantified boolean formulae
- space and time bounds for Turing Machines
- relationship between PSPACE and NPSPACE (Savitch's theorem)

**What you should know after the lecture**- how the problem of QBF is defined
- relationship between the space bound and the time bound for a TM
- how to prove Savitch's theorem

**Exercises on**reductions to show NP-hardness [M5: Exercise 09]

**Topics**[M2: Part 6]- PSPACE-completeness
- evaluation of a QBF in polynomial space

**What you should know after the lecture**- how to evaluate a QBF in polynomial space

**Topics**[M2: Part 6]- PSPACE-hardness of QBF
- the classes EXPTIME, EXPSPACE, and the exponential hierarchy
- logarithmic space

**What you should know after the lecture**- how to prove PSPACE-hardness of QBF
- typical problems complete for the classes EXPTIME and EXPSPACE
- how space is measured for sublinear space computations

**Topics**[M2: Part 6]- composition of LogSpace computations
- LogSpace reductions
- the complexity classes L and NL.

**What you should know after the lecture**- how the trivial, naive, and emulative compositions of function computations are defined
- how LogSpace reductions are defined
- how the complexity classes L and NL are defined

**Exercises on**reductions between NP-complete problems and exercises on space complexity [M5: Exercise 10]

**Topics**[M2: Part 6, Part 7]- the relationship between N and NL with graph connectivity
- the complement of NL
- families of circuits as a non-uniform computing model

**What you should know after the lecture**- how to prove that connectivity in directed graphs in NL-complete
- what a log-space reduction is
- how circuits are defined
- what the size and depth of a circuit are

**Topics**[M2: Part 7]- SIZE and DEPTH complexity measures for families of boolean functions and languages
- upper bounds on SIZE and DEPTH for arbitrary languages
- simulation of TMs by uniform circuits

**What you should know after the lecture**- how the complexity classes SIZE(f(n)) and DEPTH(f(n)) are defined
- how to prove that every language L has an exponential upper bound on SIZE
- how to prove that some languages L has an exponential lower bound on SIZE
- how to prove that every language L has a linear upper bound on DEPTH
- how to simulate TMs by uniform circuits

**Topics**[M2: Part 7]- non-uniform Turing Machines
- simulation of circuits by non-uniform TMs

**What you should know after the lecture**- how a non-uniform TM is defined
- how to simulate circuits by non-uniform TMs

**Topics**[M2: Part 7]- Binary Decision Diagrams (BDDs)
- branching program complexity of a boolean functions
- simulation of BDDs by space-bounded non-uniform TMs
- simulation of space-bounded TMs by BDDs

**What you should know after the lecture**- how BDDs are defined
- what the complexity measures for BDDs are
- how a BDD can be simulated by a space-bounded non-uniform TM
- how a space-bounded TM can be simulated by a BDD

**Exercises on**on boolean circuits [M5: Exercise 11]