Faculty of Computer Science - Master of Science in Computer Science

**[M1]** *Introduction to Automata Theory, Languages,
and Computation (2nd edition).* J.E. Hopcroft, R. Motwani,
J.D. Ullman. Addison Wesley, 2003.

**[M2]** *Lecture Notes for
Theory of Computing*. Diego Calvanese. 2004. Available as scanned
pages in pdf.

**[M3]**
*Exercises on Theory of
Computing*. Andrea Calì. 2004. Available as scanned pages in
pdf.

Week |
Topics |
Monday10:30-12:30 (lecture) |
Wednesday10:30-12:30 (lecture) |
Wednesday16:00-18:00 (exercise) |
---|---|---|---|---|

#1Oct. 6 |
Course introduction | -- | Course introduction, basic notions about languages (Lec 1,2) |
-- |

#2Oct. 11 |
Finite automata | Deterministic FA (Lec 3,4) |
Nondeterministic FA (Lec 5,6) |
DFAs and NFAs (Exer 1) |

#3Oct. 18 |
Regular expressions | Epsilon-NFAs (Lec 7,8) |
Regular expressions, from RE to FA (Lec 9,10) |
Epsilon-NFAs and RE (Exer 2) |

#4Oct. 25 |
Regular languages | From DFA to RE, closure properties for RL (Lec 11,12) |
Pumping lemma (Lec 13,14) |
Regular languages (Exer 3) |

#5Nov. 1 |
Properties of regular languages | -- | Decision properties of regular languages (Lec 15,16) |
Regular languages (Exer 4) |

#6Nov. 8 |
Formal grammars | Minimization of automata (Lec 17,18) |
Formal grammars (Lec 19,20) |
Formal grammars (Exer 5) |

#7Nov. 15 |
Context free grammars, pushdown automata | Context free grammars (Lec 21,22) |
Pushdown automata (Lec 23,24) |
Regular languages, finite automata (Exer 6) |

#8Nov. 22 |
Midterm exam | Topics for midterm exam (Exer 7) |
Midterm exam (ME) |
-- |

#9Nov. 29 |
Context free languages | Simplifying CFGs (Lec 25,26) |
Chomsky normal form, pumping lemma for CFLs (Lec 27,28) |
CFGs and PDAs (Exer 8) |

#10Dec. 6 |
Properties of context free languages | Closure and decision properties of CFLs (Lec 29,30) |
-- | -- |

#11Dec. 13 |
Turing Machines | Undecidable problems (Lec 31,32) |
The Turing Machine (Lec 33,34) |
Closure properties of CFLs and TMs (Exer 9) |

#12Dec. 20 |
Extensions of Turing Machines | Programming techniques for TMs, multi-tape TMs (Lec 35,36) |
Nondeterministic TMs (Lec 37,38) |
Nondeterministic TMs and extensions of TMs (Exer 10) |

#13Jan. 10 |
Decidability and undecidability | Closure properties of R.E. languages (Lec 39,40) |
Topic lecture 2 (Lec 41,42) |
Recursive and R.E. languages (Exer 11) |

#14Jan. 17 |
Computational complexity | Rice's theorem, (in)tractable problems (Lec 43,44) |
NP-completeness (Lec 45,46) |
NP-complete problems (Exer 12) |

#15Jan. 24 |
Complexity classes | Complexity classes above NP (Lec 47,48) |
-- | Exam topics (Exer 13) |

**Topics**[M2: Part 1]- course presentation
- basic definitions about languages
- finite state machines

**What you should know after the lecture**- the formal meaning of alphabet, string, language
- how a finite-state machine works (informally)

**Topics**[M2: Part 2]- deterministic finite automata (DFA)
- extended transition function for a DFA
- nondeterministic finite automata (NFA)

**What you should know after the lecture**- the formal definitions of a DFA and of an NFA, and of the language they accept
- construct a DFA and an NFA for a given language

**Topics**[M2: Part 2]- relationship between DFAs and NFAs (subset construction)

**What you should know after the lecture**- how to prove that DFAs and NFAs accept the same class of languages
- how to contstruct a DFA from a given NFA

**Exercises on**finite automata [M3: Exercise 1]- [M1]: Exercises 2.2.2, 2.2.5, 2.2.8, 2.3.1

**Topics**[M2: Part 2]- finite automata with epsilon-transitions
- eliminating epsilon-transitions
- regular expressions

**What you should know after the lecture**- how to prove that epsilon-NFAs and NFAs accept the same class of languages
- how to construct an NFA from a given epsilon-NFA
- what the language generated by a regular expression is

**Topics**[M2: Part 3]- algebraic laws for regular expressions
- converting a regular expression to a finite automaton

**What you should know after the lecture**- what algebraic laws hold for regular expressions
- how to prove that each language generated by a R.E. is accepted by some finite automaton
- how to construct a finite automaton from a given R.E.

**Exercises on**finite automata and regular expressions [M3: Exercise 2]

**Topics**[M2: Part 3, Part 4]- converting a finite automaton to a regular expression
- closure properties of regular expressions

**What you should know after the lecture**- how to prove that finite automata accept exactly the regular languages
- how to construct a R.E. from a given automaton
- that regular languages are closed under regular and boolean operations

**Topics**[M2: Part 4]- pumping lemma for regular languages
- proving languages not to be regular

**What you should know after the lecture**- how to prove that a languages is not regular
- what properties can be decided about regular languages

**Exercises**on regular languages [M3: Exercise 3]

