LászlóKabódi Languagesandautomata

Languages and automata

László Kabódi

László Kabódi

Example

I L={w|w is a code for a Turing machine and M_w halts in all inputs in at most 100 steps}. Show thatL∈coRE

Solution

I L∈coRE ⇔L∈RE

I L={w|w is not a code for a Turing machine or there is at least one input whereMw does not halt in at most 100 steps{. I An M Turing machine forL:

I rstM checks ifw is a code for a Turing machine: if not, stop and accept

I otherwise runM_w with all inputs for 101 steps

I if it accepts one before that, continue to the next word I if it would run for more steps, stop and acceptw

László Kabódi

Language properties

I AT language property is non-trivial is there are L₁,L₂∈RE languages whereL₁ has T andL₂ does not haveT

I We can useT for all languages that have the T property, then T is non-trivial if

I T∩RE6=∅ I T∩RE6=RE

I Let L_T ={w |wis a code for a TM,L(Mw) has T}

Some properties

I L_T =L_T∩L⁰ where L⁰ ={w|w is a code for a Turing machine }

I L_T contains all words that are not codes for Turing machines, or they accept languages that does not haveT

I LT ∈R ⇔L_T ∈R

I IfL_T ∈R, its complemet is also recursive I L⁰ is recursive

László Kabódi

Rice's theorem

I If T is a non-trivial language property thenL_T ∈/ R I we can use this to show that languages in the form of

LT ={w|w is a code for a Turing machine andL(Mw) hasT} are not recursive

I for this, we have to show one language that has T and recursively enumerable and another that does not have T and recursively enumerable

I or in other words L₁,L₂ ∈RE where L₁ ⊆T andL₂ 6⊂T

Proof of Rice's theorem

I Theorem: ifT is a non-trivial language property thenL_T ∈/ R I Let ∅∈/ T (otherwise we can prove forT)

I Let L∈RE be a language that has T as a property, and its Turing machine M

I Indirect proof: suppose L_T ∈R, so there exist anM_T Turing machine that stops on all inputs and L(M_T) =L_T

I We will create an M⁰ Turing machine that stops on all inputs andL(M⁰) =L_u, which is a contradiction becauseL_u∈RE\R

László Kabódi

Proof of Rice's theorem - the M

Turing machine

I rst it check the input: if it is not in w#s form, orw is not a code for a Turing machine, stops and rejects

I otherwise it constructs a w⁰⁰ code for anM⁰⁰ Turing machine:

I rst it runsMw(s): if it stops, and rejects,M⁰⁰stops and rejectsx (its input)

I ifMw(s)never stops, thenM⁰⁰ will never stop onx I ifM_w(s)stops and accepts, then it runsM(x)

I ifM(x)stops and accepts, thenM⁰⁰will stop and accept I ifM(x)stops and rejects, thenM⁰⁰will stop and reject I ifM(x)never stops, thenM⁰⁰will never stop

I thenM⁰ runs M_T(w⁰⁰), which stops on all inputs, and accepts the input only if it is in Lu

Proof of Rice's theorem - why M

has T only if w #s is in L

I If w#s ∈/Lu, thenw is not a code of a Turing machine, or s ∈/ L(M_w). In this case M⁰⁰ either stops and rejects every input, or never stops, soL(M⁰⁰) =∅

I If w#s ∈Lu, thens ∈L(Mw). In this case M⁰⁰ will run its input with M, soL(M⁰⁰) =L(M) =L. And L has the T property.

I So if we run M_T(w⁰⁰), it will stop, and either reject or accept the input.

I If it rejects, it is becauseL(M⁰⁰) =∅. In this casew#s∈/Lu. I If it accepts, thenL(M⁰⁰)has theT property, soL(M⁰⁰) =L.

This is becausew#s∈Lu.

I So M⁰ is a Turing machine that stops on all inputs and accepts L_u, which is a contradiction.

László Kabódi

Example

ShowL₁,L₂ ∈RE that one hasT and the other does not have it.

I T₁: the language is not empty

LT₁ ={w |w is a code for a TM and L(Mw)6=∅ } I T₂: the language has at least 100 elements

LT₂ ={w |w is a code for a TM and |L(M_w)| ≥100} I T₃: the language is regular

LT₃ ={w |w is a code for a TM and L(Mw) is regular}

Solution

I T₁: the language is not empty

LT₁ ={w |w is a code for a TM and L(Mw)6=∅ } L₁ =∅,L₂ = Σ^∗

I T₂: the language has at least 100 elements

L_T2 ={w |w is a code for a TM and |L(M_w)| ≥100} L₁ =∅,L₂ = Σ^∗

I T₃: the language is regular

LT₃ ={w |w is a code for a TM and L(Mw) is regular} L₁ =∅,L₂ =aⁿbⁿ

László Kabódi

Example

I IsL={w|w is a code for a Turing machine and

|L(M_w)|=5} ∈R?

I IsL={w|w is a code for a Turing machine and L(Mw) =Lu} ∈R?

Solution

I IsL={w|w is a code for a Turing machine and

|L(M_w)|=5} ∈R?

No, because of Rice's theorem. L₁=∅,L₂={0,1,00,01,10}. I IsL={w|w is a code for a Turing machine and

L(M_w) =L_u} ∈R?

No, because of Rice's theorem. L₁=∅,L₂=Lu.

László Kabódi

Example

LetL={w|w is a code for a TM andL(M_w) contains only even length words}

I IsL∈R? I IsL∈coRE? I IsL∈RE?

Solution I

L={w|w is a code for a TM and L(M_w)contains only even length words}

I L∈/ R, because of Rice's theorem. L₁ ={0,01,000}, L₂ ={00,0011}

I L∈coRE. We have to show thatL∈RE.

L={w|w is not a code for a Turing machine orL(Mw) contains at least one odd length word}.

László Kabódi

Solution II

I A Turing machine for L:

I rst it checks isw is a code for a Turing machine and if it is not, stops and accepts

I otherwise it checks all odd length words using the diagonal method

I if there is a word it accepts, then stop and accept I otherwise it runs forever

I L∈/ RE, because L∈/R, butRE ∩coRE =R.

Post correspondence problem

I Introduced by (and named after) Emil Post

I Given a set of word pairs, is there an order in which the concatenation of the rst words in each pair and the second words of each pair gives the same word?

I Given{(s_i,t_i)|s_i,t_i ∈Σ^∗,i =1,2, . . . ,k}is there an i₁,i₂, . . . ,i_n not empty index list (there can be repetitions) where si₁si₂. . .sin =ti₁ti₂. . .tin?

László Kabódi

Example

Is there a solution for the following PCP sets?

I {(ab,aba),(ab,ba),(aba,ba)} I {(1,111),(10111,10),(10,0)} I {(ab,a),(ab,ba),(b,ba)}

Solution

I {(ab,aba),(ab,ba),(aba,ba)} Index list: 1, 3

s₁s₃ =ab aba t₁t₃ =aba ba I {(1,111),(10111,10),(10,0)}

Index list: 2, 1, 1, 3

s₂s₁s₁s₃ =10111 1 1 10 t₂t₁t₁t₃ =10 111 111 0 I {(ab,a),(ab,ba),(b,ba)}

There is no solution, because the all rst words end with b and the second words end with a.

László Kabódi

The PCP language

I PCP ={the set of{(s_i,t_i),i =1,2, . . . ,k} word pairs where there is a good index list}

I PCP ∈RE \R

I Turing machine forPCP that does not stop on all inputs:

I check is the input consists of word pairs, if not stop and reject I otherwise it tries all the 1 element index lists then 2 element

index lists and so on

I if there is a good index list, stop and accept I if there is not, run forever

Example

I Is it recursive, if we know for a PCP problem that|s_i|=|t_i|for all i?

I Is it recursive, if we also get an m integer that is the max length of the index list that can be good for the PCP problem?

László Kabódi

Solution

I Is it recursive, if we know for a PCP problem that|s_i|=|t_i|for all i?

Yes, only have to check if there a pair that is the same.

(si =ti)

I Is it recursive, if we also get an m integer that is the max length of the index list that can be good for the PCP problem?

Yes, only have to check a nite number of index lists (2·n^m) to see if there is a solution, because we know that there is no longer solution.