Computational Models: Class 1

Transcription

1 Computational Models: Class 1 Benny Chor School of Computer Science Tel Aviv University October 19, 2015 Based on slides by Maurice Herlihy, Brown University, and modifications by Iftach Haitner and Yishay Mansour. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

2 Central Computer Science Questions What is a computer? And what is a computation? In the course, we will develop several computational models, of varying computational powers. These models will provide manageable mathematical abstractions, yet capture the essence of computers and computations. We will start with the simplest such model, termed DFA (deterministic finite automata), or FSM (finite state machine, also interpreted as the flying spaghetti monster). Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

3 Class 1: Outline Finite automata and regular languages Regular operations Sipser s book, chapter 1.1 Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

4 Part I Finite Automata Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

5 Example: An One Way Automatic Door This door has 2 states, open and closed. Pads in front and rear of the door provide inputs, and affect the next state. This is illustrated graphically by: front pad rear pad door open when person approaches hold open until person clears don t open when someone standing behind door Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

6 The Automatic Door as DFA REAR BOTH NEITHER closed FRONT open FRONT REAR BOTH NEITHER States: OPEN CLOSED Sensor: FRONT: someone on front pad REAR: someone on rear pad BOTH: someone(s) on both pads NEITHER no one on either pad. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

7 The Automatic Door as DFA A DFA stands for Deterministic Finite Automata REAR BOTH NEITHER closed FRONT open FRONT REAR BOTH NEITHER neither front rear both closed closed open closed closed open closed open open open Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

8 DFA: Informal definition A different machine, M 1 : q 1 q q 2 3 States: q 1, q 2, and q 3. Start state: q 1 (arrow from outside ). Accept state: q 2 (double circle). State transitions: arrows tagged with letters. 0,1 Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

9 DFA: Informal definition (cont.) q 1 q q 2 3 0,1 On an input string M1 begins in start state q 1 after reading each symbol, DFA makes a state transition with matching label. After reading last symbol, DFA produces output: accept if DFA is an accepting state. reject otherwise. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

10 DFA: Informal definition (cont..) q 1 q q 2 3 0,1 What happens on the following input strings: and what happens in general (which strings are accepted by M 1 )?! Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

11 DFA: Informal definition (cont...) q 1 q q 2 3 This DFA accepts All input strings that end with a 1 All input strings that contain at least one 1, and end with an even number of 0 s No other strings We leave it to you to ponder why this is true. 0,1 Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

12 DFA - Formal Definition Definition 1 A deterministic finite automaton (DFA) is a 5-tuple (Q, Σ, δ, q 0, F), where Q is a finite set called the states, Σ is a finite set called the alphabet, δ : Q Σ Q is the transition function, q 0 Q is the start state, and F Q is the set of accept states. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

13 Back to M q 1 q q 2 3 0,1 M 1 = (Q, Σ, δ, q 1, F) where Q = {q 1, q 2, q 3 }, Σ = {0, 1}, the transition function δ is q 1 is the start state F = {q 2 }. 0 1 q 1 q 1 q 2 q 2 q 3 q 2 q 3 q 2 q 2 Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

14 Another Example a s b a q 1 r 1 b b a a b b q 2 r 2 a Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

15 A Formal Model of Computation Definition 2 Let M = (Q, Σ, δ, q 0, F) be a DFA, and let w = w 1 w 2 w n be a string over Σ. We say that M accepts w if there is a sequence of states r 0,..., r n (r i Q) such that r 0 = q 0 δ(r i, w i+1 ) = r i+1, 0 i < n r n F Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

16 Alphabets and Words Definition 3 An alphabet Σ is a finite set of letters. For example: Σ = {a, b, c,..., z} the English alphabet. Σ = {α, β, γ,..., ζ} the Greek alphabet. Σ = {0, 1} the binary alphabet. Σ = {0, 1,..., 9} the digital alphabet. Definition 4 A word (i.e., string) over Σ, is a finite sequence of letters from Σ. The empty word, ε is the word of length 0, which contains no letter. The collection of all strings over Σ is denoted by Σ. For the binary alphabet, ε, 1, 0, , are all members of Σ. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

