Outline

• PDAs
• HW Problems
• 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, a more formal syntax called Backus-Naur notation was used. It turns out that this Backus-Naur notation is equivalent to giving a CFG specification.
• Meanwhile, in Germany, Friedrich Bauer (like Chomsky still alive as of 2013) had come up with (1955 -1957 patent) 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. Turing (1946) had earlier used such an idea (without pulling out a data structure) for subroutine call handling.
• 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.

HW Problems

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)}`
  ... other useless transitions `}`.
• 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`. Let $ be our start of stack symbol.
  1. We have transitions `(q_(mbox(start)), epsilon , epsilon)` `rightarrow (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 `q_(mbox(loop))` 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.