Outline

• PDAs
• Equivalences with CFGs

Pushdown Automata

Let us recall our story so far...

• Chomsky 1956, working with natural languages, had come up with the notion of context free grammars.
• The first Fortran compiler appeared around 1956/1957 for the IBM 704 computer. It was based on a specification by Backus 1954, but not using CFGs.
• By the time the Algol 1960 specification was written though using a notation called Backus-Naur notation. Using Backus-Naur notation is equivalent to giving a CFG specification.
• Meanwhile, in Germany, Friedrich Bauer (like Chomsky still alive as of 2011) had come up with the notion of a stack and also used it to show a simple algorithm for expression evaluation. We have already seen how expression have a reasonable CFG. As an aside, Bauer later (1967) coins the term software engineering.
• It is reasonable to ask if maybe stacks could be useful for coming up with a platform neutral machine model for CFGs?
• Such a model, pushdown automata (PDA), was provided by Oettinger in 1961.

Machines with Stacks

• A machine with a stack might look something like:
• In a given state reading a given input symbol and a given stack symbol, the machine can switch states, advance to the next character of the input, pop the top symbol off the stack, or push a new symbol onto the stack.
• For instance, the language `{0^n1^n | n ge 0}` could be recognized by such a machine. When one reads an `0` push it onto the stack. When one starts reading `1`'s, if one ever sees another `0` reject, also start popping `0`'s off of the stack. If when one gets to the end of the string the stack is empty, then accept.

Formal Definition

• A pushdown automaton is a 7-tuple `M=(Q, Sigma, Gamma, delta, q_0, z, F)` where:
  1. `Q` is the set of states,
  2. `Sigma` is the input alphabet,
  3. `Gamma` is the stack alphabet
  4. `delta: Q times (Sigma cup {epsilon}) times (Gamma cup {epsilon}) -> P(Q times (Gamma cup {epsilon}))` is the transition function
  5. `q_0 in Q` is the start state,
  6. `z in Gamma` is the start of stack symbol.
  7. `F subseteq Q` is the set of accept states.
• `M` accepts `w=w_1w_2 ldots w_n` where each `w_i in Sigma cup {epsilon}` if there is a sequence of states `r_0, r_1, ldots, r_m in Q` and a sequence of strings `s_0, s_1, ..., s_m` in `Gamma^star` such that
  1. `r_0= q_0`, `s_0= z`,
  2. for `i =0,ldots, m-1`, we have `(r_(i+1),b) in delta(r_i, w_(i+1), a)` where `s_i = at` and `s_(i+1)= bt` for some `a,b in Gamma cup {epsilon}` and `t in Gamma^star`, and
  3. `r_m in F`.

Remarks on the Definition

• Notice the machine is a generalization of an NFA not a DFA.
• One can show deterministic pushdown automata are a strictly weaker than nondeterministic pushdown automata.

Example

• We can define a machine to recognize `{0^n1^n | n ge 0}` as `M=(Q, Sigma, Gamma, delta, q_1, $, F)` where:
  `Q={q_1, q_2, q_3, q_4}`,
  `Sigma={0,1}`,
  `Gamma={0,$}`,
  `F={q_1, q_4}`,
  and `delta={`
  `(q_1, epsilon, epsilon)->(q_2, $)`,
  `(q_2, 0, epsilon)->(q_2, 0)`,
  `(q_2, 1, 0)->(q_3, epsilon)`,
  `(q_3, 1, 0)->(q_3, epsilon)`,
  `(q_3, epsilon, $) ->(q_4, epsilon)`
  `}`.
• One can then using the definition show this machine accepts `0011`.

Equivalence

• We now works towards showing a language is context free if and only if some pushdown automata recognizes it.
• The proof splits into two parts:
  • If a language is context-free then some pushdown automata recognizes it
  • If a pushdown automata recognizes some language then there is a context-free grammar that recognizes the same language.

CFL to PDA

• Let `L` be a CFL. Let `G` be a CFG for this language, and let `w` be a string generated by `G` (and hence in `L`). We will have a machine with three main states `{q_(mbox(start)), q_(mbox(loop)), q_(mbox(accept))}` together with some auxiliary states `E`.
  1. We have transitions `(q_(mbox(start)), epsilon , epsilon) ->\(q_(mbox(loop)), S\)` that push the start variable `S` of the CFG onto our machine's stack.
  2. Then what we want to do is to simulate the steps to generate `w` on our PDAs stack.
     1. If `A` is a variable of the CFG on the top of the stack, and we are in the state qloop we nondeterministically choose a rule `A->w_1w_2 ldots w_n` and using a sequence of transitions `\(q_(mbox(loop)) , epsilon, A\) -> (q_1, w_n)` , `(q_1, epsilon, epsilon) ->(q_2, w_(n-1)) ldots (q_n, epsilon, epsilon) ->(q_(mbox(loop)), w_1)`. We simulate this rule on the stack. Here `q_i` are some of the auxiliary states in `E`.
     2. To handle a terminal such as `b` on the top of the stack we have transitions `(q_(mbox(loop)) ,b, b) -> \(q_(mbox(loop)) , epsilon\)`.
  3. Finally, we have a transition `(q_(mbox(loop)) , epsilon, $) ->(q_(mbox(accept)), $)` where `q_(mbox(accept))` is our accept state.