1 / 57

CS 208: Computing Theory

CS 208: Computing Theory. Assoc. Prof. Dr. Brahim Hnich Faculty of Computer Sciences Izmir University of Economics. Context Free Languages. Context-Free Languages. So far …. Methods for describing regular languages Finite Automata Deterministic Non-deterministic Regular Expressions

chico
Download Presentation

CS 208: Computing Theory

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 208: Computing Theory Assoc. Prof. Dr. Brahim Hnich Faculty of Computer Sciences Izmir University of Economics

  2. Context Free Languages Context-Free Languages

  3. So far … • Methods for describing regular languages • Finite Automata • Deterministic • Non-deterministic • Regular Expressions • They are all equivalent, and limited • Cannot some simple languages like {0n1n | n is positive} • Now, we introduce a more powerful method for describing languages • Context-free Grammars (CFG)

  4. Are CFGs any useful? • Extremely useful! • Artificial Intelligence • Natural language Processing • Programming Languages • specification • compilation

  5. Example • This is a CFG which we call G1 • A0A1 • AB • B#

  6. Example: production rules • This is a CFG which we call G1 • A0A1 • AB • B# Each line is a substitution rules or production rules

  7. Example: variables • This is a CFG which we call G1 • A0A1 • AB • B# A and B are called variables or non-terminals

  8. Example: variables • This is a CFG which we call G1 • A0A1 • AB • B# 0,1, and # are called terminals

  9. Example: variables • This is a CFG which we call G1 • A0A1 • AB • B# A is the start variable

  10. Rules • We use a CFG to describe a language by generating each string of that language • Write down the start variable • Pick a variable written down and a production rule that starts with that variable • Replace that variable with right-hand side of the production rule • Repeat until no variable remain

  11. Derivations • This is a CFG which we call G1 • A0A1 • AB • B# • Derivations with G1 • A0A10B10#1 • A0A100A1100B1100#11 • A0A100A11000A111000B111000#111

  12. Parse tree • Parse tree for 0#1 in G1 • A0A10B10#1 A A B 1 0 #

  13. Parse tree Parse tree for 00#11 in G1 A0A100A1100B1100#11 A A A B 1 1 0 0 #

  14. Context-free languages • All strings generated by a CFG constitute the language of the grammar • Example: L(G1)={0n#1n | n is positive} • Any language generated by a context-free grammar is a context-free language

  15. A useful abbreviation • Production rules • A  0A1 • A  B • B  # • Can be written as • A  0A1 | B • B  #

  16. Another example • CFG G2 describing a fragment of English <SENTENCE>  <NOUN-PHRASE><VERB-PHRASE> <NOUN-PHRASE> <CMPLX-NOUN>|<PREP-PHRASE> <VERB-PHRASE><CMPLX-VERB>|<CMPX-VERB><PREP-PHRASE> <PREP-PHRASE><PREP><CMPLX-NOUN> <CMPLX-NOUN><ARTICLE><NOUN> <CMPLX-VERB><VERB>|<VERB><NOUN-PHRASE> <ARTICLE> a | the <NOUN>  boy | girl | flower <VERB>  touches | likes | sees <PREP>  with

  17. Another example • Examples of strings belonging to L(G2) a boy sees the boy sees a flower a girl with a flower likes the boy with a flower

  18. Another example • Derivation of a boy sees <SENTENCE>  <NOUN-PHRASE><VERB-PHRASE>  <CMPLX-NOUN><VERB-PHRASE>  <ARTICLE><NOUN> <VERB-PHRASE>  a <NOUN><VERB-PHRASE>  a boy <VERB-PHRASE>  a boy <CMPLX-VERB>  a boy <VERB>  a boy sees

  19. Formal definitions • A context-free grammar is a 4-tuple <V, ∑, R, S> where • V is a finite set of variables • ∑is a finite set of terminals • R is a finite set of rules: each rule is a variable and a finite string of variable and terminals • S is the start symbol

  20. Formal definitions • If • u and v are strings of variable and terminals, and • A  w is a rule of the grammar, • Then uAv yields uwv, written uAv  uwv • We write u * v if • u = v or • u u1  …. uk  v

  21. Formal definitions • The language of grammar G is • L(G) = {w | S * w}

  22. Example • Consider G4 =<{S},{(,)},R,S> where R is • S  (S) | SS | ε • What is the language of G4? • Examples: (), (()((())), …

  23. Example • Consider G4 =<{S},{(,)},R,S> where R is • S  (S) | SS | ε • What is the language of G4? • L(G4) is the set of strings of properly nested parenthesis

  24. Example • Consider G4 =<{E,T,F},{a,+, x, (, )},R,E> where R is • E  E + T | T • T  T X F | F • F  (E) | a • What is the language of G4? • Examples: a+a+a, (a+a) x a

  25. Example • Consider G4 =<{E,T,F},{a,+, x, (, )},R,E> where R is • E  E + T | T • T  T x F | F • F  (E) | a • What is the language of G4? • E stands for expression, T for Term, and F for Factor: so this grammar describes some arithmetic expressions

  26. Ambiguity • Sometimes a grammar can generate the same string in several different ways! • This string will have several parse trees • This is a very serious problem • Think if a C program can have multiple interpretations? • If a language has this problem, we say that it is ambiguous

  27. Example • Consider G5: <EXPR><EXPR>+<EXPR>|<EXPR>x<EXPR> |(<EXPR>) | a G5 is ambiguous because a+axa has two parse tress!

  28. Example • Consider G5: <EXPR><EXPR>+<EXPR>|<EXPR>x<EXPR> |(<EXPR>) | a G5 is ambiguous because a+axa has two parse tress! <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> a + a x a

  29. Example • Consider G5: <EXPR><EXPR>+<EXPR>|<EXPR>x<EXPR> |(<EXPR>) | a G5 is ambiguous because a+axa has two parse tress! <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> <EXPR> a + a x a a + a x a

  30. Formal definition: ambiguity • A string w is generated ambiguously in CFG G if it has two or more different leftmost derivations! • A derivation is leftmost if at every step the variable being replaced is the leftmost one • Grammar G is ambiguous if it generates some string ambiguously

  31. Chomsky Normal Form (CNF) • Every rule has the form • A  BC • A  a • S  ε • Where S is the start symbol, A, B, and C are any variables – except that B and C may not be the start symbol

  32. Theorem • Theorem: Any context-free language is generated by a context-free grammar in Chomsky normal form • How? • Add new start symbol S0 • Eliminate all rules of the form A  ε • Eliminate all “unit” rules of the form A  B • Patch up rules so that grammar denotes the same language • Convert remaining rules to proper form

  33. Steps to convert any grammar into CNF • Step1 • Add a new start symbol S0 • Add the rule S0S

  34. Steps to convert any grammar into CNF • Step2: Repeat • Remove some rule of the form A  ε where A is not the start symbol • Then, for each occurrence of A on the right-hand side of a rule, we add a new rule with that occurrence deleted • E.g., if R uAvAu where u and v are strings of variables and terminals • We add rules: R uvAu, RuAvu, and Ruvu • For RA add Rε, except if Rε has already been removed • Until all ε-rules not involving the start symbol have been removed

  35. Steps to convert any grammar into CNF • Step3: eliminate unit rules • Repeat • Remove some rule of the form A  B • For each Bu, add Au, except if Au has already been removed • Until all unit rules have been removed

  36. Steps to convert any grammar into CNF • Step4: convert remaining rules • Replace each rule A u1u2…uk, where k >2 and each ui is a terminal or a variable with the rules • Au1A1 • A1u2A2 • A2u3A3 • …. • Ak-2uk-1uk • If k=2, we replace any terminal ui in the preceding rules with the new variable Ui and add the rule Uiui

  37. Example • Start with • S  ASA | aB • A  B | S • B  b | ε

  38. Example • Step 1: add new start symbol and new rule • S0  S • S  ASA | aB • A  B | S • B  b | ε

  39. Example • Step 2: remove ε-rule B ε • S0  S • S  ASA | aB | a • A  B | S | ε • B  b

  40. Example • Step 2: remove ε-rule A ε • S0  S • S  ASA | aB | a | SA | AS | S • A  B | S • B  b

  41. Example • Step 3: remove unit rule S S • S0  S • S  ASA | aB | a | SA | AS | S • A  B | S • B  b

  42. Example • Step 3: remove unit rule S0 S • S0  S | ASA | aB | a | SA | AS • S ASA | aB | a | SA | AS • A  B | S • B  b

  43. Example • Step 3: remove unit rule A B • S0  ASA | aB | a | SA | AS • S ASA | aB | a | SA | AS • A  B | S | b • B  b

  44. Example • Step 3: remove unit rule A S • S0  ASA | aB | a | SA | AS • S ASA | aB | a | SA | AS • A  S | b | ASA | aB | a | SA | AS • B  b

  45. Example • Step 3: remove unit rule A S • S0  ASA | aB | a | SA | AS • S ASA | aB | a | SA | AS • A  b | ASA | aB | a | SA | AS • B  b

  46. Example • Step 4: convert remaining rules • S0  AA1|UB| a| SA | AS • S AA1|UB | a | SA | AS • A  b | AA1 | UB | a | SA | AS • B  b • Ua • A1SA

  47. Pushdown Automata

  48. Pushdown automata • Pushdown automat (PDA) are like nondeterministic finite automat but have an extra component called a stack • Can push symbols onto the stack • Can pop them (read them back) later • Stack is potentially unbounded

  49. input State control a a b a x y z stack

  50. Formal Definition • A pushdown automaton is a 6-tuple (Q,∑,S, ξ,q0,F), where • Q is a finite set of states • ∑ is a finite set of symbols called the alphabet • S is the stack alphabet • ξ : Q x ∑ε x Sε P(Q x Sε) is the transition function • q0 Є Q is the start state • F ⊆ Q is the set of accept states or final states

More Related