Cocke-Younger-Kasami-Algorithmus
# 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 in den 1960er Jahren von Itiroo Sakai, John Cocke, Tadao Kasami, Jacob Schwartz und Daniel Younger unabhängig voneinander entwickelte Algorithmus nutzt das Prinzip der dynamischen Programmierung.

## Beschreibung

Diese Beschreibung folgt Hopcroft/Ullman (1996).

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_{1}w_{2}\ldots w_{n}\in T^{*}$. Nun wird für jedes Teilwort $w_{i,j}:=w_{i}\ldots w_{i+j-1}$ (d. h.: $w_{i,j}$ fängt beim Index $i$ an und hat die Länge $j$) die Menge der Nichtterminale berechnet, die $w_{i,j}$ erzeugen, bezeichnet durch $V_{i,j}$.

Gemäß dem Prinzip der dynamischen Programmierung werden erst die $V_{i,j}$ für die kleinsten Teilwörter von $w$ berechnet, abgespeichert und dann zur somit effizienten Berechnung der nächstgrößeren Teilwörter weiterverwendet. 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. Da Nichtterminale nicht das leere Wort (ε) erzeugen können, muss $B$ den linken und $C$ den rechten Teil von $w_{i,j}$ erzeugen. Daraus folgt:

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

Mit anderen Worten: $A$ kann $w_{i,j}$ erzeugen, wenn es gemäß der Produktionsregeln auf $BC$ abgeleitet werden kann und $B$ und $C$ wiederum auf $w_{i,k}$ und $w_{i+k,j-k}$ abgeleitet werden, also

    $A\Rightarrow BC\Rightarrow ^{*}w_{i}\ldots w_{i+k-1}C\Rightarrow ^{*}w_{i}\ldots w_{i+k-1}w_{i+k}\ldots w_{i+j-1}=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 erzeugen können, das beim ersten Buchstaben anfängt und die Länge $n$ hat, also das ganze Wort.

## Algorithmus

Aus der Beschreibung ergibt sich folgender Algorithmus:

## Beispiel

Die Fragestellung lautet, ob sich das Wort $w=[]$ durch die Grammatik $G=(\{S,T,U,A,B,C,D\},\{(,),[,]\},P,S)$ erzeugen lässt. Die Produktionsregeln $P$ der Grammatik seien:

    $S\rightarrow AB\mid CD\mid AT\mid CU\mid SS$
    $T\rightarrow SB$
    $U\rightarrow SD$
    $A\rightarrow ($
    $B\rightarrow )$
    $C\rightarrow [$
    $D\rightarrow ]$

Den Algorithmus kann man mittels einer Tabelle durchführen. Dabei ist in der $i$-ten Spalte und $j$-ten Zeile $V_{i,j}$ gespeichert, also die Menge der Nichtterminalsymbole, aus denen sich das Teilwort ableiten lässt, das beim Index $i$ anfängt und die Länge $j$ hat.

Es gilt $w_{1}=($, $w_{2}=)$, $w_{3}=[$, $w_{4}=($, $w_{5}=)$, $w_{6}=]$. Aus den Produktionsregeln $A\rightarrow ($, $B\rightarrow )$, $C\rightarrow [$, $D\rightarrow ]$ folgt $V_{1,1}:=\{A\}$, $V_{2,1}:=\{B\}$, $V_{3,1}:=\{C\}$, $V_{4,1}:=\{A\}$, $V_{5,1}:=\{B\}$, $V_{6,1}:=\{D\}$. Das ergibt die erste Zeile der Tabelle:

| $V_{i,j}$ | 1 | 2 | 3 | 4 | 5 | 6 |
| - | - | - | - | - | - | - |
| 1 | {A} | {B} | {C} | {A} | {B} | {D} |

