Introduction

We have been considering context free grammars as a model for how to specify programming language syntax and, to a lesser degree, human language syntax. (It should be noted besides humans some song birds have been shown to have languages that couldn't be described using regular language).
Last week, we showed every context free grammar was equivalent to one in Chomsky Normal Form.
That is, one in which there is at most one `epsilon` rule and its right side the is the start symbol and in which all other rules are either of the form `A->BC` for some variables `A,B,C` or of the form `A->a` for some variable `A` and terminal `a`.
We now use this to give our first parsing algorithms for CFGs.

The Cocke-Younger-Kasami (CYK) algorithm (1960)

This is an `O(n^3|G|)` algorithm to check if a string `w` can be generated by a CFG `G` in Chomsky Normal Form.
It constructs a table for what variables can generate the `i`th through `j`th character substring of `w`.
Given that `w in L(G)` from this table one could then reconstruct a parse tree for `w` and in theory supply code for it if `G` were unambiguous.
Lange and Leiss (2009) have noted that you can get away with a weaker normal form than CNF in the CYK algorithm that only has an at most linear blow-up in size over the grammar before normalization, we will stick to CNF since it is more well-known.
CYK is not the only parsing algorithm known for general CFGs. Earley (1968/1970) gives another `O(n^3)` algorithm which can operate directly on an arbitrary CFG without the need to convert to CNF. This algorithm makes use of reduction sequences (a reverse derivation). A finite automata for recognizing handles is used in this algorithm. Here handles are starts of RHSs of rules which might be replaced with a variable while working back from the string to the start variable.

As cubic algorithms tend to be slow, people use algorithms based on restricted types of CFGs with a fixed amount of lookahead. Either top down LL parsing or bottom-up LR parsing.
The former is like the recursive descent parsing we described earlier but where one computes a lookahead set from two sets First(k) and Follow(k) and use a deterministic PDA rather than relying on the run time stack. The latter can be viewed as a restricted form of Earley parsing.
Here the first L in LL and LR means scan the input left-to-right, then the second letter means try to perform a (L) left derivation or a (R) right derivation in the grammar.
In practice, in parsers like YACC, one often uses rule order to determine which rule for a given variable is chosen rather than rely on the condition of LR(k) grammars.
There have been improvements to the CYK algorithm which reduce the run-time below cubic (`O(n^(2.38)|G|)`) (based on an algorithm of Valiant that makes use of fast matrix multiplication which currently can be done in this time via Coppersmith and Winograd (the exponent is 2.3727 if use Williams 2011 modification)-- huge constants lurk here) and to quadratic in the case of an unambiguous grammar.

The idea is to build a table such that `mbox(table)(i,j)` contains those variables that can generate the substring of `w` start at location `i` until location `j`.
Algorithm. On input `w=w_1w_2 ldots w_n`:
1. If `w=epsilon` and `S-> epsilon` is a rule accept.
2. For `i = 1` to `n`: [set up the substrings of length `1` case]
3. For each variable `A`:
4. Test whether `A-> b` is a rule, where `b=w_i`
5. If so, place `A` in `mbox(table)(i,i)`.
6. For `l=2` to `n`:[Here `l` is a possible length of a substring]
7. For `i = 1` to `n - l + 1`: [`i` is the start of the substring]
8. Let `j = i + l - 1`, [`j` is the end of the substring]
9. For `k = i` to `j-1`: [`k` is a place to split the substring]
10. For each rule `A->BC`
11. If `mbox(table)(i,k)` contains `B` and `mbox(table)(k+1, j)` contains `C` put `A` in `mbox(table)(i,j)`.
12. If `S` is in `mbox(table)(1,n)` accept. Otherwise, reject.
The Valiant (1975) parsing algorithm basically computes the same table `mbox(table)(i,j)` of CYK but uses 0-1 matrix multiplication to do it.
Interestingly, Lee (2002) showed that any `O(n^{3- epsilon} \cdot |G|)` CFG parsing algorithm can be converted into an algorithm for computing the product of `(n \times n)`-matrices with `0-1`-entries in time `O(n^{3 - \varepsilon/3}).`

Consider the context free grammar `S->AT`, `S->c`, `T->SB`, `A->a`, `B->b`.
Let's look at the steps CYK would do to check if `\a\a\c\b\b` was in the language.
We'll abbreviate `mbox(table)(i,j)` as `T(i,j)`.
First, lines 2-5 would be used to set `T(1,1) = {A}`, `T(2,2) = {A}`, `T(3,3) = {S}`, `T(4,4) = {B}`, `T(5,5) = {B}`.
The `l=2` pass of lines `8-11` then fills in the table for substrings of length `2`. We get `T(1,2)={}`, `T(2,3)={}`, `T(3,4) = {T}`, `T(4,5) ={}`. Notice we added `T` to `T(3,4)` because `T(3,3)` was `{S}` and `T(4,4)` was `{B}` and we have a rule `T->SB`.
The `l=3` pass of lines `8-11` then fill is the table for substrings of length `3`. We get `T(1,3)={}`, `T(2,4)={S}`, `T(3,5)={}`. Here `T(2,4)={S}`, since `T(2,2)={A}` and `T(3,4)={T}` and we have the rule `S->AT`.
The `l=4` pass of lines `8-11` then fill is the table for substrings of length `4`. We get `T(1,4)={}` and `T(2,5)={T}`. This follows as `T(2,4)={S}` and `T(5,5)={B}` and `T->SB`.
Finally, when the `l=5` pass of lines `8-11` then fill is the table for substrings of length `5`. i.e., the whole string `\a\a\c\b\b`. In this case, `T(1,5)={S}` since `T(1,1)={A}` and `T(2,5)={T}` and we have the rule `S->AT`. As `T(1,5)` has the start variable we know the string `\a\a\c\b\b` is generated by the whole grammar.

Which of the following is true?

There are some context-free languages for which no CFG for the language exists that isn't ambiguous.
There are some context-free languages for which no CFG for the language exists that does not have unit productions.
Only s-grammars can be put into Chomsky Normal Form.