Context-Free Grammars and Languages

Transcription

1 September 23, 2014

2 Limitations of finite automata

3 Limitations of finite automata There are languages, such as {0 n 1 n n 0} that cannot be described (specified) by finite automata or regular expressions

4 Limitations of finite automata There are languages, such as {0 n 1 n n 0} that cannot be described (specified) by finite automata or regular expressions Context-free grammars provide a more powerful mechanism for language specification

5 Limitations of finite automata There are languages, such as {0 n 1 n n 0} that cannot be described (specified) by finite automata or regular expressions Context-free grammars provide a more powerful mechanism for language specification Context-free grammars can describe features that have a recursive structure making them useful beyond finite automata

6 Historical notes Context-free grammars were first used to study human languages One way of understanding the relationship between syntactic categories (such as noun, verb, preposition, etc) and their respective phrases leads to natural recursion This is because noun phrases may occur inside the verb phrases and vice versa.

7 Note Context-free grammars can capture important aspects of these relationships

8 Important application Context-free grammars are used as basis for compiler design and implementation Context-free grammars are used as specification mechanisms for programming languages Designers of compilers use such grammars to implement compiler s components, such a scanners, parsers, and code generators The implementation of any programming language is preceded by a context-free grammar that specifies it

9 Context-free languages The collection of languages specified by context-free grammars are called context-free languages Context-free languages include regular languages and many others Here we will study the formal concepts of context-free grammar and context-free language

10 Notations

11 Notations We abbreviate the phrase context-free grammar to CFG.

12 Notations We abbreviate the phrase context-free grammar to CFG. We abbreviate the phrase context-free language to CFL.

13 Notations We abbreviate the phrase context-free grammar to CFG. We abbreviate the phrase context-free language to CFL. We abbreviate the concept of a CFG substitution rule to the tuple lhs rhs where lhs stands for left hand side and rhs stands for right hand side.

14 More on substitution rules

15 More on substitution rules The lhs of a substitution rule is also called variable and is denoted by capital letters

16 More on substitution rules The lhs of a substitution rule is also called variable and is denoted by capital letters The rhs of a substitution rule is also called a specification pattern and consists of a string of variables and constants

17 More on substitution rules The lhs of a substitution rule is also called variable and is denoted by capital letters The rhs of a substitution rule is also called a specification pattern and consists of a string of variables and constants The constants that occur in a specification pattern are also called terminal symbols

18 CFG: Informal A CFG grammar consists of a collection of substitution rules where one variable is designated as start variable Example: the CFG G 1 has the following specification rules: A 0A1 A B B #

