Abstract

Practice running and constructing PDAs.

1 JFLAP

1. Review the Pushdown Automata section of the Tutorial.

   • When you create a new PDA, JFlap give you an option to allow multiple or single (only) character input.

     • The single character input option also limits JFlap to pushing at most one character onto the stack per transition.

   • Our definition of PDAs (from the textbook) allows only single input characters, but allows multiple symbols to be pushed onto the stack in one transition.

     • To get this in JFlap, select “Multiple Character Input” but remember that you must only transition on one input character at a time.

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

   Try executing it (“Input -> Step by Closure”) on these inputs:

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

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

    
   

   Try executing it (“Input -> Step by Closure”) on these inputs:

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

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 the PDA for palindromes.

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

1. Design a PDA to recognize the set of all strings over ${0, 1}$ that contain 101.
   Reveal

   Weeks ago, we found this NFA for the language of strings that contain at least one occurrence of “101”.

   

   (JFLAP)

   (video)

   • Try running this on 00100 and 001011.

   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.

   

   (JFLAP)

   (video)

   • Try running this on 00100 and 001011.

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

   But sometimes PDAs can do it better.

1. Design a PDA to recognize the set of all strings over ${0, 1}$ that contain exactly three non-overlapping occurrences of 101.

   Reveal

   Again, this is something that we can do with an NFA. Here’s an approximation.

   

   (JFLAP)

   (video)

   (This actually accepts 3 or more occurrences, but we could tweak it to make it accept exactly 3. We would need to convert it to a more deterministic form to do so.)

   But 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.

   

   (JFLAP)

   (video)

   • 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 would 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 to determine if the parentheses and brackets in such expressions are properly matched and nested.
   Reveal

   This is almost surprisingly easy.

   

   (JFLAP)

   (video)

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