Module 11

1

Module 11

• Proving more specific problems are not solvable

• Input transformation technique– Use subroutine theme to show that if one

problem is unsolvable, so is a second problem– Need to clearly differentiate between

• use of program as a subroutine and

• a program being an input to another program

2

Basic Idea/Technique

3

Primality Testing Problem

• Consider the following two problems– Halting Problem

• Input: Program P, unsigned x• Yes/No Question: Does P halt on x?

– Primality Testing Problem (PTP)• Input: Program P, unsigned x• Yes/No Question: Does P output correctly whether

or not x is a prime number?

• Which problem seems harder and why?

4

Question

• Suppose we construct a program PH which solves the Halting problem H under the following conditions– All of PH is known to be correct with the

exception of one procedure PL.

– This procedure PL is being used to solve the Primality Testing Problem.

• What can we conclude in this scenario?

5

Formalizing Technique

• Assume PL is a procedure that solves problem L– We have no idea how PL solves L

• Construct a program PH that solves H using PL as a subroutine– We use PL as a black box– (We could use any unsolvable problem in place of H)

• Argue PH solves H• Conclude that L is unsolvable

– Otherwise PL would exist and then H would be solvable– L will be a problem about program behavior

6

Focusing on H

• In this module, we will typically use H, the Halting Problem, as our known unsolvable problem

• The technique generalizes to using any unsolvable problem L’ in place of H.– You would need to change the proofs to work with L’

instead of H, but in general it can be done

• The technique also can be applied to solvable problems to derive alternative consequences

• We focus on H to simplify the explanation

7

Constructing PH using PL

Answer-preserving input transformations and Program PT

8

PH has two subroutines

• There are many ways to construct PH using program PL that solves L

• We focus on one method in which PH consists of two subroutines– Procedure PL that solves L– Procedure PT which computes a function f that I

call an answer-preserving (or answer-reversing) input transformation

• More about this in a moment

9

Pictoral Representation of PH *

PH

x Yes/NoPLY/NPT

PT(x)

10

Answer-preserving input transformation PT

• Input– An input to H

• Output– An input to L such that

• yes inputs of H map to yes inputs of L• no inputs of H map to no inputs of L

• Note, PT must not loop when given any legal input to H

11

Why this works *

PH

PLPT

yes input to H yes input to L yes

no input to H no input to L no

We have assumed that PL solves L

12

Answer-reversing input transformation PT

• Input– An input to H

• Output– An input to L such that

• yes inputs of H map to no inputs of L• no inputs of H map to yes inputs of L

• Note, PT must not loop when given any legal input to H

13

Why this works

PH

PLPT

yes input to H no input to L yes

no input to H yes input to L no

We have assumed that PL solves L

no

yes

14

Yes->Yes and No->No

Domain of H

Yes inputsfor H

No inputsfor H

Yes inputsfor L

No inputsfor L

Domain of L

PLPT

PH

x PT(x) Yes/No

15

Notation and Terminology

• If there is such an answer-preserving (or answer-reversing) input transformation f (and the corresponding program PT), we say that H transforms to (many-one reduces to) L

• NotationH <= L

Domain of H

Yes inputs No inputs

Yes inputs No inputsDomain of L

16

Examples not involving the Halting Problem

17

Generalization

• As noted earlier, while we focus on transforming H to other problems, the concept of transformation generalizes beyond H and beyond unsolvable program behavior problems

• We work with some solvable, language recognition problems to illustrate some aspects of the transformation process in the next few slides

18

Example 1

• L1 is the set of even length strings over {0,1}– What are the set of legal input instances and no inputs for

the L1 LRP?

• L2 is the set of odd length strings over {0,1}– Same question as above

• Tasks– Give an answer-preserving input transformation f that

shows that L1 LRP <= L2 LRP

– Give a corresponding program PT that computes f

Domain of L1


Yes inputs No inputsDomain of L2

19

Program PT

string main(string x)

{

return(x concatenate “0”);

}

20

Example 2

• L1 is the set of all strings over {0,1}

– What is the set of all inputs, yes inputs, no inputs for the L1 LRP?

• L2 is {0}– Same question as above

• Tasks– Give an answer-preserving input transformation f which

shows that the L1 LRP <=L2 LRP

– Give a corresponding program PT which computes f

Domain of L1



21

Program PT

string main(string x)

{

return( “0”);

}

22

Example 3

• L1 – Input: Java program P that takes as input an unsigned int– Yes/No Question: Does P halt on all legal inputs

• L2

– Input: C++ program P that takes as input an unsigned int– Yes/No Question: Does P halt on all legal inputs

• Tasks– Describe what an answer-preserving input transformation f

that shows that L1 <=L2 would be/do?

Domain of L1



23

Proving a program behavior problem L is unsolvable

24

Problem Definitions *

• Halting Problem H– Input

• Program QH that has one input of type unsigned int

• non-negative integer y that is input to program QH

– Yes/No Question• Does QH halt on y?

• Target Problem L– Input

• Program QL that has one input of type string

– Yes/No question• Does Y(QL) = the set of

even length strings?

• Assume program PL solves L

25

Construction review

PH

x Yes/No

•We are building a program PH to solve the halting problem H

PTPT(x)

•PH will use PT as a subroutine, and we must explicitly construct PT using specific properties of H and L

PLY/N

•PH will use PL as a subroutine, and we have no idea how PL accomplishes its task

26

P’s and Q’s• Programs which are PART of program PH and

thus “executed” when PH executes– Program PT, an actual program we construct– Program PL, an assumed program which solves

problem L

• Programs which are INPUTS/OUTPUTS of programs PH, PL, and PT and which are not “executed” when PH executes– Programs QH, QL, and QYL

• code for QYL is available to PT

27

Two inputs for L *


• Program Q that has one input of type string

– Yes/No question• Does Y(Q) = the set of


• Program PL

– Solves L– We don’t know how

• Consider the following program Q1

bool main(string z)

{while (1>0) ;}

– What does PL output when given Q1 as input?

• Consider the following program Q2

bool main(string z)

{ if ((z.length %2) = = 0) return (yes)

else return (no); }

– What does PL output when given Q2 as input?

28

Another input for L *


• Program Q that has one input of type string

– Yes/No question• Does Y(Q) = the set of


• Program PL

– Solves L– We don’t know how

• Consider the following program QL with 2 procedures Q1 and QYL

bool main(string z) {

Q1(5); /* ignore return value */

return(QYL(z));}

bool Q1(unsigned x) {if (x > 3) return (no); else loop;

}

bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);

else return(no);}

• What does PL output when given QL as input?

29

Input and Output of PT *

• Input of PT

• (Also Input of H)– Program QH

• one input of type unsigned int

– Non-negative integer y

• Program QL that is the output of PT

• (Also input of L)bool main(string z) {

QH(y); /* QH and y come left-hand side */ /* ignore return value */

return(QYL(z));}

bool QH(unsigned x) {/* comes from left-hand side

}

bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);

else return(no);}

QH,y PT QL

30

Example 1 *

Input to PT

Program QH

bool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}

Input y5

Output of PT

Program QL

bool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 5; QH(y); return (QYL(z));}

QH,y PT QL

31

Example 2

Input to PT

Program QH

bool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}

Input y3

Output of PT

Program QL

bool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 3; QH(y); return (QYL(z));}

QH,y PT QL

32

PT in more detail

33

Declaration of PT

• What is the return type of PT?– Type program1 (with one input of type string)

• What are the input parameters of PT?– The same as the input parameters to H; in this case,

• type program2 (with one input of type unsigned int)• unsigned int (input type to program2)

program1 main(program2 QH, unsigned y)

PLPT

PH

QH,y QL Yes/No

34

program1 main(program2 P, unsigned y) {

/* Will be viewing types program1 and program2 as STRINGS over the program alphabet P */

program1 QL = replace-main-with-QH(P);/* Insert line break */

QL += “\n”;

/* Insert QYL */

QL += “bool QYL(string z) {\n \t if ((z.length % 2) == 0) return (yes) else return (no);\n }”;

/* Add main routine of QL */

QL += “bool main(string z) {\n\t”; /* determined by L */

QL += “unsigned y =”

QL += convert-to-string(y);

QL += “;\n\t QH(y)\n\t return(QYL(z));\n}”;

return(QL);}

program1 replace-main-with-QH(program2 P) /* Details hidden */string convert-to-string(unsigned y) /* Details hidden */

Code for PT PLPT

PH

QH,y QL Yes/No

35

PT in action

PT

code for QYL

QH

unsigned ystart QYL

Y/Nz

Y/N

QL

haltQH

y

Program QHbool main(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}

Input y5

Program QLbool QH(unsigned y) { if (y ==5) return yes; else if (y ==4) return no; else while (1>0) {};}bool QYL(string z) { if ((z.length % 2) == 0) return (yes) else return (no);}bool main(string z) { unsigned y = 5; QH(y); return (QYL(z));}

PT

QYL

PLPT

PH

QH,y QL Yes/No

36

Constructing QL (and thus PT)

37

Start with no input for H

• If QH, y is a no input to the Halting problem

• Program QL bool main(string z) {

QH(y); /* ignore return value */

return(Q?L(z)); /* yes or no? */}


}

bool Q?L(string y) {

}

– Thus Y(QL) = {}

– QH loops on y

– Determine if this makes QL a no or yes input instance to L

38

Answer-preserving input transformation


– Thus Y(QL) = {}

– QH loops on y




return(QYL(z)); /* yes */}


}

bool QYL(string y) {

}

– Now choose a QYL (or QNL) that is a yes (or no) input instance to L

39

Make yes for H map to yes for L


– Thus Y(QL) = {}

– QH loops on y







}

bool QYL(string y) {if ((y.length( ) % 2) = = 0) return (yes);else return (no);

}

40

Possible shortcutProgram QL bool main(string z) {

QH(y); /* ignore return value */if ((z.length( ) % 2) = = 0) return (yes);else return (no);

}


}

Program QL bool main(string z) {




}


}

41

Another Example

42

Problem Definitions

• Halting Problem H– Input

• Program QH that has one input of type unsigned int

• non-negative integer y that is input to program QH

– Yes/No Question• Does QH halt on y?


• Program QL that has one input of type string

– Yes/No question• Is Y(QL) finite?

• Assume program PL solves L

43

Start with no input for H




return(Q?L(z)); /* yes or no? */}


}

bool Q?L(string y) {

}

– Thus Y(QL) = {}

– QH loops on y


44

Answer-reversing input transformation




return(QNL(z)); /* no */}


}

bool QNL(string y) {

}

– Thus Y(QL) = {}

– QH loops on y



45

Make yes for H map to no for L




return(QNL(z)); /* no */}


}

bool QNL(string y) {if ((y.length( ) % 2) = = 0) return(yes);else return(no);

}

– Thus Y(QL) = {}

