Cocke-Younger-Kasami-Algorithmus

Der Cocke-Younger-Kasami-Algorithmus (CYK-Algorithmus) ist ein Algorithmus aus dem Gebiet der Theoretischen Informatik. Mit ihm lässt sich feststellen, ob ein Wort zu einer bestimmten kontextfreien Sprache gehört. In der Fachsprache bezeichnet man dies als Lösen des Wortproblems für kontextfreie Sprachen. Mit Hilfe von Backtracking kann der Parse-Tree bzw. die Parse-Trees eines gegebenen Wortes der Sprache konstruiert werden. Um den Algorithmus anzuwenden, muss zu der vorgegebenen Sprache eine Grammatik in Chomsky-Normalform vorliegen. Der Ende der 1960er Jahre von John Cocke, Tadao Kasami, Jacob Schwartz und Daniel Younger unabhängig voneinander entwickelte Algorithmus nutzt das Prinzip der dynamischen Programmierung.

Inhaltsverzeichnis

[Bearbeiten] Beschreibung

Als Eingabe erhält der Algorithmus eine kontextfreie Grammatik $G = (N, T, P, S)$ in Chomsky-Normalform und das zu prüfende Wort $w = w_1w_2\ldots w_n \in T^*$ . Nun wird für jedes Teilwort $w_{i,j} := w_i\ldots w_j$ die Menge der Nichtterminale berechnet, die $w i, j$ erzeugen. Dazu bezeichnet $V i, j$ die Menge der Nichtterminale, die $w i, j$ erzeugen.

Gemäß dem Prinzip der dynamischen Programmierung werden erst die $V i, j$ für die kleinsten Teilwörter von $w$ berechnet und damit dann die der größeren effizient berechnet. Die kleinsten Teilwörter sind einzelne Buchstaben. Da die kontextfreie Grammatik in Chomsky-Normalform gegeben ist, kann jeder Buchstabe nur in genau einem Schritt von einem Nichtterminal abgeleitet werden.

Ein Nichtterminal einer Grammatik in Chomsky-Normalform kann in einem Schritt nicht auf mehrere Terminale abgeleitet werden. Daher kann ein Teilwort $w i, j$ , das mehr als nur ein Zeichen enthält, von $A$ nur über eine Regel $(A \rightarrow BC) \in P$ erzeugt werden. Die Nichtterminale können allerdings nicht auf $\varepsilon$ abgebildet werden. Das bedeutet, dass $B$ den linken und $C$ den rechten Teil von $w i, j$ erzeugen muss. Daraus folgt:

$A \in V_{i,j} \Leftrightarrow \exists k \in \mathbb{N}, i \le k \le j - 1: (A \rightarrow BC) \in P \and B \in V_{i,k} \and C \in V_{k + 1, j}$

Mit anderen Worten: $A$ kann $w i, j$ erzeugen, wenn es gemäß der Produktionsregeln auf $B C$ abgeleitet werden kann und $B$ und $C$ wiederum auf $w i, k$ und $w k + 1, j$ abgeleitet werden, also $A \rightarrow BC \rightarrow w_i\ldots w_kC \rightarrow w_i\ldots w_kw_{k+1}\ldots w_j = w_{i,j}$ .

Das Wortproblem kann nun einfach entschieden werden: $w$ kann genau dann von der Grammatik erzeugt werden, wenn $S\in V_{1,n}$ gilt. In $V 1, n$ liegen alle Variablen, die das Teilwort vom ersten bis zum letzten Buchstaben erzeugen kann, also das ganze Wort.

[Bearbeiten] Algorithmus

Aus der Beschreibung ergibt sich folgender Algorithmus:

Für i = 1 ... n
  Für jede Produktion 
    Falls r =  $w i$ 
      Setze 
Für j = 2 ... n
  Für i = j-1 ... 1
    Für k = i ... j - 1
      Für jede Produktion 
        Falls  und 
          Setze 
Falls , stoppe und gib w wird von G erzeugt aus
Stoppe und gib w wird nicht von G erzeugt aus

[Bearbeiten] Beispiel

Die Fragestellung lautet, ob sich das Wort w, $w = b b a b a a$ durch die Grammatik $G = ({S, A, B, C},{a, b}, P, S)$ erzeugen lässt. Die Produktionen $P$ der Grammatik seien:

$S \rightarrow AB \mid BC$

$A \rightarrow BA \mid a$

$B \rightarrow CC \mid b$

$C \rightarrow AB \mid a$

Den Algorithmus kann man mittels einer Tabelle durchführen. Dabei ist in der i-ten Zeile und j-ten Spalte $V i, j$ gespeichert, also die Menge der Nichtterminalsymbole aus denen sich das Teilwort $w_ i \dots w_{j}$ ableiten lässt.

$V i, j$	1	2	3	4	5	6
1	{B}	{}	{A}	{S,C}	{B}	{A,S}
2		{B}	{S,A}	{S,C}	{B}	{A,S}
3			{A,C}	{S,C}	{B}	{S,A}
4				{B}	{A,S}	{}
5					{A,C}	{B}
6						{A,C}

Da $S\in V_{1,6}$ , lässt sich das gegebene Wort w = bbabaa unter der Grammatik G aus S ableiten. Also ist $w$ ein Wort der Sprache $L (G)$ .

[Bearbeiten] Komplexität

Der Algorithmus entscheidet in Zeit $\mathcal{O}(n^3 \cdot \left|P\right|)$ , ob ein Wort der Länge $n$ in der in Chomsky-Normalform gegebenen Sprache $L$ liegt. $\left|P\right|$ bezeichnet hier die Größe der Produktionen. Da die Grammatik in Chomsky-Normalform ist, gilt $\#\mbox{Produktionsregeln} = \Theta(\left|P\right|)$ . Mit $p=\#\mbox{Produktionsregeln}$ ergibt sich eine Zeitkomplexität von $\mathcal{O}(n^3 \cdot p)$ . Dabei wird Speicherplatz in der Größenordnung $\mathcal{O}(n^2 \cdot \left|P\right|) = \mathcal{O}(n^2 \cdot p)$ benötigt.

[Bearbeiten] Literatur

Takao Kasami: An efficient recognition and syntax-analysis algorithm for context-free languages. In: Scientific report AFCRL-65-758. Air Force Cambridge Research Lab, Bedford 1965.
Daniel H. Younger: Recognition and parsing of context-free languages in time $n 3$ . In: Information and Control. 10, Nr. 2, 1967, S. 189–208.
John Cocke, Jacob T. Schwartz: Programming languages and their compilers: Preliminary notes. Courant Institute of Mathematical Sciences of New York University, New York 1970.
Grune, Dick; Jacobs, Ceriel J. H.: Parsing Techniques: A Practical Guide. 1. Auflage. Ellis Horwood, New York 1990, ISBN 0-13-651431-6, S. 81-104 (PDF, 1.9 MB).