Przetwarzanie języka Wprowadzenie do informatyki Jerzy Nawrocki www.cs.put.poznan.pl/jnawrocki/wdi

Komputer Człowiek Gracz A B Test Turinga (1950) Komputer Człowiek Gracz A B Alan Turing

User: They’re always buggin us about something or other. Program ELIZA (1966) User: Men are all alike. Eliza: In what way User: They’re always buggin us about something or other. Eliza: Can you think of a specific example User: My boyfriend made me come here Eliza: Your boyfriend made you come here Joseph Weizenbaum

Przetwarzanie języka naturalnego Fonetyka Morfologia Składnia Semantyka Pragmatyka Discourse

Podejścia do analizy języka Formalna teoria języka Modele probabilistyczne

Drzewo rozbioru (parse tree) Sentence VP NP Verb NP the man took the book

Plan wykładu Gramatyka i wywód Język formalny Gramatyki bezkontekstowe Notacja Backusa-Naura Idea zejść rekurencyjnych

(reguły zastępowania) S  1 S  S 1 Produkcje i wywód 1+ = { 1, 11, 111, ... } Symbol początkowy: S Produkcje: (reguły zastępowania) S  1 S  S 1 1) 2) Wywód:  1 1: S 1  2  2  1 111: S S 1 S 1 1 1 1 1

Inne produkcje S  A B A  1 A  A 1 B  0 B  B 0 Wywód:    10: S 1) 2) 3) 4) 5) Wywód:  1  2  4 10: S A B 1 B 1 0 100:

Gramatyka S  A B A  1 A  A 1 B  0 B  B 0 Symbol początkowy Symbole nieterminalne N = {S, A, B} Symbole terminalne T = {0, 1} Produkcje

Domknięcie relacji wywodu S  A B A  1 A  A 1 B  0 B  B 0 1) 2) 3) 4) 5) Wywód: S A B 1 B 1 0  1 2 4 S 1 0  + Z S można wywieść 10 stosując 1 lub więcej produkcji

Zbiór ciągów nad alfabetem S  A B A  1 A  A 1 B  0 B  B 0 Alfabet = Zbiór symboli terminalnych T = {0, 1} Zbiór ciągów nad alfabetem T*: Zbiór wszystkich ciągów skończonych zbudowanych z elementów zbioru T. Jeśli T = {0, 1} to T* = {, 0, 1, 00, 01, 10, 11, 000, ...} Jeśli T = {a, b, c} to T* = {, a, b, c, aa, ab, ac, ba, bb, bc, ...}

Gramatyka G = <S, N, T, P> Język formalny Gramatyka G = <S, N, T, P> S – Symbol początkowy N – Zbiór symboli nieterminalnych T – Zbiór symboli terminalnych P – Zbiór produkcji Język formalny L zdefiniowany przez gramatykę G: L(G) = {x  T*: S x  + }

Język formalny S  A B A  1 A  A 1 B  0 B  B 0 L(G) = {x  T*: S x 1) 2) 3) 4) 5) S  A B A  1 A  A 1 B  0 B  B 0 L(G) = {x  T*: S x  + } S A B 1 B  1 2 S 1 B  + Czy 1B należy do L(G) ? 11  T* Czy 11 należy do L(G) ?

Równoważność gramatyk Gramatyki G1 i G2 są równoważne wtedy i tylko wtedy, gdy L(G1) = L(G2) S  A B A  1 A  A 1 B  0 B  B 0 G1 S  S 0 S  A 0 A  1 A  A 1 G2 S  1 S S  1 A A  0 A  0 A G3

Klasyfikacja Chomsky’ego Noam Chomsky Gramatyki klasy 0 Gramatyki kontekstowe Gramatyki bezkontekstowe Gramatyki liniowe

Gramatyki liniowe S  S b S  A b A  a A  A a Prawoliniowa S  a S S  a B B  b B B  b Lewoliniowa Twierdzenie. Dla każdego wyrażenia regularnego istnieje gramatyka lewoliniowa (prawoliniowa) opisująca ten sam język.

Gramatyka bezkontekstowa 1. W  ( W ) 2. W  1 Jeden nieterminal

Gramatyka bezkontekstowa W  S W  W + S 3. S  C 4. S  S * C 5. C  L 6. C  ( W ) 7. L  1 8. L  2 9. L  3 Jeden nieterminal

Gramatyka kontekstowa S  a X Y S  a S X Y a X  a b b X  b b c X  c c b Y  b c c Y  c c

Rozszerzona notacja Backusa-Naura Produkcje + wyrażenia regularne <C> ::= ‘0’ | ‘1’ | ‘2’ | ‘3’ | ‘4’ | ‘5’ | ‘6’ | ‘7’ | ‘8’ | ‘9’ <L> ::= <C>+ <L> ::= <C>* <C> <S> ::= (<L> ‘*’)* <L> <W> ::= (<S> ‘+’)* <S> John Backus

Przejście z EBNF na gramatyki <J> ::= <A>* <B> J  B J  A J

Przejście z EBNF na gramatyki <L> ::= <C>* <C> <S> ::= (<L> ‘*’)* <L> <W> ::= (<S> ‘+’)* <S> C  ‘0’ C  ‘1’ C  ‘2’ . . . C  ‘9’

Przejście z EBNF na gramatyki <L> ::= <C>* <C> <S> ::= (<L> ‘*’)* <L> <W> ::= (<S> ‘+’)* <S> <J> ::= <A>* <B> J  B J  A J L  C L  C L

Idea zejść rekurencyjnych - Problem Język liczb binarnych L = {0, 1, 00, 01, 10, 11, ...}. Po liczbie jest spacja. Napisać program sprawdzania, czy x  L. N – liczba binarna (Numer binarny) C – Cyfra binarna N  C N N  C C  0 C  1 N = C+ N = {C, CC, CCC, ...} gdzie C = {0, 1}

Bufor wejściowy 1 ‘ ‘ Token N  C N N  C C  0 C  1 #define Bool int ‘ ‘ Token #define Bool int #define True 1 #define False 0 char Token; void Init(){ scanf("%c", &Token); return; } Bool Widzisz(char c){ return Token == c; void Nastepny(){ N  C N N  C C  0 C  1

Bufor wejściowy 1 Token N  C N N  C C  0 C  1 void main(){ Init(); Token void main(){ Init(); if (N()){ printf("OK\n"); }else{ printf("Error\n"); } return; N  C N N  C C  0 C  1

Bufor wejściowy 1 Token N  C N N  C C  0 C  1 Bool C(){ Token Bool C(){ if (Widzisz('0') || Widzisz('1')){ Nastepny(); return True; }else{ return False; } N  C N N  C C  0 C  1

Bufor wejściowy 1 Token N  C N N  C C  0 C  1 #define N_ogr ' ' Token #define N_ogr ' ' Bool N(){ Bool ok; ok= C(); if (ok && Widzisz(N_ogr)){ return ok; }else{ if (ok){ return N(); }else{ return False; } N  C N N  C C  0 C  1

Gramatyki bezkontekstowe Notacja Backusa-Naura Podsumowanie Wreszcie! Gramatyka formalna Wywód zdania Język formalny Gramatyki bezkontekstowe Notacja Backusa-Naura Idea zejść rekurencyjnych