– QH loops on y



46

Analyzing proposed transformations

4 possibilities

47

Problem Setup• Input of Transformation

• Program QH, unsigned x• Output of Transformation



return(QYL(z)); /* yes or no */}

bool QH(unsigned x) {}


}

• Problem L• Input: Program P• Yes/No Question: Is Y(P) =

{aa}?

• Question: Is the transformation on the left an answer-preserving or answer-reversing input transformation from H to problem L?

48

Key Step• Input of Transformation

• Program QH, unsigned x• Output of Transformation






}

• Problem L• Input: Program P• Yes/No Question: Is Y(P) =

{aa}?

• The output of the transformation is the input to the problem.• Plug QL in for

program P above• Is Y(QL) = {aa}?

49

Is Y(QL) = {aa}?• Problem L

• Input: Program P• Yes/No Question: Is Y(P) =

{aa}?• Analysis

• If QH loops on x, Y(QL)={}• No input to H creates a QL that

is a no input for L• If QH halts on x, Y(QL) =

{even length strings}• Yes input to H creates a QL

that is a no input for L• Transformation does not work

• All inputs map to no inputs

• Input of Transformation• Program QH, unsigned x

• Output of Transformation• Program QL bool main(string z) {





}

50

Three other problems• Problem L1

• Input: Program P• Yes/No Question: Is Y(P)

infinite?

• Problem L2• Input: Program P• Yes/No Question: Is Y(P)

finite?

• Problem L3• Input: Program P• Yes/No Question: Is Y(P) =

{} or is Y(P) infinite?







}

51

Is Y(P) infinite?• Problem L1


infinite?• Analysis

• If QH loops on x, Y(QL)={}• No input to H creates a QL

that is a no input for L• If QH halts on x, Y(QL) =


that is a yes input for L• Transformation works

• Answer-preserving







}

52

Is Y(P) finite?• Problem L2


finite?• Analysis


that is a yes input for L• If QH halts on x, Y(QL) =


that is a no input for L• Transformation works

• Answer-reversing







}

53

Is Y(P) = {} or is Y(P) infinite?• Problem L3

• Input: Program P• Yes/No Question: Is Y(P) =

{} or is Y(P) infinite?• Analysis


that is a yes input for L• If QH halts on x, Y(QL) =


that is a yes input for L• Transformation does not work

• All inputs map to yes inputs







}

54

Module 12

• Computation and Configurations– Formal Definition– Examples

55

Definitions

• Configuration– Functional Definition

• Given the original program and the current configuration of a computation, someone should be able to complete the computation

– Contents of a configuration for a C++ program• current instruction to be executed• current value of all variables

• Computation– Complete sequence of configurations

56

Computation 1

1 int main(int x,y) {

2 int r = x % y;

3 if (r== 0) goto 8;

4 x = y;

5 y = r;

6 r = x % y;

7 goto 3;

8 return y; }

Input: 10 3

• Line 1, x=?,y=?,r=?• Line 2, x=10, y=3,r=?• Line 3, x=10, y=3, r=1• Line 4, x=10, y=3, r=1• Line 5, x= 3, y=3, r=1• Line 6, x=3, y=1, r=1• Line 7, x=3, y=1, r=0• Line 3, x=3, y=1, r=0• Line 8, x=3, y=1, r=0• Output is 1

57

Computation 2

int main(int x,y) {

2 int r = x % y;

3 if (r== 0) goto 8;

4 x = y;

5 y = r;

6 r = x % y;

7 goto 3;

8 return y; }

Input: 53 10

• Line 1, x=?,y=?,r=?

• Line 2, x=53, y=10, r=?

• Line 3, x= 53, y=10, r=3

• Line 4, x=53, y=10, r=3

• Line 5, x=10, y=10, r=3

• Line 6, x=10, y=3, r=3

• Line 7, x=10, y=3, r=1

• Line 3, x=10, y=3, r=1

• ...

58

Computations 1 and 2

• Line 1, x=?,y=?,r=?

• Line 2, x=53, y=10, r=?

• Line 3, x= 53, y=10, r=3

• Line 4, x=53, y=10, r=3

• Line 5, x=10, y=10, r=3

• Line 6, x=10, y=3, r=3

• Line 7, x=10, y=3, r=1

• Line 3, x=10, y=3, r=1

• ...

• Line 1, x=?,y=?,r=?

• Line 2, x=10, y=3,r=?

• Line 3, x=10, y=3, r=1

• Line 4, x=10, y=3, r=1

• Line 5, x= 3, y=3, r=1

• Line 6, x=3, y=1, r=1

• Line 7, x=3, y=1, r=0

• Line 3, x=3, y=1, r=0

• Line 8, x=3, y=1, r=0

• Output is 1

59

Observation

int main(int x,y) {2 int r = x % y;3 if (r== 0) goto 8;4 x = y;5 y = r;6 r = x % y;7 goto 3;

8 return y; }

• Line 3, x= 10, y=3, r=1

• Program and current configuration– Together, these two pieces of

information are enough to complete the computation

– Are they enough to determine what the original input was?

• No!

• Both previous inputs, 10 3 as well as 53 10 eventually reached the same configuration (Line 3, x=10, y=3, r=1)

60

Module 13

• Studying the internal structure of REC, the set of solvable problems– Complexity theory overview– Automata theory preview

• Motivating Problem– string searching

61

Studying REC

Complexity Theory

Automata Theory

62

Current picture of all languagesll Languages

RE-REC ll languages - REHalf

SolvableNot even half solvable

Which language class should be studied further?

RECSolvable

63

Complexity Theory *

• In complexity theory, we differentiate problems by how hard a problem is to solve– Remember, all problems in REC are solvable

• Which problem is harder and why?– Max:

• Input: list of n numbers• Task: return largest of the n numbers

– Element• Input: list of n numbers• Task: return any of the n numbers

REC RE -REC

All languages - RE

64

Resource Usage *

• How do we formally measure the hardness of a problem?– We measure the resources required to solve

input instances of the problem• Typical resources are?

• Need a notion of size of an input instance– Obviously larger input instances require more resources to

solve

65

Poly Language Class *

Informal Definition: A problem L1 is easier than problem L2 if problem L1 can be solved in less time than problem L2.

Poly: the set of problems which can be solved in polynomial time (typically referred to as P, not Poly)

Major goal: Identify whether or not a problem belongs to Poly

Poly Rest of REC

REC RE -REC

All languages - RE

66

Working with Poly Poly Rest of REC

• How do you prove a problem L is in Poly?• How do you prove a problem L is not in

Poly?– We are not very good at this.– For a large class of interesting problems, we

have techniques (polynomial-time answer-preserving input transformations) that show a problem L probably is not in Poly, but few which prove it.

67

Examples

• Shortest Path Problem• Input

– Graph G

– nodes s and t

• Task– Find length of shortest

path from s to t in G

• Longest Path Problem• Input

– Graph G

– nodes s and t

• Task– Find length of longest

path from s to t in G

Poly Rest of REC

Which problem is provably solvable in polynomial time?

68

Automata Theory

• In automata theory, we will define new models of computation which we call automata– Finite State Automata (FSA)– Pushdown Automata (PDA)

• Key concept– FSA’s and PDA’s are restricted models of computation

• FSA’s and PDA’s cannot solve all the problems that C++ programs can

– We then identify which problems can be solved using FSA’s and PDA’s

REC RE -REC

All languages - RE

69

New language classes

• REC is the set of solvable languages when we start with a general model of computation like C++ programs

• We want to identify which problems in REC can be solved when using these restricted automata

Rest of RECSolvableby FSA’sand PDA’s

SolvablebyPDA’s

REC RE -REC

All languages - RE

70

Recap *• Complexity Theory

– Studies structure of the set of solvable problems– Method: analyze resources (processing time) used to

solve a problem

• Automata Theory– Studies structure of the set of solvable problems– Method: define automata with restricted capabilities and

resources and see what they can solve (and what they cannot solve)

– This theory also has important implications in the development of programming languages and compilers

71

Motivating Problem

String Searching

72

String Searching

• Input– String x

– String y

• Tasks– Return location of y in

string x

– Does string y occur in string x?

• Can you identify applications of this type of problem in real life?

• Try and develop a solution to this problem.

73

String Searching II

• Input– String x

– pattern y

• Tasks– Return location of y in

string x

– Does pattern y occur in string x?

• Pattern– [anything].html

– $EN4$$

• Try and develop a solution to this problem.

74

String Searching• We will show an easy way to solve these

string searching problems

• In particular, we will show that we can solve these problems in the following manner– write down the pattern– the computer automatically turns this into a

program which performs the actual string search

75

Module 14

• Regular languages– Inductive definitions– Regular expressions

• syntax

• semantics

76

Regular Languages(Regular Expressions)

77

Regular Languages

• New language class– Elements are languages

• We will show that this language class is identical to LFSA– Language class to be defined by Finite State Automata

(FSA)

– Once we have shown this, we will use the term “regular languages” to refer to this language class

78

Inductive Definition of Integers *

• Base case definition– 0 is an integer

• Inductive case definition– If x is an integer, then

• x+1 is an integer

• x-1 is an integer

• Completeness– Only numbers generated using the above rules are

integers

79

Inductive Definition of Regular Languages• Base case definition

– Let denote the alphabet– {} is a regular language – {} is a regular language– {a} is a regular language for any character a in

• Inductive case definition– If L1 and L2 are regular languages, then

• L1 union L2 is a regular language• L1 concatenate L2 is a regular language• L1

* is a regular language

• Completeness– Only languages generated using above rules are regular languages

80

Proving a language is regular *

• Prove that {aa, bb} is a regular language– {a} and {b} are regular languages

• base case of definition

– {aa} = {a}{a} is a regular language• concatenation rule

– {bb} = {b}{b} is a regular language• concatenation rule

– {aa, bb} = {aa} union {bb} is a regular language• union rule

• Typically, we will not go through this process to prove a language is regular

81

Regular Expressions

• How do we describe a regular language?– Use set notation

• {aa, bb, ab, ba}*

• {a}{a,b}*{b}

– Use regular expressions R• Inductive def of regular languages and regular

expressions on page 72

• (aa+bb+ab+ba)*

• a(a+b)*b

82

R and L(R) *

• How we interpret a regular expression– What does a regular expression R mean to us?

• aaba represents the regular language {aaba}

• represents the regular language {}

• aa+bb represents the regular language {aa, bb}

– We use L(R) to denote the regular language represented by regular expression R.

83

Precedence rules *

• What is L(ab+c*)?– Possible answers:

• {a}({b} union {c}*}

• ({a}{b,c})*

• ({ab} union {c})*

• {ab} union {c}*

– Must know precedence rules• * first, then concatenation, then +

84

Precedence rules continued

• Precedence rules similar to those for arithmetic expressions– ab+c2

