# Lectures, Course Outline, and Learning Objectives

## Section L0101 (Azadeh Farzan)

Prof. Farzan's lecture slides are posted on her personal website.

## Section L0201 (François Pitt)

#### Key to ASCII notation

- '
`{}`' = ∅ = "empty set" - '
`(-`' = ∈ = "element of" - '
`(_`' = ⊆ = "subset of" (not strict) - '
`u`' = ∪ = "union" - '
`n`' = ∩ = "intersection" - '
`~L`' == "complement of`L``L`" - '
`-]`' = ∃ = "there exists" - '
`\-/`' = ∀ = "for all" - '
`/\`' = ∧ = "and" - '
`\/`' = ∨ = "or" - '
`->`' = → = "implies" - '
`<->`' = ↔ = "if and only if (iff)" - '
`!`' = ¬ = "not",*e.g.*, '`a != b`' =`a`≠`b`= "`a`is not equal to`b`", '`w !(- L`' =`w`∉`L`= "`w`is not an element of`L`",*etc*. - '
`\sum`' = ∑ = summation sign - '
`\prod`' = ∏ = product sign - '
`\Sigma`' = Σ = capital greek letter Sigma, '`\delta`' = δ = lowercase greek letter delta,*etc*. - '
`|_x_|`' = ⌊`x`⌋ = floor(x) - '
`|^x^|`' = ⌈`x`⌉ = ceiling(x) - '
`_`' indicates a subscript,*e.g.*, '`q_1`' =`q`_{1} - '
`^`' indicates a superscript,*e.g.*, '`n^2`' =`n`^{2} - curly braces '
`{}`' surround longer subscripts/superscripts,*e.g.*, '`\sum_{0 <= i <= n} 2^{i/2}`' = ∑_{0 ≤ i ≤ n}2^{i/2}

## Lecture summaries

Every week,
specific sections of the textbooks
will be posted as readings.
You should read these sections
to prepare for the following week's lectures and tutorials.

At the end of each week,
a short summary of
the material covered during tutorials and lectures
will be posted.
When these files are in plain text (ASCII),
they will use the notation listed above
for mathematical symbols.

*Readings*: section 1.6 from Martin's book (and review sections 1.1 and 1.2 as needed);

sections 1.1, 1.2 from Prof. Hadzilacos' notes (and review chapter 0 as needed).

Week 1 lecture notes / Week 1 tutorial problems (with solutions)*Readings*: sections 1.3, 4.1, 4.2 from Prof. Hadzilacos' notes.

Week 2 lecture notes / Week 2 tutorial problems (with solutions)*Readings*: sections 4.1, 4.3-4.5, 1.1 from Prof. Hadzilacos' notes.

Week 3 lecture notes / Week 3 tutorial notes (with solutions)*Readings*: Chapter 3 from Prof. Hadzilacos' notes.

Week 4 lecture notes / Week 4 tutorial notes (with solutions)*Readings*: Chapter 3 from Prof. Hadzilacos' notes.

Week 5 lecture notes**(updated at 11:17 on Wed 15 Feb)**/ Additional notes on induction / Week 5 tutorial notes (with solutions)*Readings*: none for this week

Week 6 lecture notes / Week 6 tutorial notes (with solutions)*Readings*: sections 2.1, 2.2, 2.7, 2.8. from Prof. Hadzilacos' notes.

Week 7 lecture notes / Week 7 tutorial notes (with solutions)*Readings*: sections 2.3, 2.4, 2.5. from Prof. Hadzilacos' notes.

Week 8 lecture notes: see Prof. Farzan's page / Week 8 tutorial notes (with solutions)*Readings*: sections 1.4, 2.1, 2.2 from Martin's book

sections 7.1, 7.3 from Prof. Hadzilacos' notes.

Week 9 lecture notes / Week 9 tutorial notes (with solutions)*Readings*: sections 2.1, 2.2, 2.3 from Martin's book

sections 7.3, 7.4 from Prof. Hadzilacos' notes.

Week 10 lecture notes / Week 10 tutorial notes (with solutions)*Readings*: chapter 3 from Martin's book

sections 7.2, 7.4, 7.6 from Prof. Hadzilacos' notes.

Week 11 lecture notes / Week 11 tutorial notes (with solutions)—**updated at 10:00 on Thu 5 Apr***Readings*: chapter 3 from Martin's book

section 7.4 from Prof. Hadzilacos' notes.

Week 12 lecture notes / (*no tutorial this week*)

## Course outline

### Lecture topics

- Induction (simple, complete, well-ordering, structural). [3 weeks]
- Algorithm complexity and recurrence relations; divide-and-conquer algorithms; algorithm correctness. [5 weeks]
- Regular languages, finite-state automata, and regular expressions; context-free grammars. [4 weeks]

### Learning objectives

By the end of this course, students should...

- understand induction and be able to use its various forms (simple, complete, structural);
- understand how to state and prove the correctness of algorithms,
including basic complexity analysis:
- be able to write preconditions and postconditions,
- be able to write and prove loop invariants,
- be able to prove partial correctness and termination of iterative and recursive algorithms,
- be able to setup and solve recurrence relations for the running time of recursive algorithms;

- know common divide-and-conquer algorithms:
- understand merge-sort and quick-sort,
- be able to write similar algorithms to solve related problems;

- understand basic properties of languages:
- know the formal definition of a language and related concepts
(strings, alphabets,
*etc*.), - understand the concept of regular languages:
- know regular expressions (regexps),
- know finite-state automata (FSAs),
- understand the equivalence between regular expressions, deterministic finite-state automata and non-deterministic finite-state automata,
- be aware of the limitations of regular languages,

- know context-free grammars (CFGs).

- know the formal definition of a language and related concepts
(strings, alphabets,