front pad rear pad door

Transcription

1

2

3 front pad rear pad door

4 REAR BOTH NEITHER closed FRONT open FRONT REAR BOTH NEITHER Think of this as a simple program that outputs one of two values (states) when provided with the current state and an input that can take on one of three possible values. front

5 REAR BOTH NEITHER closed FRONT open FRONT REAR BOTH NEITHER Many authors describe an entity like this as a "state table". It clearly defines a simple function of two inputs.

6 q 1 q q 2 3 0,1 Most authors describe such an informal definition as a "state diagram" and each labeled arc as a transition.

7 q 1 q q 2 3 0,1

8 q 1 q q 2 3 0,1

9 q 1 q q 2 3 0,1

10

11 q 1 q q 2 3 0,1

12

13 a s b a q 1 r 1 b b a a b b q 2 r 2 a Give a verbal description for the language that this machiine accepts.

14 0 2,RESET q q 0 2 q 2 0 1,RESET Give a verbal description for the language that this machine accepts.

15

16 Experiment with JFLAP Use JFlap to construct some of the machines on pages 38 and 39. Use JFlap to construct a machine that accepts strings with an odd number of 1's. The alphabet is {0, 1}. Use JFlap to construct a machine that accepts strings with an even number of 0's. The alphabet is {0, 1}.

17

18 1) A* always contains the empty string 2) A* is infinite if A is not the empty language

19

20 T The construction works because, at any point in the processing of a string, M is in some state (a,b) either because M1 is in state a or M2 is in state b. This result is due to the processing of the same string in parallel. Note: The construction for M is postponed - we need another concept, non-determinism.

21

22 0,1 0,1 0 0,ε q q q q 4

23 0,1 0,1 0 0,ε q q q q 4

24 0,1 0,1 0 0,ε q q q q 4

25 0,1 0,1 0 0,ε q q 1 q q 4 symbol 1 q 1 0 q 1 0 q 1 q 2 q 3 1 q q q q 3 q q q 1 4 4

26 25

27 DFAs are easy to program simply because they are deterministic. In fact, it is easy to write a program that duplicates the functionality of all DFAs by simply taking the DFA's transition table as input. NFAs are more descriptive - easier to give an NFA that accepts a language than a DFA.

28 0 0 q q 100 q 010 q q 001 q q q

29 0,1 1 0,1 q q q ,1 q 4 The power of non-determinism is the "guess". Determinism requires one to perform a search to discover a desired situation while non-determinism requires only the ability for the proper path of choices to be available, assumes that such a path has been followed,and proceeds from there. The NFA provides a set of transition choices that can read all but the last three symbols of a string, assumes that the proper choices have been made, and then completes the processing deterministically.

30

31 0,1 0,1 0 0,ε q q q q 4

32

33

34

35 NFA N Equivalent DFA M

36

37

38 N 1 N 2

39 N 1 ε ε N 2

40

41 N 1 N 2

42 N 1 ε ε N 2

43

44 N 1 N 1 ε ε

45

46

47

48

49

50

51

52 a

53 N 1 ε ε N 2 N 1 ε ε N 2! ε N 1! N 1 ε

54 a a b b ba ab b ε a b ε a ε ba ab U a ε a

55

56

57 Start and accept states are unique

58

59

60 3-state DFA 5-state GNFA 4-state GNFA 3-state GNFA 2-state GNFA regular expression

61 R 4 q i q j R 1 R 3 q r R 2 q i R 1 R* 2 R 3 U R 4 q j

62

63

64

65

66

67

68

69

70 The CONVERT(G) algorithm converts any GNFA G, to a regular expression for the language accepted by G. Since G` has only k-1 states, the inductive hypothesis guarantees that CONVERT(G`) = CONVERT(G) is a regular expression for the language accepted by G`, and therefore (by 1 and 2), for the language accepted by G.

71

72 Proof restatement: Let r be the state removed from G in the creation of G`. The transition from state i to j in G` is the union of G's original regular expression from state i to j with the regular expression that defined transitions in G from state i to j and through r. Therefore, G` accepts all strings, w, that G accepts.

73

74

75

76 Let L >= 1 be the size of s. Assume that the machine moves thru qo q1... gt... ql in processing s, where ql is an accept state. Since L >= 1, at least one state qr appears more than once in the sequence.

77 y x z q 1 q q 9 13

78 A valid string in the language when we pump more y's. 1's when we pump more y's. when we pump more y's.

79 A valid string in the language when we pump more y's. 1's when we pump more y's. item 3 of the pumping lemma

80

81 N