• (a times b) + (c times c)

• exponentiation first, then multiplication, then addition

• Think of Kleene closure as exponentiation, concatenation as multiplication, and union as addition and the precedence rules are identical

85

Regular expressions are strings *

• Let L be a regular language over the alphabet – A regular expression R for L is just a string

over the alphabet union {(, ), +, *, } which follows certain syntactic rules

• That is, the set of legal regular expressions is itself a language over the alphabet union {(, ), +, *}

– , a*aba are strings in the language of legal reg. exp.

– )(, *a* are strings NOT in the language of legal reg. exp.

86

Semantics *

• We give a regular expression R meaning when we interpret it to represent L(R).– aaba is just a string

– we interpret it to represent the language {aaba}.

• We do similar things with arithmetic expressions– 10+72 is just a string

– We interpret this string to represent the number 59

87

Key fact *

• A language L is a regular language iff there exists a reg. exp. R such that L(R) = L– When I ask for a proof that a language L is

regular, rather than going through the inductive proof we saw earlier, I expect you to give me a regular expression R s.t. L(R) = L

88

Summary *

• Regular expressions are strings– syntax for legal regular expressions– semantics for interpreting regular expressions

• Regular languages are a new language class– A language L is regular iff there exists a regular

expression R s.t. L(R) = L

• We will show that the regular languages are identical to LFSA

89

Module 15

• FSA’s– Defining FSA’s– Computing with FSA’s

• Defining L(M)

– Defining language class LFSA– Comparing LFSA to set of solvable languages

(REC)

90

Finite State Automata

New Computational Model

91

Tape

• We assume that you have already seen FSA’s in CSE 260– If not, review material in reference textbook

• Only data structure is a tape– Input appears on tape followed by a B character

marking the end of the input– Tape is scanned by a tape head that starts at

leftmost cell and always scans to the right

92

Data type/States

• The only data type for an FSA is char

• The instructions in an FSA are referred to as states

• Each instruction can be thought of as a switch statement with several cases based on the char being scanned by the tape head

93

Example program

1 switch(current tape cell) {case a: goto 2case b: goto 2case B: return yes

}2 switch (current tape cell) {

case a: goto 1case b: goto 1case B: return no;

}

94

New model of computation

• FSA M=(Q,,q0,A,)– Q = set of states = {1,2}

– = character set = {a,b}• don’t need B as we see below

– q0 = initial state = 1

– A = set of accepting (final) states = {1}

• A is the set of states where we return yes on B

• Q-A is set of states that return no on B

– = state transition function

1 switch(current tape cell) {case a: goto 2

case b: goto 2

case B: return yes

}

2 switch (current tape cell) {case a: goto 1

case b: goto 1

case B: return no;

}

95

Textual representations of *

1 switch(current tape cell) {case a: goto 2

case b: goto 2

case B: return yes

}


case b: goto 1

case B: return no;

}

1

2

a b

1 1

2 2

(1,a) = 2, (1,b)=2, (2,a)=1, (2,b) = 1

{(1,a,2), (1,b,2), (2,a,1), (2,b,1)}

96

Transition diagrams

1 2

a,b

a,b1 switch(current tape cell) {case a: goto 2

case b: goto 2

case B: return yes

}


case b: goto 1

case B: return no;

}

Note, this transition diagramrepresents all 5 components of an FSA, not just the transition function

97

Exercise *

• FSA M = (Q, , q0, A, )

– Q = {1, 2, 3}– = {a, b}

– q0 = 1

– A = {2,3}– : {(1,a) = 1, (1,b) = 2, (2,a)= 2, (2,b) = 3,

(3,a) = 3, (3,b) = 1}

• Draw this FSA as a transition diagram

98

Transition Diagram

1

2

3

a

a

a

b

b

b

99

Computing with FSA’s

100

Computation Example *

1

2

3

a

a

a

b

b

b

Input: aabbaa

101

Computation of FSA’s in detail

• A computation of an FSA M on an input x is a complete sequence of configurations

• We need to define– Initial configuration of the computation– How to determine the next configuration given

the current configuration– Halting or final configurations of the

computation

102

• Given an FSA M and an input string x, what is the initial configuration of the computation of M on x?– (q0,x)

– Examples• x = aabbaa

• (1, aabbaa)

• x = abab

• (1, abab)

• x = • (1, )

Initial Configuration

1

2

3

a

a

a

b

b

b

FSA M

103

• (1, aabbaa) |-M (1, abbaa)

– config 1 “yields” config 2 in one step using FSA M

• (1,aabbaa) |-M (2, baa)

– config 1 “yields” config 2 in 3 steps using FSA M

• (1, aabbaa) |-M (2, baa)

– config 1 “yields” config 2 in 0 or more steps using FSA M

• Comment:

– |-M determined by transition function

– There must always be one and only one next configuration

• If not, M is not an FSA

Definition of |-M

1

2

3

a

a

a

b

b

b

3

FSA M

*

104

• Halting configuration– (q, )

– Examples• (1, )

• (3, )

• Accepting Configuration– State in halting configuration

is in A

• Rejecting Configuration– State in halting configuration

is not in A

Halting Configurations *

1

2

3

a

a

a

b

b

b

FSA M

105

• Two possibilities for M running on x– M accepts x

• M accepts x iff the computation of M on x ends up in an accepting configuration

• (q0, x) |-M (q, ) where q is in A

– M rejects x• M rejects x iff the computation of M on x ends up in a

rejecting configuration

• (q0, x) |-M (q, ) where q is not in A

– M does not loop or crash on x

FSA M on x *b

bb

aa

a

FSA M

*

*

106

– For the following input strings, does M accept or reject?• • aa• aabba• aab• babbb

Examplesb

bb

aa

a

FSA M

107

• Notation from the book

• (q, c) = p

• k(q, x) = p– k is the length of x

• *(q, x) = p

• Examples– (1, a) = 1

– (1, b) = 2

– 4(1, abbb) = 1

– *(1, abbb) = 1

– (2, baaaaa) = 3

Definition of *(q, x)

1

2

3

a

a

a

b

b

b

FSA M

108

• L(M) or Y(M)– The set of strings M accepts

• Basically the same as Y(P) from previous unit

– We say that M accepts/decides/recognizes/solves L(M)• Remember an FSA will not loop or crash

– What is L(M) (or Y(M)) for the FSA M above?

• N(M)– Rarely used, but it is the set of strings M rejects

• LFSA– L is in LFSA iff there exists an FSA M such that L(M) = L.

L(M) and LFSA *

bb

b

aa

a

FSA M

109

LFSA Unit Overview

• Study limits of LFSA– Understand what languages are in LFSA

• Develop techniques for showing L is in LFSA

– Understand what languages are not in LFSA• Develop techniques for showing L is not in LFSA

• Prove Closure Properties of LFSA• Identify relationship of LFSA to other

language classes

110

Comparing language classes

Showing LFSA is a subset of REC, the set of solvable languages

111

LFSA subset REC

• Proof– Let L be an arbitrary language in LFSA– Let M be an FSA such that L(M) = L

• M exists by definition of L in LFSA

– Construct C++ program P from FSA M– Argue P solves L– There exists a C++ program P which solves L– L is solvable

112

Visualization

LFSAREC

FSA’s C++ Programs

L L

M P

•Let L be an arbitrary language in LFSA•Let M be an FSA such that L(M) = L

•M exists by definition of L in LFSA•Construct C++ program P from FSA M•Argue P solves L•There exists a program P which solves L•L is solvable

113

Construction

• The construction is an algorithm which solves a problem with a program as input– Input to A: FSA M– Output of A: C++ program P such that P solves

L(M)– How do we do this?

Construction Algorithm

FSA M

Program P

114

Comparing computational models

• The previous slides show one method for comparing the relative power of two different computational models– Computational model CM1 is at least as general or

powerful as computational model CM2 if

• Any program P2 from computational model CM2 can be converted into an equivalent program P1 in computational model CM1.

– Question: How can we show two computational models are equivalent?

115

Module 16

• Distinguishability– Definition– Help in designing/debugging FSA’s

116

Distinguishability

117

Questions

• Let L be the set of strings over {a,b} which end with aaba.

• Let M be an FSA such that L(M) = L.

• Questions

– Can aaba and aab end up in the same state of M? Why or why not?

– How about aa and aab?

– How about or a?

– How about b or bb?

– How about or bbab?

118

Definition *

• String x is distinguishable from string y with respect to language L iff there exists a string z such that– xz is in L and yz is not in L OR– xz is not in L and yz is in L

• When reviewing, identify the z for pair of strings on the previous slide

119

Questions

• Let L be the set of strings over {a,b} that have length 2 mod 5 or 4 mod 5.

• Let M be an FSA such that L(M) = L.• Questions

– Are aa and aab distinguishable with respect to L? Can they end up in the same state of M?

– How about aa and aaba?– How about and a?– How about b and aabbaa?

120

• One design method– Is in L?

• Implication?

– Is a distinguishable from wrt L?

• Implication?

– Is b distinguishable from wrt L?

• Implication?

– Is b distinguishable froma wrt L?

• Implication?

• L = set of strings x over {a,b} such that length of x is 2 or 4 mod 5

Design an FSA to accept L

121

• Design continued– Is aa distinguishable

from wrt L?• Implication?

– Is aa distinguishable froma wrt L?

• Implication?



122

• Design continued– What strings would we

compare ab to?

– What results do we get?

– Implications?

– How about ba?

– How about bb?



123

• Design continued– We can continue in this

vein, but it could go on forever

– Now lets try something different

– Consider string .• What set of strings are

indistinguishable from it wrt L?

• Implications?



124

• Design continued– Consider string a.

• What set of strings are indistinguishable from it wrt L?

• Implications?

– Consider string aa.• What set of strings are

indistinguishable from it wrt L?

• Implications?



125

Debugging an FSA

• Do essentially the same thing– Identify some strings which end up in each

state– Try and generalize each state to describe the

language of strings which end up at that state.

126

Example 1

a a a

a,b

b

bb

ba

a,b

I II III IV V

VI

127

Example 2

I II III IV Va a a

a,b

b

b

b

b

a

128

Example 3

III

III

IV

a

b

a

ab

b

a,b

129

Module 17

• Closure Properties of Language class LFSA– Remember ideas used in solvable languages

unit– Set complement– Set intersection, union, difference, symmetric

difference

130

LFSA is closed under set complement

• If L is in LFSA, then Lc is in LFSA• Proof

– Let L be an arbitrary language in LFSA

– Let M be the FSA such that L(M) = L• M exists by definition of L in LFSA

– Construct FSA M’ from M

– Argue L(M’) = Lc

– There exists an FSA M’ such that L(M’) = Lc

– Lc is in LFSA

131

Visualization

•Let L be an arbitrary language in LFSA•Let M be the FSA such that L(M) = L