17 Languages Definition 5 A language over Σ is a (possibly infinite) subset of Σ. Language examples: Modern English. Ancient Greek. All prime numbers, written using digits. A = {w {0, 1} : w has at most seventeen 0 s}. B = {0 n 1 n : n 0}. C = {w {0, 1} : w has an equal number of 0 s and 1 s}. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

18 The language of a DFA Definition 6 L(M), the language of a DFA M, is the set of strings that M accepts. M may accept many strings M accepts only one language. What language does M accept if it accepts no strings? Definition 7 A language L Σ is called regular, if some deterministic finite automaton accepts it. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

19 Determining and Proving the language of a DFA M 1 is the following DFA: q 1 q q 2 3 0,1 Lemma 8 L(M 1 ) = {w10 2k : k 0, w Σ } Proof: We will define 3 languages, L 1, L 2, L 3, whose union equals Σ. We will show that for each string w Σ, if w L i then on input w, M 1 ends in state q i. The proof is by induction on the length of w. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

20 Determining and Proving the language of a DFA, cont. Definition 9 L 1 = {0 k : k 0} L 2 = {w10 2k : k 0, w Σ } L 3 = {w10 2k+1 : k 0, w Σ } First, note that indeed L 1 L 2 L 3 = Σ. Induction basis (length 0): Easy to see that hypothesis holds for ɛ (which is the only word of this length). Induction step: Assume hypothesis holds for words of length j 0, and prove for words of length j + 1. Let x = yσ, where y Σ and σ Σ, be a word of length j + 1 (hence, y = j). We prove the hypothesis for x, separately for each i {1, 2, 3}. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

21 Proving the language of a DFA: the case y L 1 By induction hypothesis, if y L 1 then on input y, M 1 ends in state q 1. y L 1 means it is of the form y = 0 j. Thus x = 0 j+1 or x = 0 j 1. If x = 0 j+1, then x L 1. By the transition function, after reaching state q 1 on input y, M 1 on the input letter 0 stays in state q 1. So in this case indeed on input x, M 1 ends in state q 1. If x = 0 j 1, then x L 2. By the transition function, after reaching state q 1 on input y, M 1 on the input letter 1 moves to state q 2. So in this case indeed on input x, M 1 ends in state q 2. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

22 Proving the language of a DFA: the cases y L 2, y L 3 We leave these cases to you. This is part of assignment 1. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

23 Additional Examples of Regular languages Let Σ = {0, 1}. L odd = {w {0, 1} : w i = 1 (mod 2)} (odd number of 1 s). L 0 1 = {0m 1 n : m, n 0} (a block of consecutive 0s, followed by a block of consecutive 1s). Any finite language. Claim: All the above languages are regular How would you prove this? Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

24 A DFA Class in Python class DFA: current_state = None def init (self, states, alphabet, transition_function, start_state, accept_states): self.states = states self.alphabet = alphabet self.transition_function = transition_function self.start_state = start_state self.accept_states = accept_states self.current_state = start_state return def transition_to_state_with_input(self, input_value): if (self.current_state, input_value) not in \ self.transition_function.keys(): self.current_state = None return else: self.current_state = \ self.transition_function[(self.current_state, input_value)] return modified from Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

25 A DFA Class in Python, cont. def in_accept_state(self): return self.current_state in accept_states def go_to_initial_state(self): self.current_state = self.start_state return def run_with_input_string(self, input_string): self.go_to_initial_state() for input_char in input_string: print(self.current_state,input_char) self.transition_to_state_with_input(input_char) continue if self.current_state is None: return None else: print(self.current_state) return self.in_accept_state() Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

