Outline

• Context-free Grammars
• Quiz
• Formal Definitions
• Examples/ Designing
• Parsing

Context Free Languages

• We saw that regular languages were useful for doing things like string matching.
• This might occur in practice as the so-called lexical analysis phase of compiler. That is, the phase in which we recognize tokens like language reserved words, variable names, constants, etc.
• We now turn to ways of specify programming languages or even aspects of natural languages.
• The key to this is to have some way to recognize the underlying structures such as nouns and verbs, or control blocks, etc of the language.
• Context Free Grammars (CFGs), which are a less restricted form of grammar than a regular grammar, and their languages will provide us with the tools to do this.

Example CFG

• Recall a grammar consists of a collection of substitution rules (aka productions). For instance: `A -> 0A1`, `A -> B`, `B -> #`
• Usually, we'll write variables using uppercase letters or in brackets like `<mbox(variable)>`. Terminals are supposed to be strings over the alphabet of the language we are considering.
• In a CFG, the left hand side of each rule has one variable; the right hand side can be a string of variables and terminals.
• Variables can be substituted for; terminals cannot. One variable denoted by S is usually distinguished as a start variable.
• An example sequence of substitutions (aka a derivation) in the above grammar might be: `A => 0A1 => 00A11 => 00B11 => 00#11`

More on CFGs

• Such a derivation might also be drawn as a parse tree:
  
• Here the derivation `A => 0A1` gives the tree portion:
  
• `A => 0A1 => 00A11` gives
  

Quiz

Which of the following is true?

1. The procedure we gave in class to convert a DFA to a regular expression used the power set construction.
2. Right linear grammars can recognize some languages not recognized by left linear grammars.
3. The algorithm we gave for finiteness checking of the language of a DFA and the proof of the pumping lemma both involved checking for repeated state in a DFA.

Formal Definitions

• A context free grammar is a 4-tuple `(V, Sigma, R, S)` where:
  1. `V` is a finite set called the variables.
  2. `Sigma` is a finite set, disjoint from `V` called the terminals.
  3. `R` is a finite set of rules. Here each rule being a pair consisting of a variable and a string of variables and terminals.
  4. `S in V` is a start variable.
• For a rule `A -> w` where `w` is a string over `(V cup Sigma)`, and for other strings `u` and `v`, we say uAv yields uwv, written `uAv => uwv`. We say `u` derives `v`, written `u=>^star v`, if there is a finite sequence: `u => u_1 => u_2 => ... => u_k=> v`.
• The language of a CFG is the set of of string over `Sigma^star` derivable from its start symbol.
• A language given by a context-free grammar (CFG) is called a context-free language (CFL -- aka Canadian Football League).
• Sometimes we abbreviate multiple rules with same left hand side using a `|`. For example, `A -> 0A1 | B` .
• Context-free grammars were first defined by Chomsky, N. "Three Models for the Description of Language," I R E Trans. on Information Theory. Vol. 2. Iss. 3. 1956. pp. 113--124.
• Backus (1959) and Naur (1960) later developed a notation for CFG which is often used in the context of computer languages (so-called Backus-Naur form).

Example

• Consider the grammar `G= (V, Sigma, R, <EXPR>)` where `V` is `{<EXPR>, <TERM>, <FACTOR>}` and `Sigma` is `{a, +, times, (, )}` and the rules are: `<EXPR> -> <EXPR> + <TERM> | <TERM>`, `<TERM> -> <TERM> times <FACTOR> | <FACTOR>`, and `<FACTOR> -> (<EXPR>) | a`.
• One can verify that `<EXPR> =>^star (a+a) times a`.
• This is true since `<EXPR> =><TERM> =><TERM> x <FACTOR>`
  `=><FACTOR> x <FACTOR> =>(<EXPR>) x <FACTOR>`
  `=>(<EXPR> + <TERM>)x<FACTOR> =>(<TERM>+<TERM>)x<FACTOR>`
  `=>(<FACTOR> + <TERM>) x <FACTOR> =>(a+ <TERM>) x <FACTOR>`
  `=>(a+ <FACTOR> ) x <FACTOR> =>(a+a) x <FACTOR> =>(a+a) x a`

Techniques for Designing CFGs