•M exists by definition of L in LFSA

•Construct FSA M’ from M•Argue L(M’) = Lc

•Lc is in LFSA

LcL

LFSA

FSA’s

MM’

132

Construct FSA M’ from M

• What did we do when we proved that REC, the set of solvable languages, is closed under set complement?

• Construct program P’ from program P• Can we translate this to the FSA setting?

133

Construct FSA M’ from M

• M = (Q, , q0, A, )• M’ = (Q’, ’, q’, A’, ’)

– M’ should say yes when M says no– M’ should say no when M says yes– How?

• Q’ = Q• ’ = • q’ = q0

• ’ = • A’ = Q-A

134

Example

1

2

3

a

a

a

b

b

b

FSA M

1

2

3

a

a

a

b

b

b

FSA M’

Q’ = Q’ = q’ = q0

’ = A’ = Q-A

135

Construction is an algorithm *

• Set Complement Construction– Algorithm Specification

• Input: FSA M

• Output: FSA M’ such that L(M’) = L(M)c

– Comments• This algorithm can be in any computational model.

– It does not have to be (and typically is not) an FSA

• These set closure constructions are useful. – More on this later


FSA M

FSA M’

136

Specification of the algorithm

• Your algorithm must give a complete specification of M’ in terms of M– Example:

• Let input FSA M = (Q, , q0, A, )• Output FSA M’ = (Q’, ’, q’, A’, ’) where

– Q’ = Q– ’ = – q’ = q0

– ’ = – A’ = Q-A

• When I ask for such a construction algorithm specification, this type of answer is what I am looking for. Further algorithmic details on how such an algorithm would work are unnecessary.


FSA M

FSA M’

137

LFSA closed under Set Intersection Operation

(also set union, set difference, and symmetric difference)

138

LFSA closed under set intersection operation *

• Let L1 and L2 be arbitrary languages in LFSA

• Let M1 and M2 be FSA’s s.t. L(M1) = L1, L(M2) = L2

– M1 and M2 exist by definition of L1 and L2 in LFSA

• Construct FSA M3 from FSA’s M1 and M2

• Argue L(M3) = L1 intersect L2

• There exists FSA M3 s.t. L(M3) = L1 intersect L2

• L1 intersect L2 is in LFSA

139

Visualization

•Let L1 and L2 be arbitrary languages in LFSA•Let M1 and M2 be FSA’s s.t. L(M1) = L1, L(M2) = L2

•M1 and M2 exist by definition of L1 and L2 in LFSA

•Construct FSA M3 from FSA’s M1 and M2

•Argue L(M3) = L1 intersect L2

•There exists FSA M3 s.t. L(M3) = L1 intersect L2

•L1 intersect L2 is in LFSA

L1 intersect L2

L1

L2

LFSA

M3

M1

M2

FSA’s

140

Algorithm Specification

• Input– Two FSA’s M1 and M2

• Output– FSA M3 such that L(M3) = L(M1) intersection L(M2)

FSA M1

FSA M2

FSA M3Alg

141

Use Old Ideas

• Key concept: Try ideas from previous closure property proofs

• Example– How did the algorithm that was used to prove that REC is

closed under set intersection work?

– If we adapt this approach, what should M3 do with respect to M1, M2, and the input string?

FSA M1

FSA M2

FSA M3Alg

142

1

Run M1 and M2 Simultaneously

0 20

0

0

0

1

1

1

1

M1

A B0

1 0,1

M2

,A 0,A 1,A 2,A

,B 0,B 1,B 2,B

M3

What happens when M1 and M2 run on input string 11010?

FSA M1

FSA M2

FSA M3Alg

143

Construction *

• Input – FSA M1 = (Q1, , q1, , A1)

– FSA M2 = (Q2, , q2, , A2)

• Output– FSA M3 = (Q3, , q3, , A3)

– What is Q3?

• Q3 = Q1 X Q2 where X is cartesian product

• In this case, Q3 = {(,A), (,B), (0,A), (0,B), (1,A), (1,B), (2,A), (2,B)}

– What is 3?

• 3 = 1 = 2

• In this case, 3 = {0,1}

1 0 20

000

1

11

1

M1

A B0

1 0,1

M2

144

Construction *

• Input – FSA M1 = (Q1, , q1, , A1)

– FSA M2 = (Q2, , q2, , A2)

• Output– FSA M3 = (Q3, , q3, , A3)

– What is q3?

• q3 = (q1, q2)

• In this case, q3 = (,A)

– What is A3?

• A3 = {(p, q) | p in A1 and q in A2}

• In this case, A3 = {(0,B)}

1 0 20

000

1

11

1

M1

A B0

1 0,1

M2

145

Construction

• Input – FSA M1 = (Q1, , q1, , A1)

– FSA M2 = (Q2, , q2, , A2)

• Output– FSA M3 = (Q3, , q3, , A3)

– What is 3?

• For all p in Q1, q in Q2, a in , 3((p,q),a) = (1(p,a),2(q,a))

• In this case,– 3((0,A),0) = (1(0,0),2(A,0))

– = (0,B)

– 3((0,A),1) = (1(0,1),2(A,1))

– = (1,A)

1 0 20

000

1

11

1

M1

A B0

1 0,1

M2

146

Example Summary

1 0 200

01

1

1

M1

A B0

1 0,1

M2

,A 0,A 1,A 2,A

,B 0,B 1,B 2,B

M3

0 1

0

1

0

1

0

1

0

1

0

1 0

1

147

Observation

• Input – FSA M1 = (Q1, , q1, , A1)

– FSA M2 = (Q2, , q2, , A2)

• Output– FSA M3 = (Q3, , q3, , A3)

– What is A3?

• A3 = {(p, q) | p in A1 and q in A2}

• What if operation were different?– Set union, set difference, symmetric difference

148

Observation continued *

• Input – FSA M1 = (Q1, , q1, , A1)

– FSA M2 = (Q2, , q2, , A2)

• Output– FSA M3 = (Q3, , q3, , A3)

– What is A3?

• Set intersection: A3 = {(p, q) | p in A1 and q in A2}

• Set union: A3 = {(p, q) | p in A1 or q in A2}

• Set difference: A3 = {(p, q) | p in A1 and q not in A2}

• Symmetric difference: A3 = {(p, q) | (p in A1 and q not in A2) or (p not in A1 and q in A2) }

149

Observation conclusion

• LFSA is closed under– set intersection

– set union

– set difference

– symmetric difference

• The constructions used to prove these closure properties are essentially identical

150

Comments *• You should be able to execute this algorithm

– Convert two FSA’s into a third FSA with the correct properties.

• You should understand the idea behind this algorithm– The third FSA essentially runs both input FSA’s

simultaneously on any input string

– How we set A3 depending on the specific set operation

• You should understand how this algorithm can be used to simplify design of FSA’s

• You should be able to construct new algorithms for new closure property proofs

151

Comparison *

L1 intersect L2

L1

L2

LFSA

M3

M1

M2

FSA’s

LFSAREC

FSA’s C++ Programs

L L

M P

152

Module 18

• NFA’s– nondeterministic transition functions

• computations are trees, not paths

– L(M) and LNFA

• LFSA subset of LNFA– Comparing computational models

153

Nondeterministic Finite State Automata

NFA’s

154

Change: is a relation

• For an FSA M, (q,a) results in one and only one state for all states q and characters a.– That is, is a function

• For an NFA M, (q,a) can result in a set of states– That is, is now a relation – Next step is not determined (nondeterministic)

155

Example NFA

a a ab

a,b a,b

•Why is this only an NFA and not an FSA? Identify

as many reasons as you can.

156

Computing with NFA’s

• Configurations: same as they are for FSA’s• Computations are different

– Initial configuration is identical– However, there may be several next configurations or

there may be none.• Computation is no longer a “path” but is now a “graph” (often

a tree) rooted at the initial configuration

– Definition of halting, accepting, and rejecting configurations is identical

– Definition of acceptance must be modified

157

Computation Graph (Tree)

a a ab

a,b a,b

Input string aaaaba

(1, aaaaba)

(1, aaaba) (2, aaaba)

(1, aaba) (2, aaba) (3, aaba)

(1, aba) (2, aba) (3, aba) crash

(1, ba) (2, ba) (3, ba)

(1, a) (4, a)

(1, ) (2, ) (5, )

158

Definition of |- unchanged *

a a ab

a,b a,b

Input string aaaaba

(1, aaaaba) |- (1, aaaba)

(1, aaaaba) |- (2, aaaba)

(1, aaaaba) |-3 (1, aba)

(1, aaaaba) |-3 (3, aba)

(1, aaaaba) |-* (2, aba)

(1, aaaaba) |-* (3, aba)

(1, aaaaba) |-* (1, )

(1, aaaaba) |-* (5, )

(1, aaaaba)




(1, ba) (2, ba) (3, ba)

(1, a) (4, a)

(1, ) (2, ) (5, )

159

Acceptance and Rejection *

a a ab

a,b a,b

Input string aaaaba

M accepts string x if one of the configurations reached is an accepting configuration

(q0, x) |-* (f, ),f in A

M rejects string x if all configurations reached are either not halting configurations or are rejecting configurations

(1, aaaaba)




(1, ba) (2, ba) (3, ba)

(1, a) (4, a)

(1, ) (2, ) (5, )

160

Comparison

a a a

a,b

b

b

b

b

a

FSA

a a ab

a,b a,b

NFA

161

Defining L(M) and LNFA

• M accepts string x if one of the configurations reached is an accepting configuration

– (q0, x) |-* (f, ),f in A

• M rejects string x if all configurations reached are either not halting configurations or are rejecting configurations

• L(M) (or Y(M)) – The set of strings accepted by M

• N(M)– The set of strings rejected by M

• LNFA– Language L is in language class

LNFA iff there exists an NFA M such that L(M) = L

162

Comparing language classes

LFSA subset of LNFA

163

LFSA subset LNFA

• Let L be an arbitrary language in LFSA• Let M be the FSA such that L(M) = L

– M exists by definition of L in LFSA

• Construct an NFA M’ such that L(M’) = L• Argue L(M’) = L• There exists an NFA M’ such that L(M’) = L• L is in LNFA

– By definition of L in LNFA

164

Visualization

LFSALNFA

FSA’s NFA’s

L L

M M’

•Let L be an arbitrary language in LFSA•Let M be an FSA such that L(M) = L

•M exists by definition of L in LFSA•Construct NFA M’ from FSA M•Argue L(M’) = L•There exists an NFA M’ such that L(M’) = L•L is in LNFA

165

Construction

• We need to make M into an NFA M’ such that L(M’) = L(M)

• How do we accomplish this?

166

Module 19

• LNFA subset of LFSA– Theorem 4.1 on page 131 of Martin textbook– Compare with set closure proofs

