### CS52 - Spring 2017 - Class 21

#### Lecture notes

- start making progress on assignment 8

• 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 computational power of computers (and other similar things)

- 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 than complexity theory and reasoning about runtime

• languages
- a language (L) is a set of strings

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

- we want to ask a simple question:
- given a string of characters 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 begins (indicated by a triangle/arrow next to the state)
- we have a collection of final states (indicated by states with an inner circle)
- for each state and each letter in our alphabet, we have a transition to another state
- Note it's critical that for each state there is exactly one transition for each letter in the alphabet
- If not, then if we encountered that letter we wouldn't know what to do!

- 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. when we get to the end of the string we are in a final state) we accept the string
- otherwise, if when we get to the end of the string/tape and we're in a non-final state we reject

- all strings accepted by a DFA define a language

- look at bbab DFA (found in DFA examples)
- We can run different strings through the DFA

- For example: abbbaabab
start in q0
a -> q0
b -> q1
b -> q2
b -> q2
a -> q3
a -> q3
b -> q4
a -> q4
b -> q4

- We accept the string

- aabab
- reject (finishes in state q2)
- bbb
- reject (finishes in state q2)
- babbab
- accept
- aabbaab
- accept
- aaa
- reject (finishes in state q0)

- what language (in English) does this define)?
- all strings with bbab as a subsequence, possibly with characters in between

• 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

• 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*

- a(a|b)*

- BREAK INTO GROUPS AND SOLVE:
- 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)*

• regular expressions
- another way of expressing a language
- *not* a computational model
- built from three key things:
* (kleene star): 0 or more repetitions
| : union or "or" (has lowest precedence)
() : used to enforce precedence
- for each of the examples above, I have written a corresponding regular expression below it that also describes the language