• Many CFLs are the union of simpler CFLs. So one can design a CFG for each in turn with start states say `S_1, S_2, ldots, S_n`. Then take the union of the rules and add a new start variable with a rule `S -> S_1| S_2|ldots |S_n`. For example, take the language `{0^n1^n | n geq 0} cup {1^n0^n | n geq 0}`. First we could make CFGs for each language separately. Say, `S_1 -> 0 S_1 1|epsilon` and `S_2 -> 1 S_2 0|epsilon`. Then add the rule `S -> S_1| S_2`.
• Notice any regular grammar is already a CFG, so the regular languages are all CFGs.
• For CFL which contain two sub-strings which are linked in the sense that a machine for such a language would need to remember information about one of the strings to verify information about the other substring, you might want to consider rules of the form `R -> u R v`. Here `u` and `v` should satisfy the property you are trying to verify.

Intuitions about Compilers

• Recall compilers take strings written in a high level language like C or Java and spit out code in machine language.
• So a compiler's job is to assign machine code "meaning" to a string written in C.
• The C language might be specified using a CFG.
• For instance, we might have a rule like:
  `< whi\l\e\ statement> -> whi\l\e <expression> <statement>
• Crudely, we could imagine writing a recursive program to handle this:
  

  int parseWhile(String program, int whereParsing, MachineCode whileCode) {
      MachineCode expressionCode = new MachineCode();
      MachineCode statementCode = new MachineCode(); 
      whereParsing += 5; //advance past the keyword 'while'
      whereParsing = parseExpression(program, whereParsing, expressionCode); 
      whereParsing = parseStatement(program, whereParsing, statementCode);
      // some code to build whileCode from expressionCode and statementCode return whereParsing;
  }
  

• The underlying assumption for compilation to work is that there can be only one machine code meaning one can give to a given C string. Here we have to be careful...

Ambiguity

• Sometime a grammar can generate string in more than one way.
• Such a string will have several different parse trees. As the parse tree is supposed to give us the "meaning" of the string, such a string would have more than one meaning.
• A string with more than one parse tree with respect to a grammar is said to be ambiguously derived in that grammar.
• For example, consider `<EXPR> -> <EXPR>+ <EXPR>| <EXPR> times <EXPR>|(<EXPR>) |a`.
• Then a + a x a can be derived with two different parse trees:
  
• The left tree probably means `a+(a times a)`; whereas, the right means `(a+a) times a`

Leftmost and Rightmost Derivations

• We want to formalize the notion of ambiguity in terms of derivations rather than parse trees as derivations are easier to work with syntactically.
• We say that a derivation of a string `w` in a grammar `G` is a leftmost derivation if at every step the leftmost remaining variable is the one replaced.
• We say that a derivation of a string `w` in a grammar `G` is a rightmost derivation if at every step the rightmost remaining variable is the one replaced.
• As an example, if our CFG was `A ->\B\A\C | epsilon`, `B -> b, C->c`. Then `A=>\B\A\C => \b\A\C => \b\B\A\C\C => \b\b\A\C\C => \b\b\C\C => \b\b\c\C => \b\b\c\c`, is a leftmost derivation of `\b\b\c\c`.
• On the other hand, `A => \B\A\C => \B\A\c => \B\B\A\C\c => \B\B\A\c\c => \B\B\c\c => \B\b\c\c => \b\b\c\c` would be a rightmost derivation of the same string.
• Intuitively, if we have two ways to expand the leftmost (respectively, rightmost) symbol then the derivation will be ambiguous.

Ambiguity and Leftmost Derivations

• A string `w` is derived ambiguously in `G` if it has two or more different leftmost derivations (resp. rightmost derivations). A CFG is called ambiguous if it generates some string ambiguously.
• In the case of a + a x a, the two left most derivations are:
  1. `<EXPR> =><EXPR> + <EXPR> => a + <EXPR>`
     `=> a + <EXPR> times <EXPR> => a+a times <EXPR> =>a+a times a`
  2. `<EXPR> => <EXPR> x <EXPR> => <EXPR> + <EXPR> times <EXPR>`
     `=> a + <EXPR> times <EXPR> =>a+ax<EXPR> => a+a times a`
• There are often many different CFGs for the same language. Even though one of these may be ambiguous some other may be unambiguous. We say a language is inherently ambiguous if one can never find an unambiguous CFG for it. The book says without proof that `{a^ib^jc^k| i=j \ mbox{or} \ j=k}` is inherently ambiguous.