• Main idea– A state in FSA represents a set of states in

original NFA

167

LNFA subset LFSA

• Let L be an arbitrary language in LNFA• Let M be the NFA such that L(M) = L

– M exists by definition of L in LNFA

• Construct an FSA M’ such that L(M’) = L• Argue L(M’) = L• There exists an FSA M’ such that L(M’) = L• L is in LFSA

– By definition of L in LFSA

168

Visualization

LNFALFSA

NFA’s FSA’s

L L

M M’

•Let L be an arbitrary language in LNFA•Let M be an NFA such that L(M) = L

•M exists by definition of L in LNFA•Construct FSA M’ from NFA M•Argue L(M’) = L•There exists an FSA M’ such that L(M’) = L•L is in LFSA

169

Construction Specification

• We need an algorithm which does the following– Input: NFA M– Output: FSA M’ such that L(M’) = L(M)

170

• An NFA can be in several states after processing an input string x

Difficulty *a a ab

a,b a,b

Input string aaaaba

(1, aaaaba)




(1, ba) (2, ba) (3, ba)

(1, a) (4, a)

(1, ) (2, ) (5, )

171

• All strings which end up in the set of states {1,2,3} are indistinguishable with respect to L(M)

Observation *a a ab

a,b a,b

Input string aaaaba

(1, aaaaba)




(1, ba) (2, ba) (3, ba)

(1, a) (4, a)

(1, ) (2, ) (5, )

172

• Given an NFA M = (Q,,q0,,A), the equivalent FSA M’ should have one state for each subset of Q

• Example– In this case there are 5 states in Q

– There are 25 subsets of Q including {} and Q

– The FSA M’ will have 25 states

• What strings end up in state {1,2,3} of M’?– The strings which end up in states 1, 2, and 3 of NFA M.

– In this case, strings which do not contain aaba and end with aa such as aa, aaa, and aaaa.

Ideaa a ab

a,b a,b

Input string aaaaba

173

Idea Illustrateda a ab

a,b a,b

Input string aaaaba

(1,aaaaba) ({1}, aaaaba)

(1, aaaba) (2, aaaba) ({1,2}, aaaba)

(1, aaba) (2, aaba) (3, aaba) ({1,2,3}, aaba)

(1, aba) (2, aba) (3, aba) ({1,2,3}, aba)

(1, ba) (2, ba) (3, ba) ({1,2,3}, ba)

(1, a) (4, a) ({1,4}, a)

({1,2,5}, )(1, ) (2, ) (5, )

174

Construction

• Input NFA M = (Q, , q0, , A)• Output FSA M’ = (Q’, ’, q’, ’, A’)

– What is Q’?• all subsets of Q including Q and {}• In this case, Q’ =

– What is ’?• We always make ’ = • In this case, ’ = = {a,b}

– What is q’?• We always make q’ = {q0}• In this case q’ =

a,b a,b

a aNFA M

1 2 3

175

Construction• Input NFA M = (Q, , q0, , A)• Output FSA M’ = (Q’, ’, q’, ’, A’)

– What is A’?• Suppose a string x ends up in states 1 and 2 of the NFA M above.

– Is x accepted by M?

– Should {1,2} be an accepting state in FSA M’?

• Suppose a string x ends up in states 1 and 2 and 3 of the NFA M above.– Is x accepted by M?

– Should {1,2,3} be an accepting state in FSA M’?

• Suppose p = {q1, q2, …, qk} where q1, q2, …, qk are in Q• p is in A’ iff at least one of the states q1, q2, …, qk is in A• In this case, A’ =

a,b a,b

a aNFA M

1 2 3

176

Construction• Input NFA M = (Q, , q0, , A)

• Output FSA M’ = (Q’, ’, q’, ’, A’)– What is ’?

• If string x ends up in states 1 and 2 after being processed by the NFA above, where does string xa end up after being processed by the NFA above?

• Figuring out ’(p,a) in general– Suppose p = {q1, q2, …, qk} where q1, q2, …, qk are in Q

– Then ’(p,a) = (q1,a) union (q2,a) union … union (qk,a)

» Similar to 2 FSA to 1 FSA construction

– In this case

» ’({1,2},a) =

a,b a,b

a aNFA M

1 2 3

177

Construction Summary

• Input NFA M = (Q, , q0, , A)

• Output FSA M’ = (Q’, ’, q’, ’, A’)– Q’ = all subsets of Q including Q and {}

• In this case, Q’ = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

– ’ = • In this case, ’ = = {a,b}

– q’ ={q0}

• In this case, q’ = {1}

– A’• Suppose p = {q1, q2, …, qk} where q1, q2, …, qk are in Q

• p is in A’ iff at least one of the states q1, q2, …, qk is in A

– ’• Suppose p = {q1, q2, …, qk} where q1, q2, …, qk are in Q

• Then ’(p,a) = (q1,a) union (q2,a) union … union (qk,a)

a,b a,b

a aNFA M

1 2 3

178

Example Summary

a,b a,b

a a

NFA M

1 2 3{1} {1,2} {1,2,3} {1,3}

{} {2} {3} {2,3}

a,b

a,b

a,b

a

aa

a

a b

b

b

b

b

FSA M’

179

Example Summary Continued

a,b a,b

a a

NFA M

1 2 3{1} {1,2} {1,2,3} {1,3}

{} {2} {3} {2,3}

a,b

a,b

a,b

a

aa

a

a b

b

b

b

b

FSA M’

These states cannot be reached from initial state and are unnecessary.

180

Example Summary Continued

a,b a,b

a a

NFA M

1 2 3{1} {1,2} {1,2,3} {1,3}

aa

a

a b

b

b

b

Smaller FSA M’

By examination, we can see that state {1,3} is unnecessary.However, this is a case by case optimization.

It is not a general technique or algorithm.

181

Example 2

a,b

a b

Step 1: name the three states of NFA M

A B C

NFA M

182

Step 2: transition table

a,b

a bA B C

NFA M

{A} {B} {}

a b

{B} {B,C}{B}

{} {} {}

{B,C} {B} {B,C}

’({B,C},a) = (B,a) U (C,a)

= {B} U {}

= {B}

’({B,C},b) = (B,b) U (C,b)

= {B,C} U {}

= {B,C}

183

Step 3: accepting states

a,b

a bA B C

NFA M

{A} {B} {}

a b

{B} {B} {B,C}

{} {} {}

{B,C} {B} {B,C}

Which states should be accepting?

Any state which includes an accepting state of M, in this case, C.

A’ = {{B,C}}

184

Step 4: Answer

a,b

a bA B C

NFA M

Initial state is {A}

Set of final states A’ = {{B,C}}{A} {B} {}

a b

{B} {B} {B,C}

{} {} {}

{B,C} {B} {B,C}

This is sufficient. You do NOT need to turn this into a diagram.

185

Step 5: Optional

a,b

a bA B C

NFA Ma

a b{A} {B} {B,C}

b

a

a,b

{}

b

FSA M’

186

Comments

• You should be able to execute this algorithm – You should be able to convert any NFA into an equivalent FSA.

• You should understand the idea behind this algorithm– For an FSA M’, strings which end up in the same state of M’ are

indistinguishable wrt L(M’)

– For an NFA M, strings which end up in the same set of states of M are indistinguishable wrt L(M)

187

Comments

• You should understand the importance of this algorithm– Design tool

• We can design using NFA’s

• A computer will convert this NFA into an equivalent FSA– FSA’s can be executed by computers whereas NFA’s cannot (or at least

cannot easily be run by computers)

– Chaining together algorithms• Perhaps it is easy to build NFA’s to accept L1 and L2

• Use this algorithm to turn these NFA’s to FSA’s

• Use previous algorithm to build FSA to accept L1 intersect L2

• You should be able to construct new algorithms for new closure property proofs

188

Module 20

• NFA’s with -transitions– NFA-’s

• Formal definition

• Simplifies construction

– LNFA- – Showing LNFA is a subset of LNFA (extra

credit)• and therefore a subset of LFSA

189

Defining NFA-’s

190

Change:-transitions

• We now allow an NFA M to change state without reading input

