Outline

• Greibach Normal Form
• In-Class Exercise
• Pushdown Automata
• Start PDA to CFL

Greibach Normal Form

• On Monday, we were talking about the CYK algorithm for parsing CFGs in Chomsky Normal Form.
• We then very briefly introduced Greibach Normal Form. Today, we start by reviewing this form and reiterating why it is useful.
• A CFG is said to be in Greibach Normal Form if all productions are of the form `A->ax` where `a` is a terminal and `x` is a string of variables (possibly the empty string).
• It turns out that any CFG without the empty string is equivalent to one in Greibach Normal Form. This was proven by Sheila Greibach in 1965.
• Notice unlike an s-grammar, a grammar in Greibach Normal Form is allowed to have multiple rules with the same `(A, a)`.
• Greibach Normal Form is interesting for two reasons: (1) it can be used in proofs of equivalences of CFL with those languages recognized by a certain type of automaton with a stack. (2) it also gives a slightly different upper bound on the time/space needed to parse a string in a CFG.
• To see notice, a string is generated by a a CFG in Greibach Normal Form then as each rule consumes one string letter, the derivation will be of linear length.
• The brute force algorithm on this string might still take exponential time since if we are currently reading an `a`, there might be several applicable rules.
• However, as all particular derivations are of linear length, the algorithm is a linear space algorithm.
• Further, if we could nondeterministically guess which rule to apply, we could find verify a derivation in linear time. This shows the context free languages are in nondeterministic linear time.
• Another way to express what I mean by nondeterminism here is suppose I gave you a derivation some string `w` from a start symbol `S`. How fast could you verify that the derivation was made according to some fixed CFG `G`? If the CFG is in Greibach Normal Form, we know eeach yeeidls step consumees onee character of `w`, so it can be done in linear time in `w` rather than in time proportional to the derivation length (which might be much longer for some grammars).

Example Converting to Greibach Normal Form

• Consider the CFG `S->abSC|aa`, `C->b`.
• To convert to GNF we introduce new variables `A`, `B` with rules `A->a` and `B->b`.
• The the grammar `S-> aBSC|aA`, `C->b`, `A-> a`, `B->b` is in GNF.
• The above was relatively easy since we didn't have any rules whose right hand size began with a variable. i.e., a rule like `B -> BaD`. Greibach's proof gives an algorithm to eliminate such rules.
• The idea is if we have a rule `B->Bv` for some string `v in (Sigma \cup V)^star` and `B` also appears as the left hand side of a rule `B->u` for some `u` without `B` as its first symbol, we add a new variable `C` and add the rules:
  `B->uC`
  `C->v`
  `C->vC`
  If we do this for every rule of the form `B->u` (each time adding a different new variable), we can then delete the rule `B->Bv` from the grammar as still get a grammar that generates the same language.
• As part of the process in converting to Greibach Normal Form, we may also need to use eliminate unit rule steps.

In-Class Exercise

• Consider the context free grammar S->SS|(S)|a.
• Convert this grammar to Greibach Normal Form.
• Post your solution to the Mar 25 In-Class Exercise Thread.

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 (1924 - 2015) had come up with (1955 -1957 patent) the notion of a stack and also used it to show a simple algorithm for expression evaluation.
• When we first introduced CFGs, we showed how arithmetic expression could be represented using a 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.

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.