**Topics**[M2: Part 4]- decision problems for regular languages
- minimization of finite automata

**What you should know after the lecture**- what properties about regular languages can be decided, and what is the computational cost

**Exercises**on regular languages [M3: Exercise 4]

**Topics**[M2: Part 4]- minimization of finite automata
- Chomsky formal grammars

**What you should know after the lecture**- how to minimize a finite automaton
- what a Chomsky formal grammar is

**Topics**[M2: Part 4]- classification of formal grammars

**What you should know after the lecture**- what the language defined by a formal grammar is
- how formal grammars are classified

**Exercises on**formal grammars [M3: Exercise 5]

**Topics**[M2: Part 5]- contex-free grammars
- parse-trees for contex-free grammars
- ambiguous grammars
- pushdown automata (PDAs)

**What you should know after the lecture**- how to construct the parse-tree corresponding to a derivation
- recognize when a context-free grammar is ambiguous
- how a pushdown automaton is defined

**Topics**[M2: Part 6]- istantaneous description for a pushdown automaton
- PDA acceptance by final state and by empty stack
- equivalence of PDAs that accept by final state and by empty stack

**What you should know after the lecture**- how to define a PDA for a given context free language
- how to convert a PDA that accepts by final state into an equivalent one that accepts by empty stack, and vice-versa

**Exercises on**regular languages and finite automata [M3: Exercise 6]

**Exercises on**regular languages, automata, and grammars (preparation for midterm exam) [M3: Exercise 7]

**Topics**- regular languages
- automata
- formal grammars

**Topics**[M2: Part 6, Part 7]- relationship between PDAs and CFGs
- simplifying context free grammars (eliminating useless symbols, eliminating epsilon-transitions)

**What you should know after the lecture**- how to convert a CFG to a PDA that accepts by empty stack
- how to eliminate useless symbols from a CFG
- how to eliminate epsilon-productions from a CFG

**Topics**[M2: Part 7b]- eliminating unit-productions
- Chomsky normal form for a CFG
- pumping lemma for context-free languages

**What you should know after the lecture**- how to eliminate unit-productions from a CFG
- how to convert a CFG into Chomsky normal form
- how to prove that a language is not context-free by applying the pumping lemma

**Exercises on**context-free grammars and pushdown automata [M3: Exercise 8]

**Topics**[M2: Part 7b]- closure properties for context-free languages
- decision properties for context-free languages

**What you should know after the lecture**- under which operations contex-free languages are closed and not closed
- which decision problems related to context-free can be solved by an algorithm, and what is the computational cost of the algorithm

**Topics**[M2: Part 8]- an example for an undecidable problem: the Hello-world problem
- proving undecidability by reduction to an undecidable problem

**What you should know after the lecture**- a technique to prove that a problem is undecidable
- how one can exploit an undecidable problem to show that other problems are also undecidable

**Topics**[M2: Part 8]- the Turing Machine
- instantaneous description of a Turing Machine
- recursive enumerable and recursive languages

**What you should know after the lecture**- how a Turing Machine is formally defined
- relationship between acceptance by a TM and acceptance by a FA/PDA

**Exercises on**closure properties of contex-free languages and Turing Machines [M3: Exercise 9]

**Topics**[M2: Part 8]- programming techniques for Turing Machines
- storage in the state
- multiple tracks
- subroutines and procedure calls

- multi-tape Turing Machines

- programming techniques for Turing Machines
**What you should know after the lecture**- how one can program a TM easier by imposing structure on states and tape symbols
- how a multi-tape TM can be simulated by a single-tape TM

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

**What you should know after the lecture**- 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

**Exercises on**nondeterministic Turing Machines and extensions of Turing Machines [M3: Exercise 10]

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

- closure properties of recursive and R.E. languages

- classes of languages/problems
**What you should know after the lecture**- how languages/problems can be classified
- how to prove closure properties of recursive and R.E. languages

**Topics**[M2: Part 9]- showing languages to be nonrecursive/non-R.E.
- encoding Turing Machines as binary strings/integers
- enumerating binary strings/Turing Machines
- a non-R.E. language: the diagonalization languages
- a non-recursive language: the universal language

**What you should know after the lecture**- how to encode a Turing Machine as a binary string
- how to prove that the diagonalization language is non-R.E.
- how to prove that the universal language is non-recursive

**Exercises on**recursive and R.E. languages [M3: Exercise 11]

**Topics**[M2: Part 9, M2: Part 10]- Rice's theorem
- tractable and intractable problems
- the classes P and NP
- a problem in NP: SAT

**What you should know after the lecture**- how to prove Rice's theorem
- how the classes P and NP are defined
- how to show a problem to be in NP

**Topics**[M2: Part 10]- SAT and CSAT
- poly-time reductions
- NP-hardness and NP-completeness
- Cook's theorem

**What you should know after the lecture**- how to polynomially reduce one problem to another
- sketch the proof of Cook's theorem
- how to show a problem to be NP-hard

**Exercises on**NP-complete problems [M3: Exercise 12]

**Topics**[M2: Part 10]- coNP-complete problems
- oracle Turing Machines
- the polynomial hierarchy and PSPACE
- the classes EXPTIME, EXPSPACE, and the exponential hierarchy

**What you should know after the lecture**- what an oracle TM is
- how the polynomial hierarchy is defined
- typical problems complete for the classes EXPTIME and EXPSPACE

**Exercises on**exam topics [M3: Exercise 13]