• That is, we add the following categories of transitions to – (q is allowed

191

Example *

a,b

a

a,b

a b a

b

a,b a,b

a a b

192

Defining L(M) and LNFA-

• M accepts string x if one of the configurations reached is an accepting configuration

– (q0, x) |-* (f, ),f A

• M rejects string x if all configurations reached are either not halting configurations or are rejecting configurations

• L(M) or Y(M)

• N(M)

• LNFA-– Language L is in

language class LNFA- iff

193

LNFA- subset LFSA

• Recap of what we already know– Let M be any NFA

– There exists an algorithm A1 which constructs an FSA M’ such that L(M’) = L(M)

• New goal– Let M be any NFA-– There exists an algorithm A2 which constructs an FSA

M’ such that L(M’) = L(M)

194

Visualization

• Goal– Let M be any NFA-– There exists an algorithm A2 which constructs an FSA

M’ such that L(M’) = L(M)

NFA- M FSA M’A2

195

Modified Goal

• Question– Can we use any existing algorithms to simplify the task

of developing algorithm A2?

• Yes, we can use algorithm A1 which converts an NFA M1 into an FSA M’ such that L(M’) = L(M1)

NFA- M FSA M’A2

NFA- M FSA M’

Algorithm A2

NFA M1

A1A2’

196

New Goal (extra credit)• Difficulty

– NFA- M can make transitions on – How can the NFA M1 simulate these -transitions?

NFA- M NFA M1A2’

a

bb 2 3 4 5 61

197

Basic Idea

• For each state q of M and each character of , figure out which states are reachable from q taking any number of -transitions and exactly one transition on that character .

• In the NFA- M1, directly connect q to each of these states using an arc labeled with .

NFA- M NFA M1A2’

a

bb 2 3 4 5 61

2 3 4 5 61

bb

b

198

Process State 2 NFA- M NFA- M1A2’

a

bb 2 3 4 5 61

2 3 4 5 61

bb

b

b b

b

199

Process State 3 NFA- M NFA- M1A2’

a

bb 2 3 4 5 61

2 3 4 5 61

bb

b

b b

ba

a

b

200

Final Picture NFA- M NFA- M1A2’

a

bb 2 3 4 5 61

2 3 4 5 61

bb

b

b b

ba

a

b

b

b

a

a

201

Construction

• Input NFA- M = (Q, , q0, , A)

• Output NFA M1 = (Q1, 1, q1, 1, A1)

– What is Q1?

• Q1 = Q

• In this case, Q1 = {1,2,3,4,5,6}

– What is 1?

• 1 =

• In this case, 1 = = {a,b}

– What is q1?

• We always make q1 = q0

• In this case q1 = 1

a

bb 2 3 4 5 61

202

Construction

• Input NFA- M = (Q, , q0, , A)

• Output NFA M1 = (Q1, 1, q1, 1, A1)

– What is 1?

• 1(q,a) = the set of states reachable from state q in M taking any number of -transitions and exactly one transition on the character a

– More on this later

• In this case – 1(1,a) = {}

– 1(1,b) = {3,4,5}

– What is A1?

• A1 = A with one minor change

– If an accepting state is reachable from q0 using only-transitions, then we make q1 an element of A1

• In this case, using only -transitions, no accepting state is reachable from q0, so A1 = A

a

bb 2 3 4 5 61

203

Computing 1(q,a)

• 1(q,a) = the set of states reachable from state q in M taking 0 or more -transitions and exactly one transition on the character a– Break this down into three steps

• First compute all states reachable from q using 0 or more -transitions– We call this set of states (q)

• Next, compute all states reachable from any element of (q) using the character a

– We can denote these states as ((q),a)

• Finally, compute all states reachable from states in ((q),a) using 0 or more -transitions

– We denote these states as (((q),a))

– This is the desired answer

a

bb 2 3 4 5 61

204

Example

• 1(1,b) = {3,4,5}– Compute (1), all states reachable from state 1 using 0 or more -

transitions• (1) = {1,2}

– Compute ((q),b), all states reachable from any element (1) of using the character b:

• ((q),b) = ({1,2},b)• = (1,b) U (2,b)• = {} U {3} = {3}

– Compute (((q),a)), all states reachable from states in ((q),a) using 0 or more -transitions

• (((q),a)) = (3)• = {3,4,5}

a

bb 2 3 4 5 61

205

Comments

• For extra credit, you should be able to execute this algorithm – Convert any NFA- into an equivalent NFA.

• For extra credit, you should understand the idea behind this algorithm– Why the transition function is computed the way it is– Why A1 may need to include q1 in some cases

• You should understand the importance of this algorithm– Compiler role again– Use in combination with previous algorithm for converting any

NFA into an equivalent FSA to create a new algorithm for converting any NFA- into an equivalent FSA

206

LNFA- = LFSA

• Implications– Let us primarily use the term LFSA to refer to

this language class– Given a language L is in LFSA

• We know there exists an FSA M s.t. L(M) = L

• We know there exists an NFA M s.t. L(M) = L

– To show a language L is in LFSA• Show there exists an FSA M s.t. L(M) = L

• Show there exists an NFA- M s.t. L(M) = L

207

Module 21

• Closure Properties for LFSA using NFA’s– From now on, when I say NFA, I mean any

NFA including an NFA- unless I add a specific restriction

– union (second proof)– concatenation– Kleene closure

208

LFSA closed under set union(again)

209

LFSA closed under set union


• Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

– M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

• Construct NFA M3 from NFA’s M1 and M2

• Argue L(M3) = L1 union L2

• There exists NFA M3 s.t. L(M3) = L1 union L2

• L1 union L2 is in LFSA

210

Visualization

L1 union L2

L1

L2

LFSA

M3

M1

M2

NFA’s

•Let L1 and L2 be arbitrary languages in LFSA•Let M1 and M2 be NFA’s s.t. L(M1) = L1, L(M2) = L2

•M1 and M2 exist by definition of L1 and L2 in LFSA and the fact that every FSA is an NFA

•Construct NFA M3 from NFA’s M1 and M2

•Argue L(M3) = L1 union L2

•There exists NFA M3 s.t. L(M3) = L1 union L2

•L1 union L2 is in LFSA

211


• Input– Two NFA’s M1 and M2

• Output– NFA M3 such that L(M3) = ?

NFA M1

NFA M2

NFA M3A

212

Use -transitionNFA M1

NFA M2

NFA M3A

a

M1

a,b a,b

a,b

M2

a

a,b a,b

a,b

M3

213

General Case *NFA M1

NFA M2

NFA M3A

M1

M2

M3

214

Construction *

• Input – NFA M1 = (Q1, , q1, , A1)

– NFA M2 = (Q2, , q2, , A2)

• Output– NFA M3 = (Q3, , q3, , A3)

– What is Q3?

• Q3 =

– What is 3?

• 3 = 1 = 2

– What is q3?

• q3 =

NFA M1

NFA M2

NFA M3A

215

Construction

• Input – NFA M1 = (Q1, , q1, , A1)

– NFA M2 = (Q2, , q2, , A2)

• Output– NFA M3 = (Q3, , q3, , A3)

– What is A3?

• A3 =

– What is 3?

• 3 =

NFA M1

NFA M2

NFA M3A

216

Comments

• You should be able to execute this algorithm

• You should understand the idea behind this algorithm

• You should understand how this algorithm can be used to simplify design

• You should be able to design new algorithms for new closure properties

• You should understand how this helps prove result that regular languages and LFSA are identical– In particular, you should understand how this is used to construct an

NFA M from a regular expression r s.t. L(M) = L(r)

– To be seen later

217

LFSA closed under set concatenation

218

LFSA closed under set concatenation





• Argue L(M3) = L1 concatenate L2

• There exists NFA M3 s.t. L(M3) = L1 concatenate L2

• L1 concatenate L2 is in LFSA

219

Visualization

L1 concatenate L2

L1

L2

LFSA

M3

M1

M2

NFA’s





• Argue L(M3) = L1 concatenate L2

• There exists NFA M3 s.t. L(M3) = L1 concatenate L2

• L1 concatenate L2 is in LFSA

220


• Input– Two NFA’s M1 and M2

• Output– NFA M3 such that L(M3) =

NFA M1

NFA M2

NFA M3A

221

Use -transitionNFA M1

NFA M2

NFA M3A

a

M1

a,b a,b

a,b

M2

a

a,b a,b

a,b

M3

222

General CaseNFA M1

NFA M2

NFA M3A

M1

M2

M3

223

Construction

• Input – NFA M1 = (Q1, , q1, , A1)

– NFA M2 = (Q2, , q2, , A2)

• Output– NFA M3 = (Q3, , q3, , A3)

– What is Q3?

• Q3 =

– What is 3?

• 3 = 1 = 2

– What is q3?

• q3 =

NFA M1

NFA M2

NFA M3A

224

Construction

• Input – NFA M1 = (Q1, , q1, , A1)

– NFA M2 = (Q2, , q2, , A2)

• Output– NFA M3 = (Q3, , q3, , A3)

– What is A3?

• A3 =

– What is 3?

• 3 =

NFA M1

NFA M2

NFA M3A

225

Comments

• You should be able to execute this algorithm

• You should understand the idea behind this algorithm



• You should understand how this helps prove result that regular languages and LFSA are identical– In particular, you should understand how this is used to construct an

NFA M from a regular expression r s.t. L(M) = L(r)

– To be seen later

226

LFSA closed under Kleene Closure

227

LFSA closed under Kleene Closure

• Let L be arbitrary language in LFSA

• Let M1 be an NFA s.t. L(M1) = L

– M1 exists by definition of L1 in LFSA and the fact that every FSA is an NFA

• Construct NFA M2 from NFA M1

• Argue L(M2) = L1*

• There exists NFA M2 s.t. L(M2) = L1*

• L1* is in LFSA

228

Visualization

L1*

L1

LFSA

NFA’s

• Let L be arbitrary language in LFSA

• Let M1 be an NFA s.t. L(M1) = L

– M1 exists by definition of L1 in LFSA and the fact that every FSA is an NFA

• Construct NFA M2 from NFA M1

• Argue L(M2) = L1*

• There exists NFA M2 s.t. L(M2) = L1

*

• L1* is in LFSA

M1 M2

229


• Input– NFA M1

• Output– NFA M2 such that L(M2) =

NFA M1 NFA M2A

230

Use -transition NFA M1 NFA M2A

a

M1a

M2

231

General Case * NFA M1 NFA M2A

M1

M3

232

Construction

• Input – NFA M1 = (Q1, , q1, , A1)

• Output– NFA M2 = (Q2, , q2, , A2)

– What is Q2?

– What is 2?

• 2 = 1

– What is q2?

• q2 =

NFA M1 NFA M2A

233

Construction

• Input – NFA M1 = (Q1, , q1, , A1)

• Output– NFA M2 = (Q2, , q2, , A2)

– What is A2?

• A2 =

– What is 2?

• 2 =

NFA M1 NFA M2A

234

Comments

• You should be able to execute this algorithm • You should understand the idea behind this algorithm

– Why do we need to make an extra state p?



• You should understand how this helps prove result that regular languages and LFSA are identical– In particular, you should understand how this is used to construct an NFA

M from a regular expression r s.t. L(M) = L(r)– To be seen later

235

Module 22

• Regular languages are a subset of LFSA– algorithm for converting any regular expression

into an equivalent NFA– Builds on existing algorithms described in

previous lectures

236

Regular languages are a subset of LFSA

237

Reg. Lang. subset LFSA

• Let L be an arbitrary regular language

• Let R be the regular expression such that L(R) = L– R exists by definition of L is regular

• Construct an NFA- M such that L(M) = L– M is constructed from regular expression R

• Argue L(M) = L

• There exists an NFA- M such that L(M) = L

• L is in LFSA– By definition of L in LFSA and equivalence of LFSA and LNFA-

238

Visualization

RegularLanguages LFSA

RegularExpressions

NFA-’s

L L

R M

•Let L be an arbitrary regular language•Let R be the regular expression such that L(R) = L

•R exists by definition of L is regular•Construct an NFA- M such that L(M) = L

•M is constructed from regular expression R

•Argue L(M) = L•There exists an NFA- M such that L(M) = L•L is in LFSA

•By definition of L in LFSA and equivalence of LFSA and LNFA-

239


• Input– Regular expression R

• Output– NFA M such that L(M) =

Regular expression R NFA- MA

240

Recursive Algorithm

• We have an inductive definition for regular languages and regular expressions

• Our algorithm for converting any regular expression into an equivalent NFA is recursive in nature– Base Case– Recursive or inductive Case

241

Base Case

• Regular expression R has zero operators– No concatenation, union, Kleene closure– For any alphabet , only || + 2 regular

languages can be depicted by any regular expression with zero operators

• The empty language • The language {}

• The || languages consisting of one string {a} for all a in

242

Table lookup• Finite number of base cases means we can

use table lookup to handle them

a

b

243

Recursive Case

• Regular expression R has at least one operator– This means R is built up from smaller regular

expressions using the union, Kleene closure, or concatenation operators

– More specifically, there are 3 cases:• R = R1+R2

• R = R1R2

• R = R1*

244

Recursive Calls

• The algorithm recursively calls itself to generate NFA’s M1 and M2 which accept L(R1) and L(R2)

• The algorithm applies the appropriate construction– union

– concatenation

– Kleene closure

to NFA’s M1 and M2 to produce an NFA M such that L(M) = L(R)

1) R = R1 + R2

2) R = R1 R2

3) R = R1*

245

