### CS30 - Spring 2016 - Class 23

#### Lecture notes

- NIM tournament in class next Tuesday

• midterm
- can hand in revised solutions for any of the problems and receive up to half of the points back
- For T/F and circle the answer questions, must also provide an explanation!
- must work on it on your own, but may use any of the normal resources you use for an assignment (i.e. the book, wing/python, the class notes, etc.)
- hand me back your original final and a separate set of clearly labeled revisions
- due by beginning of class on Tuesday, 4/26

• talk at a high level about theoretical models of computation

• models of computation
- going to look at some very simple models of computation
- much simpler than modern computers

- why simple models?
- they're much easier to understand
- allow us to reason and think about them

- even though they're simple models, many of them can be shown to have similar capabilities as modern computers (just not as fast :)
- therefore, reasoning about these simplified models will (in some cases) allow us to reason about things

- answer questions like:
- What are the capabilities and limitations of computers?
- E.g. are there problems that we could NEVER (even given an infinite amount of time, memory, etc.) answer with a computer?

- slightly different then complexity theory and reasoning about big-O

• languages
- a language (L) is a set of strings (possibly infinite in size)

- strings in that language are build up from an alphabet of characters, often denoted \sigma

- we want to ask a simple question:
- given a string of character in \sigma does it belong to the language L

• deterministic finite automata (DFA)
- basic idea
- we have a set of states (indicated by circles)
- we have a start state where computation starts (indicated by an triangle/arrow next to the state)
- we have a collection of final state(s) (indicated by states with an inner circle)
- for each state and each letter in our alphabet, we have a transition to another state

- computing
- we have a string as input on a tape
- we start at the beginning of the string
- read a symbol from the tape and transition to the state indicated by the model
- if:
- we end in a final state (i.e. get to the end of the string) we accept the string
- otherwise, if when we get to the end of the string/tape we're in a non-final state we reject

- the strings accepted by a DFA define a language

• some DFA examples (found in DFA_examples)
- no_a (1): Strings of a's and b's with no a's
- b*

- even_a (2): Strings of a's with an even number of a's
- (aa)*

- 5a (3): Strings with a's that are multiples of 5
- (aaaaa)*

- one_a (4): Strings with only one a
- b*ab*

- start_a (5): all strings that start with a
- a(a|b)*

- start_end: Strings that start and end with the same letter
- (a(a|b)*a)|(b(a|b)*b)|a|b

- odd: odd length strings
- (a|b)((a|b)(a|b))*

- two_a: strings with two or more a's
- (a|b)*a(a|b)*a(a|b)*

- two_exact_a: strings with exactly two a's
- b*ab*ab*

- ab: some number of repetitions of ab
- (ab)*

• formal definition of DFAs
- defined by 5 things
- \sigma: alphabet
- Q: set of states
- q_start: starting state
- F \subset Q: final states
- \delta: state transition function
- Q x \sigma -> Q
- transitions for each state for each letter in the alphabet to some other state
- often written as a table