Outline

• PDAs and CFLs
• Quiz
• CFG Pumping Lemma

Introduction

• Before the break, we were talking about context free languages (CFLs).
• These languages are specified by a context free grammar (CFG) `G = (V, Sigma, R, S)`.
• We said the syntax of programming languages are often specified using a CFG.
• We showed for any CFG `G` there are a CFG `G'` and `G''` such that `G'` and `G''` both generate the same language as `G` and `G'`is in Chomsky Normal Form (CNF) and `G''` is Greibach Normal Form.
• We gave the the cubic time CYK parsing algorithm for CNF grammars ato determine if a string `w` can be generated by the rules `R` of a grammar from the start symbol `S`.
• We then introduced a machine model called a pushdown automata (PDA) which we said could be used to recognize CFLs.
• A PDA `M=(Q, Sigma, Gamma, delta, q_0, z, F)` is a generalization of an NFA where in addition to the input alphabet `Sigma`, we also have a stack alphabet `Gamma` and a modified transition function `delta: Q times (Sigma cup {epsilon}) times (Gamma cup {epsilon}) -> P(Q times (Gamma cup {epsilon}))` which can be used to specify how to push symbols on or pop symbols off the stack.
• We begin today by describing how to recognize an CFL using a PDA and then we show any language recognized by a PDA is context-free.

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.

PDA to CFL

Let `P` be a PDA. We want to make a CFG `G` that generates the same language.

• For each pair of states `p`, `q` in `P` we will have in `G` a variable `A_(pq)`. This variable will be able to generate all strings that can take `P` in state `p` with the empty stack to state `q` with the empty stack.
• To simplify the problem we will assume `P` has been modified so that:
  • it has a single accept state
  • it empties its stack before accepting
  • each transition either pushes a symbol onto the stack or pops one off of the stack (but not both). (We might add states to make our machine have this property).
• `G` will have rules `A_(pp) -> epsilon` for each state `p` of `P`; `A_(pq) -> aA_(rs)b` for each `p`, `q`, `r`, `s` such that `delta(p,a, epsilon)` contains `(r,t)` and `delta(s,b, t)` contains `(q, epsilon)`, and `A_(pq) -> A_(pr)A_(rq)` for any state `r`.
• The start variable of `G` will be `A_(q_0,q_(mbox(accept)))`.

The proof that languages given by PDAs and the CFLs are the same is due independently to Chomsky (1962), Schutzenberger (1963), and Evey (1963).

Example PDA in JFLAP and of PDA to CFL conversion

• Consider the PDA:
  
• Notice the diagram comes from JFLAP. To make PDAs in JFLAP on the main button panel of JFLAP select "Pushdown Automata".
• This allows the user to create pushdown automata in much the same way as DFAs are made in JFLAP.
• When you choose Step-by-State menu item to run an automata on some inputs you will notice that the starting stack symbol is always "`Z`".
• The automata above recognizes the language `{a^nb^n | n >0}`.
• It has a single accept state and each transition either pushes or pops a symbol, so we can apply the construction.
• This machine empties the stack except for the start of stack symbol.
• The start variable given by the construction of the last slide will be `A_(q_0q_3)`. We'll abbreviate this as `A_(03)`.
• Many of the rules the construction would give are completely useless; nevertheless, one can check it does produce the rules `A_(03) -> epsilon A_(12) epsilon`, `A_(12)->aA_(12)b`, `A_(12)->aA_(11)b`, and `A_(11)->epsilon`.

Another Proof of the PDA to CFL result

• If you try to convert a PDA to a CFG in JFLAP you will notice that the algorithm is not the same as two slides back.
• Instead, JFLAP uses an algorithm based on the following proof:
  

  Alternative Proof can convert from PDA to a CFG. Let `N` be a PDA. Without loss of generality we assume the final state of `N` is entered iff the stack is empty. We also assume that any move of `N` increases or decreases the stack content by a single symbol. We set the variables of the simulating CFG to be of the form `(q_iAq_j)` where `q_i` and `q_j` are states of `N`. Our grammar will have rules that ensure that:
  `(q_iAq_j) =>^\star v`
  iff `N` erases `A` from the stack while reading `v` and going from state `q_i` to `q_j`. If our grammar has this property, and we choose `q_(\mbox(start))zq_(\mbox(final))` as the start symbol, then
  `q_(\mbox(start))zq_(\mbox(final)) =>^star w`
  iff `N` accepts `w`. To complete our proof, we now say the rules of our grammar and leave it to the reader to verify they work. Our grammar consists of two types of rules: (1) rules to handle `N` moves that decrease the stack size by `1` -- these have the form: `(q_iAq_j) -> a` for every transition of `N` from some `q_i` to `q_j` which when reading some `a` pops an `A` symbol from the stack; (2) rules to handle transitions from `(q_i,a, A)` to `(q_j, BC)`, these have the form: `(q_iAq_k) -> a(q_jBq_l)(q_lCq_k)` for all possible values of `k` and `l` in the set of states of `N`.