26 Building an Instance of a DFA in Python states = {(0,0), (0,1), (0,2), (1,0), (1,1), (1,2)} alphabet = { 0, 1 } start_state = (0,0) accept_states = {(1,0),(1,1),(1,2),(0,1)} tf = dict() tf[((0,0), 0 )] = (0,0) tf[((0,1), 0 )] = (0,1) tf[((0,2), 0 )] = (0,2) tf[((1,0), 0 )] = (1,0) tf[((1,1), 0 )] = (1,1) tf[((1,2), 0 )] = (1,2) tf[((0,0), 1 )] = (1,1) tf[((0,1), 1 )] = (1,2) tf[((0,2), 1 )] = (1,0) tf[((1,0), 1 )] = (0,1) tf[((1,1), 1 )] = (0,2) tf[((1,2), 1 )] = (0,0) what = DFA(states, alphabet, tf, start_state, accept_states) What is this DFA doing? What language does it accept? Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

27 Running the Instance of the DFA on an Input String >>> inp_string = list( ) >>> print(what.run_with_input_string(inp_string)) (0, 0) 0 (0, 0) 0 (0, 0) 1 (1, 1) 1 (0, 2) 1 (1, 0) 1 (0, 1) 0 (0, 1) 1 (1, 2) 0 (1, 2) 1 (0, 0) 1 (1, 1) 1 (0, 2) 0 (0, 2) 1 (1, 0) True In our Python implementation, the states the machine goes through, and the input letters, are printed. At the end, True/False is printed and returned, depending on the DFA reaching an accept state or not. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

28 Part II Regular Operations Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

29 The regular operations Let A and B be languages. The union operation: A B = {x : x A or x B} The concatenation operation: A B = {xy : x A and y B} The star operation: A = {x 1 x 2... x k : k 0 and each x i A} We ll show that regular languages are closed under the regular operations. Will start today (with union) and continue next week (with concatenation and star). Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

30 The regular operations Examples Let A= {good, bad} and B = {boy, girl}. Union Concatenation A B = {good, bad, boy, girl} A B = {goodboy, goodgirl, badboy, badgirl} Star A = {ε, good, bad, goodgood, goodbad, badbad, badgood,...} Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

31 Closure under union Theorem 10 If A 1 and A 2 are regular languages, then so is A 1 A 2. Approach to Proof: Some DFA M 1 accepts A 1 Some DFA M 2 accepts A 2 Construct DFA M that accepts A 1 A 2. Attempted Proof Idea: First simulate M 1 on the input string, and if M 1 doesn t accept, then simulate M 2. What s wrong with this idea? Fix: Simulate both machines simultaneously on the input string. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

32 Closure Under Union: Correct Proof Suppose M 1 = (Q 1, Σ, δ 1, q 1, F 1 ) accepts L 1, M 2 = (Q 2, Σ, δ 2, q 2, F 2 ) accepts L 2. Define M as follows (M will accept L 1 L 2 ): Q = Q 1 Q 2. Σ is the same. For each (r 1, r 2 ) Q and a Σ, δ((r 1, r 2 ), a) = (δ 1 (r 1, a), δ 2 (r 2, a)) q 0 = (q 1, q 2 ) F = {(r 1, r 2 ): r 1 F 1 or r 2 F 2 }. Formal proof (next slide) (hey, why not choose F = F 1 F 2?) Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

33 Correctness of the construction Claim 11 L(M) = L(M 1 ) L(M 2 ). Specifically, will show Claim 12 If M on input x reaches state (q 1, q 2 ), then M 1 on input x reaches state q 1, and M 2 on input x reaches state q 2. Proof by Induction on the input length. Induction Basis: x = ɛ, x = 0. Trivial. Induction Step: x = yσ, x = i + 1, y = i and σ Σ. Follows from the definition of δ. Completing the proof: On the board. Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34

34 What about concatenation? Theorem 13 If L 1, L 2 are regular languages, then so is L 1 L 2. Example: L 1 = {good, bad} and L 2 = {boy, girl}. L 1 L 2 = {goodboy, goodgirl, badboy, badgirl} This is much harder to prove. Idea: Simulate M 1 for a while, then switch to M 2. Problem: But when do you switch? This leads us into non-determinism, but we must wait for next class... Benny Chor (Tel Aviv University) Computational Models: Class 1 October 19, / 34