19 Note Nonterminals of CFG G 1 are {A, B} and A is the start variable Terminals of CFG G 1 are {0, 1, #}

20 More terminology

21 More terminology The substitution rules of a CFG are also called productions

22 More terminology The substitution rules of a CFG are also called productions Nonterminals used in the specification rules defining a CFG may be strings

23 More terminology The substitution rules of a CFG are also called productions Nonterminals used in the specification rules defining a CFG may be strings Terminals in the substitution rules defining a CFG are constant strings

24 Terminals Terminals used in CFG specification rules are analogous to the input alphabet of an automaton Example terminals used in CFG-s are letters of an alphabet, numbers, special symbols, and strings of such elements.

25 Language specification A CFG is used as a language specification mechanism by generating each string of the language in following manner:

26 Language specification A CFG is used as a language specification mechanism by generating each string of the language in following manner: 1. Write down the start variable; it is the lhs of one of the substitution rules, the top rule, unless specified otherwise

27 Language specification A CFG is used as a language specification mechanism by generating each string of the language in following manner: 1. Write down the start variable; it is the lhs of one of the substitution rules, the top rule, unless specified otherwise 2. Find a variable that is written down and a rule whose lhs is that variable. Replace the written down variable with the rhs of that rule

28 Language specification A CFG is used as a language specification mechanism by generating each string of the language in following manner: 1. Write down the start variable; it is the lhs of one of the substitution rules, the top rule, unless specified otherwise 2. Find a variable that is written down and a rule whose lhs is that variable. Replace the written down variable with the rhs of that rule 3. Repeat step 2 until no variables remain in the string thus generated

29 Example string generation Using CFG G 1 we can generate the string 000#111 as follows:

30 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A

31 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1

32 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1 00A11

33 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1 00A11 000A111

34 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1 00A11 000A B111

35 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1 00A11 000A B #111

36 Example string generation Using CFG G 1 we can generate the string 000#111 as follows: A 0A1 00A11 000A B #111 Note: The sequence of substitutions used to obtain a string using a CFG is called a derivation and may be represented by a tree called a parse tree

37 Example derivation tree The derivation tree of the string 000#111 using CFG G 1 is in Figure 1 A A A A B # Figure 1 : Derivation tree for 000#111

38 Note

39 Note All strings of terminals generated in this way constitute the language specified by the grammar

40 Note All strings of terminals generated in this way constitute the language specified by the grammar We write L(G) for the language generated by the grammar G. Thus, L(G 1 ) = {0 n #1 n n 0}.

41 Note All strings of terminals generated in this way constitute the language specified by the grammar We write L(G) for the language generated by the grammar G. Thus, L(G 1 ) = {0 n #1 n n 0}. The language generated by a context-free grammar is called a Context-Free Language, CFL.

42 More notations

43 More notations To distinguish nonterminal from terminal strings we often enclose nonterminals in angular parentheses,,, and terminals in quotes,

44 More notations To distinguish nonterminal from terminal strings we often enclose nonterminals in angular parentheses,,, and terminals in quotes, If two or more rules have the same lhs, as in the example A 0A1 and A B, we may compact them using the form A 0A1 B where is used with the meaning of an or

45 More notations To distinguish nonterminal from terminal strings we often enclose nonterminals in angular parentheses,,, and terminals in quotes, If two or more rules have the same lhs, as in the example A 0A1 and A B, we may compact them using the form A 0A1 B where is used with the meaning of an or In general if there are multiple rules of the form lhs rhs 1, lhs rhs 2,..., lhs rhs n we may compactly write them in the form lhs rhs 1 rhs 2 rhs n

46 CFG G 2 The CFG G 2 specifies a fragment of English SENTENCE NounPhrase VerbPhrase NounPhrase CpNoun CpNoun PrepPhrase VerbPhrase CpVerb CpVerb PrepPhrase PrepPhrase Prep CpNoun CpNoun Article Noun CpVerb Verb Verb NounPhrase Article a the Noun boy girl flower Verb touches likes sees Prep with

47 Note The CFG G 2 has ten variables (capitalized and in angular brackets) and 9 terminals (written in the standard English alphabet) plus a space character Also, the CFG G 2 has 18 rules Examples strings that belongs to L(G 2 ) are: a boy sees the boy sees a flower a girl with a flower likes the boy

48 Example derivation with G 2 SENTENCE NounPhrase VerbPhrase CpNoun VerbPhrase Article Noun VerbPhrase a Noun VerbPhrase a boy VerbPhrase a boy CpVerb a boy Verb a boy sees

49 Formal definition of a CFG

50 Formal definition of a CFG A context-free grammar is a 4-tuple (V, Σ, R, S) where:

51 Formal definition of a CFG A context-free grammar is a 4-tuple (V, Σ, R, S) where: 1. V is a finite set called the variables or nonterminals

52 Formal definition of a CFG A context-free grammar is a 4-tuple (V, Σ, R, S) where: 1. V is a finite set called the variables or nonterminals 2. Σ is a finite set of strings, disjoint from V, called terminals

53 Formal definition of a CFG A context-free grammar is a 4-tuple (V, Σ, R, S) where: 1. V is a finite set called the variables or nonterminals 2. Σ is a finite set of strings, disjoint from V, called terminals 3. R is a finite set of rules (or substitution rules) of the form lhs rhs, where lhs V, rhs (V Σ)

54 Formal definition of a CFG A context-free grammar is a 4-tuple (V, Σ, R, S) where: 1. V is a finite set called the variables or nonterminals 2. Σ is a finite set of strings, disjoint from V, called terminals 3. R is a finite set of rules (or substitution rules) of the form lhs rhs, where lhs V, rhs (V Σ) 4. S V is the start variable

55 Example CFG grammar G 1 = ({A, B}, {0, 1, #}, R, A) where R is: A 0A1 A B B #

56 Direct derivation

57 Direct derivation If u, v, w (V Σ) (i.e., are strings of variables and terminals) and A w R (i.e., is a rule of the grammar) then we say that uav yields uwv, written uav uwv

58 Direct derivation If u, v, w (V Σ) (i.e., are strings of variables and terminals) and A w R (i.e., is a rule of the grammar) then we say that uav yields uwv, written uav uwv We may also say that uwv is directly derived from uav using the rule A w

59 Derivation Suppose u, v (V Σ) are strings of variables and terminals We say that u derives v, written as u v, if u = v or if a sequence u 1, u 2,..., u k (V Σ) exists, for k 0, and u 1 u 2... u k v

60 Language specified by G If G = (V, Σ, R, S) is a CFG then the language specified by G (or the language of G) is L(G) = {w Σ S w}

61 Note Often we specify a grammar by writing down only its rules We can identify the variables as the symbols that appear only as the lhs of the rules Terminals are the remaining strings used in the rules

62 More examples of CFGs

63 More examples of CFGs Consider the grammar G 3 = ({S}, {a, b}, {S asb SS ɛ}, S)

64 More examples of CFGs Consider the grammar G 3 = ({S}, {a, b}, {S asb SS ɛ}, S) L(G 3 ) contains strings such as abab, aaabbb, aababb;

65 More examples of CFGs Consider the grammar G 3 = ({S}, {a, b}, {S asb SS ɛ}, S) L(G 3 ) contains strings such as abab, aaabbb, aababb; Note: if one think at a, b as (, ) then we can see that L(G 3 ) is the language of all strings of properly nested parentheses

66 Arithmetic expressions Consider the grammar G 4 = ({E, T, F }, {a, +,, (, )}, R, E) where R is: E E + T T T T F F F (E) a L(G 4 ) is the language of arithmetic expressions

67 Note Arithmetic operations in L(G 4 ) are addition, represented by +, and multiplication, represented by * An examples of a derivation using G 4 is in Figure 2

68 Example derivation with G 4 E E + T T T * F F F a a Figure 2 : a Derivation tree for a+a*a

69 Designing CFGs As with the design of automata, the design of CFGs requires creativity CFGs are even trickier to construct than finite automata because we are more accustomed to programming a machine than we are to specify programming languages

70 Design techniques

71 Design techniques Many CFG are unions of simpler CFGs. Hence the suggestion is to construct smaller, simpler grammars first and then to join them into a larger grammar

72 Design techniques Many CFG are unions of simpler CFGs. Hence the suggestion is to construct smaller, simpler grammars first and then to join them into a larger grammar The mechanism of grammar combination consists of putting all their rules together and adding the new rules S S 1 S 2... S k where the variables S i,1 i k, are the start variables of the individual grammars and S is a new variable

73 Example grammar design Design a grammar for the language {0 n 1 n n 0} {1 n 0 n n 0}

74 Example grammar design Design a grammar for the language {0 n 1 n n 0} {1 n 0 n n 0} 1. Construct the grammar S 1 0S 1 1 ɛ that generates {0 n 1 n n 0}

75 Example grammar design Design a grammar for the language {0 n 1 n n 0} {1 n 0 n n 0} 1. Construct the grammar S 1 0S 1 1 ɛ that generates {0 n 1 n n 0} 2. Construct the grammar S 2 1S 2 0 ɛ that generates {1 n 0 n n 0}

76 Example grammar design Design a grammar for the language {0 n 1 n n 0} {1 n 0 n n 0} 1. Construct the grammar S 1 0S 1 1 ɛ that generates {0 n 1 n n 0} 2. Construct the grammar S 2 1S 2 0 ɛ that generates {1 n 0 n n 0} 3. Put them together adding the rule S S 1 S 2 thus getting S S 1 S 2 S 1 0S 1 1 ɛ S 2 1S 2 0 ɛ

77 Second design technique

78 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language

79 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language Conversion procedure:

80 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language Conversion procedure: 1. Make a variable R i for each state q i of DFA

81 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language Conversion procedure: 1. Make a variable R i for each state q i of DFA 2. Add the rule R i ar j to the CFG if δ(q i, a) = q j is a transition in the DFA

82 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language Conversion procedure: 1. Make a variable R i for each state q i of DFA 2. Add the rule R i ar j to the CFG if δ(q i, a) = q j is a transition in the DFA 3. Add the rule R i ɛ if q i is an accept state of the DFA

83 Second design technique Constructing a CFG for a regular language is easy if one can first construct a DFA for that language Conversion procedure: 1. Make a variable R i for each state q i of DFA 2. Add the rule R i ar j to the CFG if δ(q i, a) = q j is a transition in the DFA 3. Add the rule R i ɛ if q i is an accept state of the DFA 4. If q 0 is the start state of the DFA make R 0 the start variable of the CFG.

84 Third design technique Certain CFLs contain strings with two related substrings as are 0 n and 1 n in {0 n 1 n n 0} Example of relationship: to recognize such a language a machine would need to remember an unbounded amount of info about one of the substrings

85 Note A CFG that handles this situation uses a rule of the form R urv which generates strings wherein the portion containing u s corresponds to the portion containing v s

86 Fourth design technique In a complex language, strings may contain certain structures that appear recursively Example: in arithmetic expressions any time the symbol a appear, the entire parenthesized expression may appear.

87 Ambiguity If a CFG G generates the same string x in several different ways, we say that x is derived ambiguously in G. If a CFG G generates some string ambiguously we say that the grammar G is ambiguous

88 Example Consider the grammar G 4 whose rules are: E E + T T, T T F F, F (E) a and the grammar G 5, whose rules are: E E + E E E (E) a L(G 4 ) = L(G 5 ) Note: one can easily show this by showing the inclusions L(G 4 ) L(G 5 ) and L(G 5 ) L(G 4 ) G 5 generates ambiguously some arithmetic expressions while G 4 doesn t.

89 Ambiguous expressions Figure 3 shows two different derivation trees for a+a*a E E * E E + E a E E + E a E * E a a a a Figure 3 : Two derivation trees for a+a*a

90 Note The grammar G 5 does not capture the usual precedence relations and so groups + before * and vice versa In contrast, the grammar G 4 generates the same language, but every generated string has a unique derivation tree Hence, G 5 is ambiguous and G 4 is not, i.e., G 4 is unambiguous

91 Another example G 2 below is another ambiguous grammar SENTENCE NounPhrase VerbPhrase NounPhrase CpNoun CpNoun PrepPhrase VerbPhrase CpVerb CpVerb PrepPhrase PrepPhrase Prep CpNoun CpNoun Article Noun CpVerb Verb Verb NounPhrase Article a the Noun boy girl flower Verb touches likes sees Prep with

92 Example ambiguous string The sentence: the girl touches the boy with the flower has two different derivations, so it is ambiguous The two derivations correspond to the two readings: (the girl touches the boy) (with the flower) (the girl touches) (the boy with the flower)

93 Note When a grammar generates a string ambiguously it means that the string has two different parse trees and not two different derivations Two different derivations however, may produce the same derivation tree because they may differ in the order in which they replace nonterminals not in the rules they use To concentrate on the structure we define a type of derivation that replaces variables in a fixed order

94 Fixing rule application order Leftmost derivation: a derivation of a string w in a grammar G is a leftmost derivation if at every step the leftmost nonterminal is replaced

95 Ambiguity again A string w is derived ambiguously in the CFG G if it has two or more different leftmost derivations. A CFG G is ambiguous if it generates some string ambiguously

96 Note Sometimes when we have an ambiguous grammar (such as G 5 ) we can find an unambiguous grammar (such as G 4 ) that generates the same language

97 Inherent ambiguity Some CFL, however, can be generated only by ambiguous grammar. A CFL that can be generated only by ambiguous grammars is called inherently ambiguous Example of inherently ambiguous language: {0 i 1 j 2 k i = j j = k}