Pseudocode Algorithm_____________ RegExptoNFA(_____________) {

regular expression R1, R2;

NFA M1, M2;

Modify R by removing unnecessary enclosing parentheses/* Base Case */

If R = a, return (NFA for {a}) /* include here */If R = , return (NFA for {})

/* Recursive Case */Find “last operator O” of regular expression R

Identify regular expressions R1 (and R2 if necessary)

M1 = RegExptoNFA(R1)

M2 = RegExptoNFA(R2) /* if necessary */return (OP(M1, M2)) /* OP is chosen based on O */

}

246

Example

A: R = (b+a)a*

Last operator is concatenationR1 = (b+a)R2 = a*Recursive call with R1 = (b+a)

B: R = (b+a)Extra parentheses stripped awayLast operator is unionR1 = bR2 = aRecursive call with R1 = b

247

Example Continued

C: R = bBase caseNFA for {b} returned

B: return to this invocation of procedureRecursive call where R = R2 = a

D: R = aBase caseNFA for {a} returned

B: return to this invocation of procedurereturn UNION(NFA for {b}, NFA for {a})

A: return to this invocation of procedureRecursive call where R = R2 = a*

248

Example Finished

E: R = a*Last operator is Kleene closureR1 = aRecursive call where R = R1 = a

F: R = aBase caseNFA for {a} returned

E: return to this invocation of procedurereturn (KLEENE(NFA for {a}))

A: return to this invocation of procedure return CONCAT(NFA for {b,a}, NFA for {a}*)

249

concatenate

Pictoral View

(b|a)a*

(b|a) a*union

b ab a

b

a

Kleene Closure

aa

a

a

b

a

250

Parse TreeWe now present the “parse” tree for regular expression (b+a)a*

concatenate

union Kleene closure

b a a

251

Module 23

• Regular languages review– Several ways to define regular languages– Two main types of proofs/algorithms

• Relative power of two computational models proofs/constructions

• Closure property proofs/constructions

– Language class hierarchy

• Applications of regular languages

252

Defining regular languages

253

Three definitions

• LFSA– A language L is in LFSA iff there exists an FSA M s.t. L(M) = L

• LNFA– A language L is in LNFA iff there exists an NFA M s.t. L(M) = L

• Regular languages– A language L is regular iff there exists a regular expression R s.t.

L(R) = L

• Conclusion– All these language classes are equivalent

– Any language which can be represented using any one of these models can be represented using either of the other two models

254

Two types of proofs/constructions

255

Relative power proofs

• These proofs work between two language classes and two computational models

• The crux of these proofs are algorithms which behave as follows:– Input: One program from the first computational model

– Output: A program from the second computational model that is equivalent in function to the first program

256

Closure property proofs

• These proofs work within a single language class and typically within a single computational model

• The crux of these proofs are algorithms which behave as follows:– Input: 1 or 2 programs from a given computational

model

– Output: A third program from the same computational model that accepts/describes a third language which is a combination of the languages accepted/described by the two input programs

257

Comparison

L1 intersect L2

L1

L2

LFSA

M3

M1

M2

FSA’s

LNFALFSA

NFA’s FSA’s

L L

M M’

258

Language class hierarchy

All languages over alphabet

RE

RECregular

HH

?

259

Three remaining topics

• Myhill-Nerode Theorem– Provides technique for proving a language is not regular

– Also represents fundamental understanding of what a regular language is

• Decision problems about regular languages– Most are solvable in contrast to problems about recursive

languages

• Pumping lemma– Provides technique for proving a language is not regular

260

Module 24

• Myhill-Nerode Theorem– distinguishability– equivalence classes of strings– designing FSA’s– proving a language L is not regular

261

Distinguishability

262

Distinguishable and Indistinguishable

• String x is distinguishable from string y with respect to language L iff – there exists a string z such that

• xz is in L and yz is not in L OR

• xz is not in L and yz is in L

• String x is indistinguishable from string y with respect to language L iff – for all strings z,

• xz and yz are both in L OR

• xz and yz are both not in L

263

Example

• Let EVEN-ODD be the set of strings over {a,b} with an even number of a’s and an odd number of b’s– Is the string aa distinguishable from the string

bb with respect to EVEN-ODD?– Is the string aa distinguishable from the string

ab with respect to EVEN-ODD?

264

Equivalence classes of strings

265

Definition of equivalence classes

• Every language L partitions * into equivalence classes via indistinguishability– Two strings x and y belong to the same equivalence

class defined by L iff x and y are indistinguishable w.r.t L

– Two strings x and y belong to different equivalence classes defined by L iff x and y are distinguishable w.r.t. L

266

ExampleHow does EVEN-ODD partition {a,b}* into equivalence classes?

Strings with anEVEN number of a’s

and anEVEN number of b’s

Strings with anEVEN number of a’s

and anODD number of b’s

Strings with anODD number of a’s

and anEVEN number of b’s

Strings with anODD number of a’s

and anODD number of b’s

267

Second ExampleLet 1MOD3 be the set of strings over {a,b} whose length mod 3 = 1.How does 1MOD3 partition {a,b}* into equivalence classes?

Length mod 3 = 0

Length mod 3 = 1

Length mod 3 = 2

268

Designing FSA’s

269

Designing an FSA for EVEN-ODD

EvenEven

EvenOdd

OddOdd

OddEven

b ab

aa

b b

a

270

Designing an FSA for 1MOD3

Length mod 3 = 0

Length mod 3 = 1

Length mod 3 = 2

a aaa,b a,b

a,b

271

Proving a language is not regular

272

Third Example• Let EQUAL be the set of strings x over {a,b} s.t.

the number of a’s in x = the number of b’s in x• How does EQUAL partition {a,b}* into

equivalence classes?• How many equivalence classes are there?• Can we construct a finite state automaton for

EQUAL?

273

Myhill-Nerode Theorem

274

Theorem Statement

• Two part statement– If L is regular, then L partitions * into a finite

number of equivalence classes– If L partitions * into a finite number of

equivalence classes, then L is regular

• One part statement– L is regular iff L partitions * into a finite

number of equivalence classes

275

Implication 1

• Method for constructing FSA’s to accept a language L– Identify equivalence classes defined by L– Make a state for each equivalence class– Identify initial and accepting states– Add transitions between the states

• You can use a canonical element of each equivalence class to help with building the transition function

276

Implication 2

• Method for proving a language L is not regular– Identify equivalence classes defined by L– Show there are an infinite number of such

equivalence classes• Table format may help, but it is only a way to help

illustrate that there are an infinite number of equivalence classes defined by L

277

Proving a language is not regular revisited

278

Proving EQUAL is not regular

• Let EQUAL be the set of strings x over {a,b} s.t. the number of a’s in x = the number of b’s in x

• We want to show that EQUAL partitions {a,b}* into an infinite number of equivalence classes

• We will use a table that is somewhat reminiscent of the table used for diagonalization– Again, you must be able to identify the infinite number

of equivalence classes being defined by the table. They ultimately represent the proof that EQUAL or whatever language you are working with is not regular.

279

Table *

aaa

aaaaaaa

aaaaa...

bINOUTOUTOUTOUT...

bbOUTINOUTOUTOUT...

bbbOUTOUT1

INOUTOUT...

bbbbOUTOUTOUTINOUT...

bbbbbOUTOUTOUTOUTIN...

………………

The strings being distinguished are the rows.The tables entries indicate that the concatenation of the row

string with the column string is in or not in EQUAL.Each complete column shows one row string is distinguishable

from all the other row strings.

280

Concluding EQUAL is nonregular *

• We have shown that EQUAL partitions {a,b}* into an infinite number of equivalence classes– In this case, we only identified some of the

equivalence classes defined by EQUAL, but that is sufficient

• Thus, the Myhill-Nerode Theorem implies that EQUAL is nonregular

281

Summary

• Myhill-Nerode Theorem and what it says– It does not say a language L is regular iff L is finite

• Many regular languages such as * are not finite

– It says that a language L is regular iff L partitions * into a finite number of equivalence classes

• Provides method for designing FSA’s• Provides method for proving a language L is not

regular– Show that L partitions * into an infinite number of

equivalence classes

282

Two/Three Types of Problems

• Create a table that helps prove that a specific language L is not regular– You get to choose the “row” and “column”

strings– I choose the “row” strings

• Identify the equivalence classes defined by L as highlighted by a given table

283

Module 25

• Decision problems about regular languages– Basic problems are solvable

• halting, accepting, and emptiness problems

– Solvability of other problems• answer-preserving input transformations to basic

problems

284

Programs

• In this unit, our programs are the following three types of objects– FSA’s– NFA’s– regular expressions

• Previously, they were C++ programs– Review those topics after mastering today’s

examples

285

Basic Decision Problems(and algorithms for solving them)

286

Halting Problem

• Input– FSA M

– Input string x to M

• Question– Does M halt on x?

• Give an algorithm for solving the FSA halting problem.

287

Accepting Problem

• Input– FSA M

– Input string x to M

• Question– Is x in L(M)?

• Give an algorithm ACCEPT for solving the accepting problem.

288

Empty Language Problem

• Input– FSA M

• Question– Is L(M)={}?

• Give an algorithm for solving the empty language problem.– Don’t look ahead to the next slide.

289

Algorithms for solving empty language problem

• Algorithm 1– View FSA M as a directed graph (nodes, arcs)

– See if any accepting node is reachable from the start node

• Algorithm 2– Let n be the number of states in FSA M

– Run ACCEPT(M,x) for all input strings of length < n

– If any are accepted THEN no ELSE yes• Why is algorithm 2 correct?

290

Solving Other Problems(using answer-preserving input

transformations)

291

Complement Empty Problem

• Input– FSA M

• Question– Is (L(M))c = {}?

• Show how to use an answer-preserving input transformation to help solve this problem– Show that the Complement Empty problem transforms

to the Empty Language problem

– Don’t look at next two slides

292

Algorithm Description

• Convert input FSA M into an FSA M’ such that L(M’) = (L(M))c

– We do this by applying the algorithm which we used to show that LFSA is closed under complement

• Feed FSA M’ into algorithm which solves the empty language problem

• If that algorithm returns yes THEN yes ELSE no

293

Input Transformation Illustrated

Algorithm forsolving empty

language problemFSA M Complement

Construction

FSA M’Yes/No

Algorithm for complement empty problem

The complement construction algorithm is the answer-pres. input transformation.If M is a yes input instance of CE, then M’ is a yes input instance of EL.If M is a no input instance of CE, then M’ is a no input instance of EL.

294

NFA Empty Problem

• Input– NFA M

• Question– Is L(M)={}?

• Show how to use answer-preserving input transformations to help solve this problem– Show that the NFA Empty problem transforms to the

Empty Language problem

295

Input Transformation

Yes/No

Algorithm for NFA empty problem

296