Nun wird für jedes $V_{i,j}$ geprüft, ob es Produktionsregeln der Form $l\rightarrow YZ$ gibt, für die das [Nichtterminalsymbol $Y$ in derselben Spalte der Tabelle oberhalb von $V_{i,j}$ liegt, das Nichtterminalsymbol $Z$ in derselben Diagonalen rechts oberhalb von $V_{i,j}$ liegt und außerdem $Y\in V_{i,k}$ und $Z\in V_{i,k}$ gilt. Aus der Produktionsregel $S\rightarrow AB$ und den Einträgen $A\in V_{1,1}$, $B\in V_{2,1}$, $A\in V_{4,1}$, $B\in V_{5,1}$ der ersten Zeile folgt $V_{1,2}:=\{S\}$, $V_{1,4}:=\{S\}$. Das ergibt die zweite Zeile der Tabelle:

| $V_{i,j}$ | 1 | 2 | 3 | 4 | 5 | 6 |
| - | - | - | - | - | - | - |
| 1 | {A} | {B} | {C} | {A} | {B} | {D} |
| 2 | {S} | | | {S} | | |

Aus den Produktionsregeln $U\rightarrow SD$, $S\rightarrow CU$, $S\rightarrow SS$ und den schon jeweils oberhalb vorhandenen Nichtterminalsymbolen ergeben sich die weiteren Zeilen der Tabelle:

| $V_{i,j}$ | 1 | 2 | 3 | 4 | 5 | 6 |
| - | - | - | - | - | - | - |
| 1 | {A} | {B} | {C} | {A} | {B} | {D} |
| 2 | {S} | | | {S} | | |
| 3 | | | | {U} | | |
| 4 | | | {S} | | | |
| 5 | | | | | | |
| 6 | {S} | | | | | |

Da $S\in V_{1,6}$, lässt sich das gegebene Wort $w=[]$ unter der Grammatik $G$ aus $S$ ableiten.

Eine Linksableitung des Wortes $w$ wäre demnach:

    $S\Rightarrow SS\Rightarrow ABS\Rightarrow (BS\RightarrowS\RightarrowCU\Rightarrow[U\Rightarrow[SD\Rightarrow[ABD\Rightarrow[(BD\Rightarrow[D\Rightarrow[]=w$

Also ist $w$ ein Wort der Sprache $L(G)$.

## Komplexität

Der Cocke-Younger-Kasami-Algorithmus entscheidet in der Zeit ${\mathcal {O}}\left(n^{3}\right)$, ob ein Wort der Länge $n$ in der Sprache $L(G)$ liegt (vgl. Landau-Symbole zur Beschreibung der Notation). Dabei wird Speicherplatz in der Größenordnung ${\mathcal {O}}\left(n^{2}\right)$ benötigt, denn jeder Eintrag $V_{i,j}$ der Tabelle benötigt Speicherplatz der Größenordnung ${\mathcal {O}}\left(1\right)$. Die Effizienz hängt entscheidend vom Algorithmus für die Chomsky-Normalform ab, denn nur dann kann der CYK-Algorithmus verwendet werden.

Es gibt asymptotisch schnellere Algorithmen. Graham, Harrison und Ruzzo geben eine Variante des Earley-Algorithmus an. Er hat eine Laufzeit von ${\mathcal {O}}\left(gn^{3}/\log(n)\right)$. Rytter modifiziert diesen Algorithmus weiter und verbessert die Abhängigkeit von der Wortlänge auf ${\mathcal {O}}\left(n^{3}/\log(n)\right)$. Aber Valiants Parsing-Methode, die die Berechnungen des Cocke-Younger-Kasami-Algorithmus neu organisiert, ist die asymptotisch schnellste bekannte. Die Worst-Case-Laufzeit für eine kontextfreie Grammatik in Chomsky-Normalform ist proporitional zur Laufzeit für die Multiplikation von zwei booleschen $n\times n$-Matrixen. Der schnellste derzeit bekannte Algorithmus für die Matrizenmultiplikation ist eine Variante des Coppersmith-Winograd-Algorithmus, der eine Laufzeit von etwa ${\mathcal {O}}\left(n^{2{,}376}\right)$ hat.

