Commit 7d2d36de authored by Theo von Arx's avatar Theo von Arx

Add Part I & III

Teile I & III von der Zusammenfassung von Andreas Traber kopiert.
Sie sieht ziemlich ählich wie der Vorlesungsstoff aus. Wenn wir Zeit &
Lust haben, können wir diese Teile auch anpasses.

Anpassungen an Inhalt & Form nötig!
parent 5fa130b8
\documentclass[a4paper, landscape, 8pt, german]{scrartcl}
\input{chapters/header.tex}
\title{DES - Zusammenfassung}
\author{Theo von Arx}
\author{Theo von Arx \& René Zurbrügg}
\begin{document}
\begin{multicols*}{3}
\maketitle
% Part I
\input{chapters/automaten_sprachen.tex}
\input{chapters/inelligenteAutomaten.tex}
\newpage
% Part II
\input{chapters/queueing.tex}
\newpage
\input{chapters/online.tex} \vfill \null \columnbreak
\input{chapters/onlineAlg.tex}
\newpage
% Part II
\input{chapters/specificationModels.tex}
% Appendix
\vfill \null \columnbreak
\appendix
......
%! TEX root = DES.tex
\section{Automaten \& Sprachen}
\subsection{Alphabete und Strings}
\textbf{Alphabet} $\Sigma$: Eine Menge von Symbolen (Zeichen, Buchstaben) \\
\textbf{String} von $\Sigma$: Eine Sequenz von Symbolen. $|.|$ bezeichnet die Länge eines Strings. \\
Der leere String $\varepsilon$ hat die Länge $|\varepsilon| = 0$.
\subsection{Deterministic Finite Automaton (DFA)}
Ein finiter Automat (FA) ist ein 5-tuple ($Q, \Sigma, \delta, q_0, F$) mit
\begin{itemize}
\item $Q$ ist eine endliche Menge genannt Zustände
\item $\Sigma$ ist eine endliche Menge genannt Alphabet
\item $\delta: Q \times E \to Q$ ist die Transfer Funktion
\item $q_0 \in Q$ ist der Start Zustand
\item $F \subseteq Q$ ist die Menge der akzeptierenden Zustände (final states)
\end{itemize}
Der DFA liest den Inputstring von links nach rechts und wechselt bei jedem Symbol den Zustand. Falls der DFA am Ende des Inputstrings in einem akzeptierenden Zustand ist, so wird der String akzeptiert.
\begin{fdef}
Ein String $u$ wird akzeptiert von einem Automaten M genau dann, wenn der Pfad, der in $q_0$ startet, mit $u$ angeschrieben ist und $u$ in einem akzeptierenden Zustand endet.
\end{fdef}
\subsection{Sprachen}
\begin{fdef}
Die Sprache, die von einem DFA $M$ akzeptiert wird, ist die Menge aller Strings, die vom DFA $M$ akzeptiert werden. Die Sprache wird durch $L(M)$ angegeben. Wir sagen auch, dass $M$ $L(M)$ erkennt oder dass $M$ $L(M)$ akzeptiert.
\end{fdef}
\\
Eine Sprache wird eine \textbf{reguläre Sprache} gennant, falls ein DFA $M$ existiert, der die Sprache $L$ erkennt.
\begin{ftext}
Theorem: Alle endlichen Sprachen ($|L(M)|$ ist endlich) sind regulär.
\end{ftext} \\
Die leere Sprache $\emptyset$ akzeptiert keinen String (auch nicht $\varepsilon$).
\subsection{Regular operations}
Wenn reguläre Operationen auf reguläre Sprachen angewandt werden, so entstehen wieder reguläre Sprachen. Reguläre Sprachen sind geschlossen unter den Operationen Union, Concatenation, Kleene-$^\star$ und Kleene-$^+$.
\subsubsection{Union}
$A \cup B$ bedeutet, dass der String akzeptiert wird, falls $A$ oder $B$ den String akzeptieren.
\subsubsection{Concatenation}
$A \cdot B$ bedeutet, dass der erste Teil des Strings von $A$ akzeptiert werden muss und der zweite Teil von $B$. Die Trennung ist dabei beliebig. \\
Es gilt: $L \cdot \{\varepsilon \} = L$ \\
$L \cdot \emptyset = \emptyset$
\subsubsection{Kleene-$^\star$}
$A^{\star}$ heisst, dass $A$ beliebig oft (auch 0 mal) wiederholt werden kann. Falls $A$ 0 mal wiederholt wird, so entspricht dies $\varepsilon$.
\subsubsection{Kleene-$^+$}
Sehr ähnlich zu Kleene-$^\star$, jedoch muss $A$ mindestens einmal vorkommen. Man kann dies darstellen als $A^+ = A \cdot A^\star$
\subsection{Kartesisches Produkt}
Das kartesische Produkt $A \times B$ von zwei Mengen $A$ und $B$ ist die Menge aller geordneten Paare $(a, b)$ mit $a \in A$ und $b \in B$. (alle Kombinationen von $A$ und $b$)
Gegeben seien zwei zwei DFAs $M_1 = (Q_1, \Sigma, \delta_1, q_1, F_1)$ und $M_2 = (Q_2, \Sigma, \delta_2, q_2, F_2)$. Diese können nun unter verschiedenen Operationen zusammengefügt werden:
\begin{itemize}
\item Vereinigung ($A \cup B$): Entweder $M_1$ oder $M_2$ müssen akzeptierend sein: \\ $M_\cup = (Q_1 \times Q_2, \Sigma, \delta_1 \times \delta_2, (q_1, q_2), F_\cup)$ mit $F_\cup = Q_1 \times F_2 \cup F_1 \times Q_2$
\item Schnitt ($A \cap B$): Beide müssen akzeptierend sein: \\
$M_\cap = (Q_1 \times Q_2, \Sigma, \delta_1 \times \delta_2, (q_{0,1}, q_{0,2}), F_\cap)$ mit $F_\cap = F_1 \times F_2$
\item Differenz ($A - B = \{ x \in A \, | \, x \notin B \}$): Akzeptiere, wenn $A$ akzeptiert aber $B$ nicht: \\
$M_{-} = (Q_1 \times Q_2, \Sigma, \delta_1 \times \delta_2, (q_{0,1}, q_{0,2}), F_{-})$ mit $F_{-} = F_1 \times Q_2 - Q_1 \times F_2$
\item Symmetrische Differenz ($A \oplus B = A \cup B - A \cap B$): Akzeptiere, wenn genau ein Automat akzeptiert: \\
$M_{\oplus} = (Q_1 \times Q_2, \Sigma, \delta_1 \times \delta_2, (q_{0,1}, q_{0,2}), F_\oplus)$ mit $F_\oplus = F_\cup - F_\cap$
\item Komplement ($\overline{L}$): Vertausche die akzeptierenden mit den nicht akzeptierenden Zuständen.
\end{itemize}
\subsection{Nondeterministic Finite Automaton (NFA)}
Ein nicht deterministischer enlicher Automat (NFA) ist gegeben durch $M = (Q, \Sigma, \delta, q_0, F)$, genau gleich wie ein FA, jedoch hat $\delta$ eine andere Definition
\[
\delta: Q \times \Sigma_\varepsilon \to P(Q)
\]
$P(Q)$ bezeichnet die Potenzmenge (die Menge aller Teilmengen von $Q$). \\
$\Sigma_\varepsilon = \Sigma \cup \{ \varepsilon \}$
\begin{fdef}
Ein String $u$ wird vom NFA $M$ akzeptiert genau dann, wenn ein Pfad existiert, der bei $q_0$ startet, mit dem Label $u$ angeschrieben ist und in einem akzeptierenden Zustand endet. Die von $M$ akzeptierte Sprache wird mit $L(M)$ bezeichnet.
\end{fdef}
\\
Einem Label $\varepsilon$ zu folgen ist gratis, es wird nicht vom Input gelesen. Im Label des Pfades sollten alle $\varepsilon$ entfernt werden.
\subsubsection{Reguläre Operationen für NFAs}
Im folgenden Bild bezeichnet der Block einen NFA, wobei die hellgraue Fläche die nicht akzeptierenden Zustände darstellt, die (dunkelgraue/)grüne Fläche die akzeptierenden. Der rote Punkt steht für den Startzustand.
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/nfa-block}
\end{figure}
\begin{itemize}
\item Union
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/nfa-union}
\end{figure}
\item Concatenation
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/nfa-concatenation}
\end{figure}
\item Kleene-$^+$
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/nfa-kleeneplus}
\end{figure}
\item Kleene-$^\star$
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/nfa-kleenestar}
\end{figure}
\end{itemize}
\begin{ftext}
Theorem: Wenn $L_1$ und $L_2$ von NFAs akzeptiert werden, so werden auch $L_1 \cup L_2, L_1 \cdot L_2, L_1^+$ und $L_1^\star$ von einem NFA akzeptiert. Diese NFAs können in linearer Zeit konstruiert werden.
\end{ftext}
\subsection{Reguläre Ausdrücke (REX)}
\begin{figure}[H]
\centering
\includegraphics[width=\columnwidth]{fig/rex-table}
\end{figure}
Es gilt die Operatorrangfolge: $^\star, \cdot, \cup$
\\
Es gilt speziell: \\
$L(\varepsilon) = \{ \varepsilon \}$ \\
$L(\emptyset) = \{ \} = \emptyset$ und $1^\star \emptyset = \emptyset$
\subsection{REX $\to$ NFA}
\begin{ftext}
Theorem: Für jeden regulären Ausdruck $r$ gibt es einen NFA $N$, der $r$ simuliert. Das heisst, die Sprache von $N$ ist genau die Sprache, die von $r$ generiert wird, so dass $L(N) = L(r)$. Der NFA lässt sich ausserem in linearer Zeit konstruieren.
\end{ftext}
\\
Aus den folgenden 3 Basisoperationen und den Operationen Union, Concatenation, Kleene-$^\star$ und Kleene-$^+$ lassen sich alle regulären Sprachen zusammenbauen.
\begin{figure}[H]
\centering
\begin{subfigure}[b]{0.3\textwidth}
\centering
\includegraphics[scale=0.4]{fig/rex-nfa-a}
\caption*{$a \in \Sigma$}
\end{subfigure}
\begin{subfigure}[b]{0.3\textwidth}
\centering
\includegraphics[scale=0.4]{fig/rex-nfa-epsilon}
\caption*{$\varepsilon$}
\end{subfigure}
\begin{subfigure}[b]{0.3\textwidth}
\centering
\includegraphics[scale=0.4]{fig/rex-nfa-empty}
\caption*{$\emptyset$}
\end{subfigure}
\end{figure}
Es folgt, dass alle Sprachen, die von einem NFA akzeptiert werden, regulär sind.
\subsection{NFA $\to$ FA}
\begin{itemize}
\item Anstelle der $n$ Zustände des NFA betrachten wir die Potenzmenge der Zustände im FA. \\
$\Rightarrow$ FA hat $2^n$ Zustände.
\item Zuerst finden wir heraus, welche Zustandsmenge von welchen Zustandsmengen erreicht werden. (mit den Regeln des NFA)
\item Dann müssen alle Epsilon-Kanten eingefügt werden. Wir biegen Pfeile von $\{a, b, c \}$ um nach $\{ a, b, c, d, e, f \}$ genau dann, wenn es einen Nur-Epsilon-Pfad gibt, der von einem der Zustände $a, b, c$ zu den Zuständen $d, e, f$ zeigt. \\
Das gleiche machen wir auch mit dem Startzustand. Falls z.B. im NFA der Startzustand $1$ ist und wir eine Epsilon-Kante von 1 nach 2 haben, so ist der Startzustand im FA $\{1, 2\}$.
\item Die akzeptierenden Zustände im FA sind alle diejenigen Zustände, die einen akzeptierenden Zustand enthalten.
\end{itemize}
Manchmal gibt es offensichtliche Vereinfachungen für den resultierenden FA, da dieses Rezept meist einen komplexeren FA generiert, als notwendig wäre. Ansonsten kann der Automat auch später noch vereinfacht werden.
\\
\begin{bsp}
\hspace*{0pt}\\
\includegraphics[width=0.9\columnwidth]{fig/nfa-fa-bsp}
\end{bsp}
\begin{ftext}
Theorem: Falls $L$ eine von einem NFA akzeptierte Sprache ist, so existiert ein konstruierbarer DFA, der die Sprache $L$ akzeptiert.
\end{ftext}
\subsection{NFA $\to$ REX}
Um aus einem NFA eine REX zu bekommen, machen wir einen Umweg über GNFA (generalized nondeterministic finite automaton). \\
Ein GNFA ist ein Graph, dessen Kanten mit regulären Ausdrücken beschriftet sind:
\begin{itemize}
\item Der Startzustand muss eindeutig sein mit einem In-Grad von 0, aber Kanten zu allen anderen Zuständen.
\item Der Endzustand muss eindeutig sein mit einem Aus-Grad von 0, aber Kanten von allen anderen Zuständen. (Anfangszustand $\neq$ Endzustand)
\item Alle anderen Zustände dürfen eingehende und ausgehende Kanten von allen Zuständen haben, sogar zu sich selbst.
\end{itemize}
Nun muss der GNFA vereinfacht werden, bis nur noch zwei Zustände (Anfangs- und Endzustand) übrig bleiben. Die REX kann dann direkt von dem einzig verbliebenen Label abgelesen werden.
\subsubsection{Vorgehen}
\begin{enumerate}
\item Konstruiere GNFA aus einem FA
\begin{enumerate}
\item Falls mehr als ein Pfeil von einem Zustand zu einem anderen Zustand existieren, vereinige diese mit $\cup$
\item Erstelle einen eindeutigen Startzustand mit In-Grad 0.
\item Erstelle einen eindeutigen Endzustand mit Aus-Grad 0.
\end{enumerate}
\item Wiederhole: So lange der GNFA mehr als 2 Zustände hat:
Entferne beliebige innere Zustände und passe die Labels entsprechend an.
\item Die REX ist das verbliebene Label
\end{enumerate}
\paragraph*{Innere Zustände entfernen} \hspace*{0pt}\\
Wir entfernen den Zustand $v$.
\begin{figure}[H]
\centering
\includegraphics[scale=0.4]{fig/gnfa-1}
\end{figure}
Damit keine Möglichkeiten verloren gehen, müssen wir die REX von u nach w anpassen
\begin{figure}[H]
\centering
\includegraphics[scale=0.4]{fig/gnfa-2}
\end{figure}
\subsection{Vereinfachung}
\begin{fdef}
Ein Automat ist nicht weiter reduzierbar falls
\begin{itemize}
\item er keinen nutzlosen Zustand enthält und
\item keine zwei Zustände äquivalent sind
\end{itemize}
\end{fdef}
\subsection{Pumping Lemma}
\begin{ftext}
Pigeonhole Principle: Wenn $m$ Tauben auf $n < m$ Taubenschläge verteilt werden müssen, so muss in mindestens einem Taubenschlag mehr als eine Taube sein.
\end{ftext}
\\
Wir betrachten eine Sprache $L$ mit Strings $w \in L$ und einen FA mit $n < |w|$ Zuständen. Nach dem Pigeonhole principle muss der FA mindestens einen Zustand mehrfach besuchen, um $L$ zu akzeptieren. Das bedeutet, dass reguläre Sprachen mit unbegrenzt langen Strings nur dann von einem FA akzeptiert werden können, falls diese Strings sich irgendwo wiederholen.
\begin{ftext}
Theorem: Gegeben eine reguläre Sprache $L$, dann existiert eine Zahl $p$ (die Pumping Zahl), so dass alle Strings in $L$ mit Länge $\geq p$ pumpbar sind innerhalb ihrer ersten $p$ Buchstaben.
\end{ftext}
\\
In anderen Worten: Für alle $u \in L$ mit $|u| \geq p$ muss gelten:
\begin{itemize}
\item $u = x \, y \, z$ \hspace{100pt} x ist ein Prefix, z ist ein Suffix
\item $|y| \geq 1$ \hspace{110pt} mittlerer Teil $y$ ist nicht leer
\item $|x y | \leq p$ \hspace{105pt} Pumpen erfolgt in den ersten $p$ Buchstaben
\item $x y^i z \in L$ für alle $i \geq 0$ \hspace{40pt} wir können y pumpen. $i$ darf 0 sein.
\end{itemize}
Falls kein solches $p$ existiert, so ist die Sprache nicht regulär.
\\
Um zu beweisen, dass eine Sprache nicht regulär ist, muss man zeigen, dass für alle Wahlmöglichkeiten $y$ die es gibt, keine die genannten Eigenschaften erfüllt.
TODO: Hier noch mehr zum Vorgehen einfügen. Siehe dazu Sipser Buch
\subsubsection{Beweis von nicht Regularität}
Die folgende Argumentation basiert auf der Geschlossenheit der regulären Sprachen und Operatoren, sie funktioniert nur in diese Richtung. \\
Es gilt: Für einen Operator $\diamond \in \{ \cup, \cap, \cdot \}$ gilt
\[
\text{Falls $L_1$ und $L_2$ regulär sind, so ist auch $L_1 \diamond L_2$ regulär}
\]
Falls entweder $L_1$ oder $L_2$ oder beide nicht regulär sind, so können wir nicht auf die nicht Regularität von $L$ schliessen oder umgekehrt. \\
Ebenso, dass $L$ regulär ist, bedeutet nicht, dass $L_1$ und $L_2$ auch regulär sind.
%! TEX root = DES.tex
\section{Intelligentere Automaten}
\subsection{Kontext-freie Grammatik (CFG)}
Definition: Eine kontext-freie Grammatik besteht aus dem 4-Tupel $(V, \Sigma, R, S)$ mit
\begin{itemize}
\item $V$: Einer endlichen Menge von Variablen
\item $\Sigma$: Einer endlichen Menge von Terminals (oder dem Alphabet). Terminals dürfen nicht in $V$ vorkommen.
\item $R$: Einer endlichen Menge von Regel (oder Produktionen) der Form \\
$v \to w$ mit $v \in V$ und $w \in (\Sigma_\varepsilon \cup V)^*$
\item $S \in V$: Dem Start Symbol. Falls nicht explizit angegeben ist das Startsymbol dasjenige in der ersten Regel links.
\end{itemize}
Defintion: Das Ableitungssymbol ''$\Rightarrow$'' steht für eine Beziehung zwischen Strings in $(\Sigma \cup V)^*$. Wir schreiben $x \Rightarrow y$ falls $x$ und $y$ aufgeteilt werden können in $x = sAt$ und $y = sWt$ und $v \to w$ eine Regel in $R$ ist.
\\
Definition: Das Ableitungssymbol ''$\Rightarrow^*$'' steht für eine Beziehung zwischen Strings in $(\Sigma \cup V)^*$. Wir schreiben $x \Rightarrow^* y$ falls eine Sequenz von Regeln existiert die $x$ in $y$ überführt. Das bedeutet $x_0 \Rightarrow x_1, x_1 \Rightarrow x_2, \ldots, x_{n-1} \Rightarrow x_n = y$.
\\
Definition: Sei $G$ eine kontext-freie Grammatik. Die kontext-freie Sprache (CFL) die von G generiert wird ist die Menge aller Terminal-Strings, die vom Startsymbol abgeleitet werden können.\\
Man schreibt: $L(G) = \{w \in \Sigma^* \, | \, S \Rightarrow^* w \}$
\\
\subsubsection{Ableitungsbäume}
Ein einem Ableitungsbaum (oder Parsebaum) entspricht jedem Konten ein Symbol. Jeder Elternknoten ist ein Symbol, wobei nach den Regeln der CFG weitere Knoten unterhalb angefügt werden. \\
Beispiel für $v \to abcdefg$
\begin{figure}[H]
\centering
\includegraphics[scale=0.35]{fig/cfg-tree}
\end{figure}
Der Stamm ist immer die Startvariable. \\
Die Blätter werden aus dem String von links nach rechts abgeleitet. (Die Variable am meisten links zuerst auswerten.)
\subsubsection{Mehrdeutigkeit}
Es gibt mehrere Möglichkeiten eine Regel einer CFG auszuwerten. Die bekanntesten sind \textbf{Left-most derivation}, wo zuerst das Symbol am meisten links ersetzt wird und \textbf{Right-most derivation}, wo zuerst das Symbol am meisten rechts ersetzt wird. \\
Diese unterschiedlichen Ansätze könne zu komplett unterschiedlichen Terminalstrings führen.
\\
Definition: Einen String $x$ nennt man mehrdeutig, falls es zwei komplett verschiedene Wege gibt $x$ in G abzuleiten. Eine Grammatik nennt man mehrdeutig, falls es einen String $x$ in $L(G)$ gibt der mehrdeutig ist.
\subsection{Prüfen ob $L = L(G)$}
Sei $G$ eine CFG und $L$ eine Sprache. Um zu zeigen, dass $L(G) = L$ gilt, muss folgendes gelten
\begin{itemize}
\item $L \subseteq L(G)$: Jeder String in $L$ kann generiert werden durch $G$.
\item $L \supseteq L(G)$: $G$ generiert nur Strings von $L$.
\end{itemize}
TODO: Evtl hier noch ein Beispiel anfügen
\subsection{Designen von kontext-freie Grammatik}
\begin{itemize}
\item Falls die CFG ein Union von einfacheren Grammatiken ist, so kann man $S \to S_1 | S_2$ verwenden, wobei $S_1$ bzw. $S_2$ die Startsymbole der einfacheren Grammatiken sind.
\item Falls die CFG regulär ist, so kann man zuerst den DFA designen und dann auf die CFG zurückführen.
\begin{itemize}
\item Jeder Zustand wird zu einer Variable.( $q_i$ wird zu $V_i$)
\item Erstellen der Regel $R_i \to a R_j$ falls $\delta(q_i, a) = q_j$
\item Für akzeptierende Zustände erstellen wir die Regel $R_i \to \varepsilon$.
\item Für den Startzustand ist $S = q_0$
\end{itemize}
\end{itemize}
\subsection{Push-down Automaten (PDA)}
PDAs sind Automaten, die CFGs realiseren können. Die Beschreibung durch eine CFG und einen PDA sind äquivalent. Der PDA erhält im Gegensatz zu den DFA/NFA noch einen Stack auf dem folgende Basisoperationen möglich sind
\begin{itemize}
\item \textbf{Push}: Ein neues Element zuoberst auf den Stack legen ($\varepsilon \to a$)
\item \textbf{Pop}: Das oberste Element vom Stack entfernen ($a \to \varepsilon$)
\item \textbf{Peek}: Das oberste Element überprüfen, ohne es zu entfernen
\end{itemize}
Um den leeren Stack zu erkennen wird oft ein spezielles Symbol als erstes auf den Stack gepusht ($\varepsilon \to \$$), das am Ende wieder entfernt wird ($\$ \to \varepsilon$).
\\
\begin{bsp}
\hspace*{0pt}\\
\includegraphics[width=0.9\columnwidth]{fig/cfg-pda-bsp}
\end{bsp}
\subsubsection{Formale Definition eines PDA}
Ein Push-down Automat (PDA) ist ein 6-Tuple $ M = (Q, \Sigma, \Gamma, \delta, q_0, F)$:
\begin{itemize}
\item $Q, \Sigma, q_0$ und $F$ sind definiert wie bei einem DFA
\item $\Gamma$ ist das Stack Alphabet
\item $\delta$ ist die Übergangsfunktion, bestimmt durch den aktuellen Zustand $p$, den nächsten Input $x$ und das oberste Symbol auf dem Stack $y$. $\delta(p, x, y)$ gibt uns alle $(q, z)$, wobei $q$ der nächste Zustand und $z$ das neue Symbol auf dem Stack ist.
\[
\delta: Q \times \Sigma_\varepsilon \times \Gamma_\varepsilon \to P(Q \times \Gamma_\varepsilon)
\]
\end{itemize}
\subsection{Rechtslineare Grammatiken}
\begin{fdef}
Eine rechtslineare Grammatik ist eine CFG, so dass alle Regeln die Form $A \to u B$ oder $A \to u$ haben, wobei $u$ ein Terminalstring und $A, B$ Variablen sind
\end{fdef}
\begin{ftext}
Theorem: Wenn $M = (Q, \Sigma, \delta, q_0, F)$ ein NFA ist, dann gibt es eine rechtslineare Grammatik $G(M)$, die die gleiche Sprache wie $M$ generiert.
\end{ftext}
\\
Natürlich können nicht alle CFGs in eine rechtslineare Grammatik konvertiert werden, denn das würde bdeuten, das CFGs regulär sind.
\subsection{Chomsky Normal Form (CNF)}
Die CNF ist eine simpler Type einer CFG, wobei alle kontext-freien Sprachen in die Chomsky Normal Form gebracht werden können.
\begin{fdef}
Eine CFG ist in der Chomsky Normal Form, wenn alle Regeln der Grammatik die folgende Form haben:
\begin{itemize}
\item $S \to \varepsilon$
\item $A \to BC$
\item $A \to a$
\end{itemize}
Wobei $S$ die Startvariable ist.
\end{fdef}
\subsubsection{CFG $\to$ CNF}
Um eine allgemeine Grammatik in die Chomsky Normal Form zu bringen kann man wie folgt vorgehen:
\begin{enumerate}
\item Die Startvariable darf nur auf der linken Seite stehen. (evtl. eine neue Variable einführen)
\item Entferne alle $\varepsilon$ Regeln, ausser von der Startvariable.
\item Entferne alle Übergange der Form $A \to B$, wenn $A$ und $B$ Variablen sind
\item Modifiziere die verbleibenden Regeln bis sie der CNF entsprechen
\end{enumerate}
\subsubsection{CFG $\to$ GPDA $\to$ PDA}
Alle CFGs können in PDAs umgewandelt werden. Wir betrachten generalisierte PDAs, um uns die Arbeit zu erleichtern.
\\
Ein Generalisierter PDA (GPDA) ist wie ein PDA, ausser das das oberste Stack Symbol durch einen ganzen String ersetzt werden kann und nicht nur durch ein einzelnes Symbol oder $\varepsilon$. Um vom GPDA zurück zu einem PDA zu kommen, müssen die String-Pushes nur noch durch einzelne einfache Pushes ersetzt werden.
\\
Vorgehen:
\begin{enumerate}
\item Push das Markierungssymbol $\$$ und das Startsymbol auf den Stack.
\item Wiederhole folgende Schritte beliebig oft:
\begin{enumerate}
\item Falls auf dem Stack zuoberst ein Variablen Symbol $A$ liegt, wähle nondeterministisch eine Regel von $A$ aus und ersetzt $A$ durch den String auf der rechten Seite der Regel.
\item Falls auf dem Stack zuoberst ein Terminalsymbol $a$ liegt, dann lies das nächste Symbol vom Input und vergleiche die beiden.\\
Falls sie gleich sind, mache weiter. Falls sie nicht gleich sind, verwerfe diesen Ausführungszweig.
\item Falls auf dem Stack zuoberst das Markierungssymbol $\$$ liegt, gehe in den akzeptierenden Zustand.\\
Falls der Input noch nicht fertig ist, so wir der PDA diesen Ausführungszweig trotzdem verwerfen.
\end{enumerate}
\end{enumerate}
\subsubsection{PDA $\to$ CFG}
\begin{ftext}
Theorem: Für jeden PDA gibt es eine CFG, die die gleiche Sprache akzeptiert
\end{ftext}
\\
Korollar: PDA $\approx$ CFG
\subsection{Kontext-sensitive Grammatiken}
Es existiert eine noch allgemeinere Form von Grammatiken. Im Allgemeinen ist eine nicht kontext-freie Grammatik eine Grammatik die auf der linken Seite einer Regel nicht nur eine Variable zulässt, sondern auch mehrere Variablen und Variablen gemischt mit Terminalsubstrings.
\\
\begin{bsp}
\hspace*{0pt}\\
\includegraphics[scale=0.34]{fig/cfg-csg-bsp}
\end{bsp}
\textbf{Kontext-sensitive Grammatiken} werden nicht kontext-freie Grammatiken genannt, deren Länge der linken Seite $\leq$ Länge der rechten Seite.
\subsection{Tandem Pumping}
Analog zu regulären Sprachen gibt es ein Pumping Lemma für kontext-freie Sprachen. Die Idee ist, dass man kontext-freie Sprachen an zwei Stellen Pumpen kann. (aber nicht an mehr als zwei Stellen)
\\
\begin{ftext}
Theorem: Sei $L$ eine kontext-freie Sprache, dann gibt es eine Zahl $p$ (die Tandem-Pumping Zahl), so dass alle Strings in L mit Länge $\geq p$ tandem-pumpbar innerhalb eines Substrings mit $p$ Buchstaben ist.
\end{ftext}
\\
In anderen Wort: Für alle $w \in L$ mit $|w| \geq p$ muss gelten:
\begin{itemize}
\item $w = u v x y z$
\item $|v y| \geq 1$ \hspace{140pt} pumpbare Bereiche sind nicht leer
\item $|v x y| \leq p$ \hspace{133pt} Pumpen innerhalb eines Bereichs von $p$ Buchstaben
\item $u v^i x y^i z \in L$ für alle $i \geq 0$ \hspace{60pt} Tandem-pumpen von $v$ und $y$.
\end{itemize}
Falls keine solche Zahl $p$ existiert, so ist die Sprache nicht kontext-frei.
\subsection{Transducers}
\begin{fdef}
Ein endlicher Zustands-Transducer (FST) ist ein Type eines endliche Automaten, dessen Output ein String und nicht nur Akzeptieren oder Ablehnen ist.
\end{fdef}
\\
Bei einem Transducer werden jedem Übergang zwei Symbole angeschrieben, das erste für den Input und das zweite für den Output. ($\varepsilon$ als Output bedeutet, das nichts ausgegeben werden soll)
\\
\begin{bsp}
\hspace*{0pt}\\
\includegraphics[scale=0.5]{fig/cfg-transducers}
\end{bsp}
\subsection{Touring Maschine (TM)}
Eine Touring Maschine ist ein Gerät mit einer endlichen Anzahl read-only Memory (Zustände) und einem unbegrenzten Anzahl read/write Tape-Memory. Es gibt keinen seperaten Input, der Input befindet sich auf dem Tape, wenn die TM startet.
\\
Definition: Eine Touring Maschine (TM) ist ein 7-Tuple $M = (Q, \Sigma, \Gamma, \delta, q_0, q_{acc}, q_{rej})$.
\begin{itemize}
\item $Q, \Sigma$ und $q_0$ sind gleich wie bei einem FA.
\item $q_{acc}$ und $q_{rej}$ sind die akzeptierenden und ablehnenden Zustände.
\item $\Gamma$ ist das Tape Alphabet, das notwendigerweise das leere Symbol $\cdot$ enthält, als auch das Input Alphabet $\Sigma$
\item $\delta$ ist wie folgt
\[
\delta: (Q - \{q_{acc}, q_{rej} \} ) \times \Gamma \to Q \times \Gamma \times \{L, R \}
\]
\item Bei einem nicht haltenden Zustand $p$, einem Tape Symbol $x$, so meint $\delta(p, x) = (q, y, D)$, dass die TM in den Zustand $q$ übergeht, $x$ durch $y$ ersetzt und der Tape Kopf sich in die Richtung $D$ (links oder recht) bewegt.
\end{itemize}
Ein String $x$ ist akzeptiert von $M$, wenn, nachdem $x$ auf das Tape geschrieben wurde und der Tape Kopf der TM auf die Position am weitesten links gesetzt und die TM laufen gelassen wurde, M schlussendlich den akzeptierenden Zustand erreicht.
\subsection{Decidability?, Halting-Problem?}
%! TEX root = DES.tex
\section{Specification Models}
\subsection{State Charts}
In einem endlichen Automaten läuft immer genau ein Prozess sequentiell ab, es gibt keine Parallelität. Ausserdem gibt es keinerlei hierarchische Strukturen.\\
State Charts beheben diese Probleme indem sie Super-States einführen, deren Zustände selbst wieder Super-States sein können. Zustände, die nicht aus anderen Zuständen zusammengesetzt sind (keine Super-states), nennt man Basis-Zustände.
\begin{figure}[H]
\centering
\includegraphics[width=\columnwidth]{fig/state-super}
\end{figure}
\paragraph*{OR-Super-State}
Ein Super-State wird OR-Super-State genannt, wenn genau ein Sub-State aktiv ist, wenn S aktiv ist.
\paragraph*{AND-Super-State}
Ein Super-State wird AND-Super-State genannt, wenn alle direkten Sub-States aktiv sind, wenn S aktiv ist.
\begin{figure}[H]
\centering
\begin{subfigure}[b]{0.3\textwidth}
\centering
\includegraphics[scale=0.8]{fig/state-or-super}
\caption*{OR-super-state}
\end{subfigure}
\begin{subfigure}[b]{0.3\textwidth}
\centering
\includegraphics[scale=0.8]{fig/state-and-super}
\caption*{AND-super-state}
\end{subfigure}
\end{figure}
\paragraph*{Event}
Ein Event kann entweder intern (vom State Chart) oder extern generiert werden. Es können Events kombiniert werden wie (E1 and E2), (E1 or E2) oder (not E).
\paragraph*{Condition}
Eine Bedingung bezieht sich auf den Wert von Variablen. Bedingungen können wie Events kombiniert werden.
\paragraph*{Zustandsübergang}
Der Übergang ist aktiv, wenn der Event existiert und die Bedingung erfüllt ist
\paragraph*{Reaction / Aktion}
Beim Zustandsübergang können Variablen neue Werte zugewiesen oder Events generiert werden. Reaktionen können sequentiell ausgeführt werden mit (A1; A2).
\begin{figure}[H]
\centering
\includegraphics[scale=0.4]{fig/state-events}
\end{figure}
Alle Events, Zustände und Aktionen sind global sichtbar.
\subsubsection{Simulation}
State Charts werden in drei Phasen simuliert:
\begin{enumerate}
\item Auswirkungen von Veränderungen der Events und Bedingungen werden ausgewertet.
\item Die Menge der Zustandsübergänge, die in diesem Schritt gemacht werden müssen und die rechte Seite von Zuweisungen wird berechnet.
\item Übergänge werden durchgeführt, Variablen erhalten ihren neuen Wert.
\end{enumerate}