Equal Problem

• Input– FSA’s M1 and M2

• Question– Is L(M1) = L(M2)?

• Show how to use answer-preserving input transformations to solve this problem– Try and transform this problem to the empty language problem– If L(M1) = L(M2), then what combination of L(M1) and L(M2) must be

empty?

297

Input Transformation Illustrated

Yes/No

Algorithm for Equal problem

298

Summary

• Decision problems with programs as inputs

• Basic problems– You need to develop algorithms from scratch

based on properties of FSA’s

• Solving new problems– You need to figure out how to combine the

various algorithms we have seen in this unit to solve the given problem

299

Module 26

• Pumping Lemma– A technique for proving a language L is NOT

regular– What does the Pumping Lemma mean?– Proof of Pumping Lemma

300

Pumping Lemma

How do we use it?

301

Pumping Condition

• A language L satisfies the pumping condition if: – there exists an integer n > 0 such that– for all strings x in L of length at least n– there exist strings u, v, w such that

• x = uvw and

• |uv| <= n and

• |v| >= 1 and

• For all k >= 0, uvkw is in L

302

Pumping Lemma

• All regular languages satisfy the pumping condition

All languages over {a,b}

Regular languages

“Pumping Languages”

303

Implications

• We can use the pumping lemma to prove a language L is not regular– How?

• We cannot use the pumping lemma to prove a language is regular– How might we try to use the pumping lemma to

prove that a language L is regular and why does it fail?

Regular

Pumping

304

Pumping Lemma

What does it mean?

305

Pumping Condition

• A language L satisfies the pumping condition if: – there exists an integer n > 0 such that

– for all strings x in L of length at least n

– there exist strings u, v, w such that• x = uvw and

• |uv| <= n and

• |v| >= 1 and


306

v can be pumped

• Let x = abcdefg be in L• Then there exists a substring v in x such that v can be repeated

(pumped) in place any number of times and the resulting string is still in L– uvkw is in L for all k >= 0

• For example– v = cde

• uv0w = uw = abfg is in L• uv1w = uvw = abcdefg is in L• uv2w = uvvw = abcdecdefg is in L• uv3w = uvvvw = abcdecdecdefg is in L • …

1) x in L2) x = uvw3) For all k >= 0, uvkw is in L

307

What the other parts mean• A language L satisfies the pumping condition if:

– there exists an integer n > 0 such that• defer what n is till later

– for all strings x in L of length at least n• x must be in L and have sufficient length


• |uv| <= n and– v occurs in the first n characters of x

• |v| >= 1 and– v is not


308

Examples

• Example 1– Let L be the set of even length strings over

{a,b}– Let x = abaa– Let n = 2– What are the possibilities for v?

• abaa, abaa• abaa

– Which one satisfies the pumping lemma?

309

Examples *

• Example 2– Let L be the set of strings over {a,b} where the number

of a’s mod 3 is 1– Let x = abbaaa– Let n = 3– What are the possibilities for v?

• abbaaa, abbaaa, abbaaa• abbaaa, abbaaa• abbaaa

– Which ones satisfy the pumping lemma?

310

Pumping Lemma

Proof

311

High Level Outline

• Let L be an arbitrary regular language

• Let M be an FSA such that L(M) = L– M exists by definition of LFSA and the fact that

regular languages and LFSA are identical

• Show that L satisfies the pumping condition– Use M in this part

• Pumping Lemma follows

312

First step: n+1 prefixes of x

• Let n be the number of states in M

• Let x be an arbitrary string in L of length at least n– Let xi denote the ith character of string x

• There are at least n+1 distinct prefixes of x– length 0: – length 1: x1

– length 2: x1x2

– ...

– length i: x1x2 … xi

– ...

– length n: x1x2 … xi … xn

313

Example

• Let n = 8

• Let x = abcdefgh

• There are 9 distinct prefixes of x– length 0: – length 1: a

– length 2: ab

– ...

– length 8: abcdefgh

314

Second step: Pigeon-hole Principle

• As M processes string x, it processes each prefix of x– In particular, each prefix of x must end up in some state of M

• Situation– There are n+1 distinct prefixes of x

– There are only n states in M

• Conclusion– At least two prefixes of x must end up in the same state of M

• Pigeon-hole principle

– Name these two prefixes p1 and p2

315

Third step: Forming u, v, w

• Setting:– Prefix p1 has length i

– Prefix p2 has length j > i

• prefix p1 of length i: x1x2 … xi

• prefix p2 of length j: x1x2 … xi xi+1 … xj

• Forming u, v, w– Set u = p1 = x1x2 … xi

– Set v = xi+1… xj

– Set w = xj+1 … x|x|

– x1x2 … xi xi+1… xj xj+1 … x|x|

u v w

316

Example 1

• Let M be a 5-state FSA that accepts all strings over {a,b,c,…,z} whose length mod 5 = 3

• Consider x = abcdefghijklmnopqr, a string in L

• What are the two prefixes p1 and p2?

• What are u, v, w?

0 1 2 3 4

317

Example 2

• Let M be a 3-state FSA that accepts all strings over {0,1} whose binary value mod 3 = 1

• Consider x = 10011, a string in L

• What are the two prefixes p1 and p2?

• What are u, v, w?

0 1 21

00

1

318

Fourth step: Showing u, v, w satisfy all the conditions

• |uv| <= n– uv = p2

– p2 is one of the first n+1 prefixes of string x

• |v| >= 1– v consists of the characters in p2 after p1

– Since p2 and p1 are distinct prefixes of x, v is not

• For all k >= 0, uvkw in L – u=p1 and uv=p2 end up in the same state q of M

• This is how we defined p1 and p2

– Thus for all k >= 0, uvk ends up in state q– The string w causes M to go from state q to an accepting state

319

Example 1 again

• Let M be a 5-state FSA that accepts all strings over {a,b,c,…,z} whose length mod 5 = 3

• Consider x = abcdefghijklmnopqr, a string in L

• What are u, v, w?– u = – v = abcde

– w = fghijklmnopqr

• |uv| = 5 <= 5

• |v| = 5 >= 1

• For all t>=0, (abcde)tfghijklmnopqr is in L

0 1 2 3 4

320

Example 2 again

• Let M be a 3-state FSA that accepts all strings over {0,1} whose binary interpretation mod 3 = 1

• Consider x = 10011, a string in L

• What are u, v, w?– u = 1

– v = 00

– w = 11

• |uv| = 3 <= 3

• |v| = 2 >= 1

• For all k>=0, 1(00)k11 is in L

0 1 21

00

1

321

Pumping Lemma

• A language L satisfies the pumping condition if: – there exists an integer n > 0 such that



• |uv| <= n and

• |v| >= 1 and


• Pumping Lemma: All regular languages satisfy the pumping condition

322

Module 27

• Applications of Pumping Lemma– General proof template

• What is the same in every proof

• What changes in every proof

– Incorrect pumping lemma proofs– Some rules of thumb

323

Pumping Lemma

Applying it to prove a specific language L is not regular

324

How we use the Pumping Lemma

• We choose a specific language L– For example, {ajbj | j > 0}

• We show that L does not satisfy the pumping condition

• We conclude that L is not regular

325

Showing L “does not pump”

• A language L satisfies the

pumping condition if: – there exists an integer n > 0

such that


– there exist strings u, v, w such that

• x = uvw and

• |uv| <= n and

• |v| >= 1 and


• A language L does not satisfy

the pumping condition if: – for all integers n of sufficient

size

– there exists a string x in L of length at least n such that

– for all strings u, v, w such that• x = uvw and

• |uv| <= n and

• |v| >= 1

– There exists a k >= 0 such that uvkw is not in L

326

Example Proof


the pumping condition if: – for all integers n of sufficient

size



• |uv| <= n and

• |v| >= 1


• Proof that L = {aibi | i>0} does not satisfy the pumping condition

• Let n be the integer from the pumping lemma

• Choose x = anbn

• Consider all strings u, v, w s.t.• x = uvw and• |uv| <= n and• |v| >= 1

• Argue that uvkw is not in L for some k >= 0

– Argument must apply to all possible u,v,w

– Continued on next slide

327

Example Proof Continued



• Choose x = anbn




– Continued on right

• uv0w = uw is not in L– uv contains only a’s

• why?

– uw = an-|v|bn

• Follows from previous line and uvw = x = anbn

– uw contains fewer a’s than b’s• why?

– Therefore, uw is not in L

• Therefore L does not satisfy the pumping condition

328

Alternate choice of k



• Choose x = anbn




– Continued on right

• uv2w = uvvw is not in L– uv contains only a’s

• why?

– uvvw = an+|v|bn

• follows from previous line and uvw = x = anbn

– uvvw contains more a’s than b’s

• why?

– Therefore, uvvw is not in L

• Therefore L does not satisfy the pumping condition

329

Pumping Lemma

Some bad applications of the pumping lemma

330

Bad Pumping Lemma Applications

• We now look at some examples of bad applications of the pumping lemma

• We work with the language EQUAL consisting of the set of strings over {a,b} such that the number of a’s equals the number of b’s

• We focus first on bad choices of string x

• We then consider another flawed technique

331

First bad choice of x


the pumping condition if: – Let n be the integer from the

pumping lemma



• |uv| <= n and

• |v| >= 1



• Choose x = a10b10

– What is wrong with this choice of x?

332

Second bad choice of x



pumping lemma



• |uv| <= n and

• |v| >= 1



• Choose x = anb2n


333

Third bad choice of x



pumping lemma



• |uv| <= n and

• |v| >= 1



• Choose x = (ab)n


• The problem is there is a choice of u, v, w satisfying the three conditions such that for all k >=0, uvkw is in L

• What is an example of such a u, v, w?

334

Find the flaw in this proof



pumping lemma



• |uv| <= n and

• |v| >= 1



• Choose x = anbn

• Let u = a2, v =a, w = an-3bn

– |uv| = 3 <= n

– |v| = 1

• Choose k = 2

• Argue uv2w is not in EQUAL– uv2w = uvvw = a2aaan-3bn = an+1bn

– There is one more a than b in uv2w

– Thus uv2w is not in L

335

Pumping Lemma

Two rules of thumb

336

Two Rules of Thumb *

• Try to make the first n characters of x identical– For EQUAL, choose x = anbn rather than (ab)n

• Simplifies case analysis as v only contains a’s

• Try k=0 or k=2– k=0

• This reduces number of occurrences of that first character

– k=2• This increases number of occurrences of that first character

337

Summary

• We use the Pumping Lemma to prove a language is not regular– Note, does not work for all nonregular

languages, though

• Choosing a good string x is first key step

• Choosing a good integer k is second key step

• Must apply argument to all legal u, v, w

Module 11

Documents

lyesno input

houtputan input

legal input

worksphplptyes input

input transformations

program pl

program ph

halting problem h