Introduction to Computational Linguistics

21. Pushdown Automata 86
the PDA deterministic. We add here that theoretically the operation that reads the
top of the stack removes the topmost symbol. The stack really is just a memory
device. In order to look at the topmost symbol we actally need to pop it off the
stack. However, if we put it back, then this as if we had just ‘peeked’ into the top
of the stack. (We shall not go into the details here: but it is possible to peek into
any number of topmost symbols. The price one pays is an exponential blowup of
the number of states.)
We say that the PDA accepts ⃗x by state if it is in a final state at the end of ⃗x.
To continue the above example, we put the automaton in an accepting state if after
popping as the topmost symbol is #. Alternatively, we say that the PDA accepts
⃗x by stack if the stack is empty after ⃗x has been scanned. A slight modification of
the machine results in a machine that accepts the language by stack. Basically, it
needs to put one a less than needed on the stack and then cancel # on the last move.
It can be shown that the class of languages accepted by PDAs by state is the same
as the class of languages accepted by PDAs by stack, although for a given machine
the two languages may be different. We shall establish that the class of languages
accepted by PDAs by stack are exactly the CFGs. There is a slight problem in
that the PDAs might actually be nondeterministic. While in the case of finite state
automata there was a way to turn the machine into an equivalent deterministic
machine, this is not possible here. There are languages which are CF but cannot be
recognized by a deterministic PDA. An example is the language of palindromes:
{⃗x⃗x T : ⃗x ∈ A ∗ }, where ⃗x T is the reversal of ⃗x. For example, abddc T = cddba.
The obvious mechanism is this: scan the input and start pushing the input onto the
stack until you are half through the string, and then start comparing the stack with
the string you have left. You accept the string if at the end the stack is #. Since
the stack is popped in reverse order, you recognize exactly the palindromes. The
trouble is that there is no way for the machine to know when to shift gear: it cannot
tell when it is half through the string. Here is the dilemma. Let ⃗x = abc. Then
abccba is a palindrome, but so is abccbaabccba and abccbaabccbaabccba. In
general, abccba n is a palindrome. If you are scanning a word like this, there is no
way of knowing when you should turn and pop symbols, because the string might
be longer than you have thought.
It is for this reason that we need to review our notion of acceptance. First, we
say that a run of the machine is a series of actions that it takes, given the input. Alternatively,
the run specifies what the machine chooses each time it faces a choice.
(The alternatives are simply different actions and different subsequent states.) A