Abstract

Practice running and constructing PDAs.

1 Automat

1. Review the Pushdown Automata section of the Automat help pages.

    
   

2. Here is the PDA for $0^n1^n$.

   Try running it on these inputs:

   • 0
   • 1
   • 01
   • 10
   • 0011
   • 000111
   • 00110
    
   

3. Here is the PDA for $ww^R$.

   Try running it on these inputs:

   • 0
   • 1
   • 00
   • 0101
   • 0110
   • 10101
   • 011001
   • 111111
   • 01100110

   Take particular note of how some states can be active with many different stack contents. This is a new consequence of the nondeterminism in these automata.

4. A palindrome is a string that reads the same backwards as forwards. All strings in our $ww^R$ language are palindromes. But “1001001” is also a palindrome, and is not in $ww^R$.

   Can you modify the $ww^R$ PDA so that it recognizes all palindromes over $\{0, 1\}^*$? (This is a good way to see if you have really embraced thinking about non-determinism.)

   Try it before looking at the answer.

   We just need to allow the “middle” symbol to be consumed without either pushing it onto the stack nor matching against a symbol already on the stack. Of course, we don’t know which input symbol is the middle one, so we pretend that all of them could be. Non-determinism for the win!

   Here is a PDA for palindromes.

   It only differs from the $ww^R$ n the addition of extra labels to the transition from $q_0$ to $q_1$. Now, in additional to making that transition immediately (input $\epsilon$) without affecting the stack, we now allow an additional, “simultaneous” transition in which the current input character is simply discarded without putting it onto the stack.

   Try running it on the same inputs you used for $ww^R$.

2.1 A PDA can do anything a FA can.

I introduced PDAs by suggesting that they paired an NFA “controller” with a stack.

Because the controller is an NFA, it can recognize regular languages without even using the stack.

 

1. Here is the NFA we used, weeks ago, to recognize the set of all strings over ${0, 1}$ that contain 101.

   • You might try running this on inputs 00100 and 001011 to refresh your memory of how it works.

   With that as a guide, can you create a PDA to recognize the same language?

   Reveal

   Because the controller of a PDA is an NFA, we can pretty much just copy this to a PDA, state by state, transition, by transition, simply ignoring the stack.

   An NFA transition on $x$ becomes a PDA transition $x,\epsilon/\epsilon$. The two “$\epsilon$”s indicate that we are neither popping from the stack nor pushing onto it.

    

   

   Here is the PDA.

   • Try running this on 00100 and 001011.

In general, any regular language can be recognized by a PDA constructed this way.

1. Consider the language of strings over ${0, 1}$ that contain exactly three non-overlapping occurrences of 101.

    
   

   This is something that we can do with an FA.

   • Try running this on 10101011101 and 10101011101101 to see how it works.
     • The top “row” of states recognizes the first 101.
     • The second row of states recognizes the second 101.
     • The third row of states recognizes the first 101.
     • The bottom row of states traps and rejects any string that has a fourth 101.

   This is not the prettiest FA we’ve ever designed. In general, an FA to recognized exactly $k$ occurrences of a string of length $w$is going to require $O(k w)$ states.

   Can you do this with a PDA, taking advantage of the stack to use fewer ($O(w)$) states?

   Reveal

   PDAs are really good at counting (as long as we only need to count one thing at a time)

   • push a marker onto the stack to increase a count
   • pop a marker to decrease the count.

    

   

   You can see this idea in play here.

   • The transition from $q_0$ to $q_1$ loads up the stack with one character for each occurrence we want to see.
   • The transition sequence $[q_1, q_2, q_3, q_4]$ recognizes a 101. You should recognize elements from the NFA solution in the transitions maong these states.
   • The transition from $q_4$ to $q_1$ “counts” that occurrence by removing one of the symbols from the stack. (If the stack had already been emptied, the PDA fails.)
   • Also note the common “trick” of having a single accept state that we enter, from almost everywhere, when the stack has been emptied.
   • Try running this on 00100, 010111010, and 1011011101101

   This PDA could be very easily modified to look for two occurrences of 101, or five, or 100. Much easier than modifying the NFA.

2. How would you modify the previous answer to accept strings with 5 occurrences of 101?

   Reveal

   Just change the number of ‘x’ symbols pushed onto the stack at the very beginning, when making the transition from q0 to q1.

a[2*(i+1)] = (b[i] - 1)

1. Design a PDA for a language over {a, b, i, =, (, ) [, ] } to determine if the parentheses and brackets in such expressions are properly matched and nested.
   Reveal

    

   

   This is almost surprisingly easy.

   • Upon seeing a left parenthesis or left bracket, push it onto the stack.
   • Upon seeing a right parenthesis or right bracket, pop the corresponding left symbol from the stack.
     • If the left/right symbols do not match up properly, e.g., “(a]”, there will be no transition to match a “(” on the stack against an input character “]”, and the PDA will fail.
   • As long as the stack is empty, the parentheses and brackets are properly matched and nested.
     • If there are unmatched left symbols, e.g., “((b)”, then hte unmatched symbols will stay on top of the stack and we will be unable to enter the accepting state q1.

   Here is the PDA.

   • Test this on a[(i+1)]=a(b[a])a and a[b(a)a,a[i),a]b