Quiz

Which of the following is true?

1. In LL-Parsing, the second L denotes that the parsing is being done according to a left-most derivation of the string being parsed.
2. Greibach Normal Form shows that parsing can be done using only logarithmic in the input length amount of space.
3. A pushdown automata is a deterministic finite automata augmented with a queue.

Pumping Lemma for Context Free Languages

Theorem. If `A` is a context free language, then there is a number `p` (the pumping length) where, if `s` is any string in `A` of length at least `p`, then `s` may be divided into five pieces `s = uvxyz` satisfying the conditions:

1. For each `i ge 0`, `uv^ixy^iz` is in `A`,
2. `|vy| > 0`, and
3. `|vxy| le p`.

Proof. Let `G` be a CFG for our context free language `A`. Let `|V|` be the number of variables in `G`. Let `b` be the maximum number of symbols on the right hand side of a rule. So the maximum number of leaves a parse tree of height `d` can have is `b^d`. We set the pumping length to `p = b^(|V|+1)`. So if `s` is in `A` of length bigger than `p`, its smallest parse tree must be of height greater than `|V|+1`. So some variable `R` must be repeated. So we can do the following kind of surgeries on the parse tree to show Condition 1 of the pumping lemma:
Condition 2 of the pumping lemma will hold since if `v` and `y` were the empty string then the pumped down tree would be a smaller derivations of `s` contradicting our choice of parse tree. Condition 3 can be guaranteed by choosing `R` so both occurrence are among the last `|V|+1` nonterminals of the longest path in the tree. The upper `R` generates `vxy` is therefore of height at most `|V|+1` and so can generate a string of length at most `b^(|V|+1) = p`.

Remarks on the Pumping Lemma

• A stronger form of the pumping lemma for CFGs, commonly known as Ogden's Lemma, was proven by W.G. Ogden in Mathematical Systems Theory. Vol.2. 1968. pp. 191--194.
• Ogden's result states:
  Lemma. If a language `L` is context-free, then there exists some number `p > 0` such that for any string `w` of length at least `p` in `L` and every way of "marking" `p` or more of the positions in `w`, `w` can be written as `w = uvxyz` with strings `u`, `v`, `x`, `y`, and `z`, such that
  1. `x` has at least one marked position,
  2. either `u` and `v` both have marked positions or `y` and `z` both have marked positions,
  3. `vxy` has at most `p` marked positions, and
  4. `uv^ixy^iz` is in `L` for every `i ge 0`.
• Ogden's Lemma was originally used to try to understand inherent ambiguity in CFGs.
• Earlier work on showing that there are languages which are inherently ambiguous had been done by Parikh (1966) (Technical Report on same 1961). His main result (Parikh's Theorem) was to show the CFLs have a semi-linearity property.
• These results can also be used to show languages are not context-free.
• Another interesting technique to show languages are inherently ambiguous or are not context-free is based on the generating function of a language. For a language context-free language `L`, let `a_n =` the number of strings of length `n` in the language and consider the power series `f(z) = sum_(n=0)^\infty a_nz^n`. It turns out this series is algebraic (finitely many roots) if and only if `L` is unambiguous. Flajolet (1985/1987) uses this to get inherently ambiguous results.

Example use of the CFL Pumping Lemma

• Let `C={a^ib^jc^k |0 le i le j le k}`. We show `C` is not CFL using the pumping lemma.
• Suppose `C` was CFL. Then it has a pumping length `p`. Consider the string `s=a^pb^pc^p`.
• By the pumping lemma `s` can be written as `uvxyz` satisfying the three condition of two slides ago.
• There are two cases to consider:
  1. Both `v` and `y` contain only one type of alphabet symbol. So one of `a`, `b`, or `c` does not appear in `v` or `y`. There are three subcases: (a) The `a`'s do not appear. By the pumping lemma, `uv^0xy^0z= uxz` must be in the language. This string has the same number of `a`'s but fewer `b`'s or `c`'s so cannot be in `C` giving a contradiction. (b) The `b`'s do not appear. Then either `a`'s or `c`'s must appear in `v` and `y`. If `a`'s appear, then `uv^2xy^2z` will have more `a`'s then `b`'s giving a contradiction. If `c`'s appear, then `uv^0xy^0z` will have more `b`'s then `c`'s giving a contradiction. (c) The `c`'s do not appear. Then `uv^2xy^2z` will have more `a`'s or `b`'s then `c`'s giving a contradiction.
  2. When either `v` or `y` contain more than one symbol `uv^2xy^2z` will not contain the symbols in the right order giving a contradiction.