mirror of
https://github.com/janishutz/eth-summaries.git
synced 2026-01-13 02:38:25 +00:00
[TI] Cleaner structure
This commit is contained in:
148
semester3/ti/main/parts/02_finite-automata/00_representation.tex
Normal file
148
semester3/ti/main/parts/02_finite-automata/00_representation.tex
Normal file
@@ -0,0 +1,148 @@
|
||||
\subsection{Darstellung}
|
||||
Folgende Fragen müssen zur Definition eines Berechnungsmodells beantwortet werden:
|
||||
\begin{enumerate}
|
||||
\item Welche elementaren Operationen stehen zur Verfügung (um das Programm zusammenzustellen)?
|
||||
\item Wie funktioniert der Speicher?
|
||||
\item Wie funktioniert die Eingabe (und welches Alphabet verwendet sie)?
|
||||
\item Wie funktioniert die Ausgabe (und welches Alphabet verwendet sie)?
|
||||
\end{enumerate}
|
||||
Endliche Automaten haben keinen Speicher, mit Ausnahme des Zeigers (can be understood similarly to a program counter)
|
||||
|
||||
Ein endlicher Automat mit dem Eingabealphabet $\Sigma = \{ a_1, \ldots, a_k \}$ darf nur den Operationstyp \texttt{select} verwenden.
|
||||
\begin{align*}
|
||||
\texttt{select } input & = a_1 \texttt{ goto } i_1 \\[-0.2cm]
|
||||
\vdots \\
|
||||
input & = a_k \texttt{ goto } i_k
|
||||
\end{align*}
|
||||
Alternativ, falls $|\Sigma| = 2$ (typischerweise für $\alphabets{bool}$), kann man statt \texttt{select} auch \texttt{if\dots then\dots else} nutzen.
|
||||
Typischerweise werden solche Programme für Entscheidungsprobleme genutzt und die Checks sind dann:
|
||||
\begin{align*}
|
||||
\texttt{if } input = 1 \texttt{ then goto } i \texttt{ else goto } j
|
||||
\end{align*}
|
||||
Wir wählen eine Teilmenge $F \subseteq \{ 0, \ldots, m - 1 \}$, wobei $m$ die Anzahl Zeilen des Programms ist.
|
||||
Ist die Zeile auf der das Programm endet ein Element von $F$, so akzeptiert das Programm die Eingabe.
|
||||
Die Menge $F$ wird auch die \bi{vom Programm akzeptierte Sprache} genannt
|
||||
%
|
||||
Ein Programm $A$ arbeitet dann Buchstabe für Buchstabe das Eingabewort ab und springt so also kontinuierlich durch das Programm bis die Eingabe endet.
|
||||
Mit formaleren Begriffen ist das Eingabewort als \bi{Band} dargestellt, welches von einem \bi{Lesekopf}, der sich nur nach links oder rechts bewegen kann gelesen wird und die gelesene Eingabe dann dem \bi{Programm} weitergibt.
|
||||
|
||||
Diese Notation wird jedoch heute kaum mehr verwendet (because \texttt{goto} bad, Prof. Roscoe would approve).
|
||||
Heute verwendet man meist einen gerichteten Graphen $G(A)$:
|
||||
\begin{itemize}
|
||||
\item Hat so viele Knoten (= \bi{Zustände}) wie das Programm $A$ Zeilen hat
|
||||
\item Wenn das Programm beim Lesen von Symbol $b$ von Zeile $i$ auf $j$ sprint, so gibt es in $G(A)$ eine gerichtete Kante $(i, j)$ von Knoten $i$ nach Knoten $j$ mit Markierung $b$. Sie wird als \bi{Übergangsfunktion} bezeichnet
|
||||
\item Jeder Knoten hat den Ausgangsgrad $|\Sigma|$ (wir müssen alle Fälle abdecken)
|
||||
\end{itemize}
|
||||
|
||||
% TODO: Clean up (make it look less crowded)
|
||||
\begin{definition}[]{Endlicher Automat}
|
||||
Ist eine Quitupel $M = (Q, \Sigma, \delta, q_0, F)$:
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $Q$ ist eine endliche Menge von \bi{Zuständen}
|
||||
\item $\Sigma$ ist das \bi{Eingabealphabet}
|
||||
\item $\delta: Q \times \Sigma \rightarrow Q$ ist die \bi{Übergangsfunktion}. $\delta(q, a) = p$ bedeutet Übergang von Zustand $q$ nach $p$ falls in $q$ $a$ gelesen wurde
|
||||
\item $q_0 \in Q$ ist der \bi{Anfangszustand}
|
||||
\item $F \subseteq Q$ ist die \bi{Menge der akzeptierenden Zustände}
|
||||
\end{enumerate}
|
||||
\rmvspace
|
||||
\rmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{itemize}
|
||||
\item \bi{Konfiguration}: Element aus $Q \times \Sigma^*$
|
||||
\item \bi{Startkonfiguration} auf $x$: $(q_0, x)$
|
||||
\item \bi{Endkonfiguration}: Jede aus $Q \times \{ \lambda \}$
|
||||
\end{itemize}
|
||||
\end{multicols}
|
||||
\rmvspace
|
||||
\rmvspace
|
||||
\begin{itemize}
|
||||
\item \bi{Schritt}: Relation auf Konfigurationen $\bigvdash{M}{} \subseteq (Q \times \Sigma^*) \times (Q \times \Sigma^*$ definiert durch $(q, w) \bigvdash{M}{} (p, x) \Leftrightarrow w = ax, a \in \Sigma \text{ und } \delta(q, a) = p$. Einfacher: Anwendung von $\delta$ auf die aktuelle Konfiguration
|
||||
\item \bi{Berechnung} $C$: Endliche Folge von Konfigurationen, $C_i \bigvdash{M}{} C_{i + 1}$.
|
||||
Auf Eingabe $x \in \Sigma^*$, $C_0$ Startkonfiguration und $C_n$ Endkonfiguration.
|
||||
Falls $C_n \in F \times \{ \lambda \}$, $C$ \bi{akzeptierende Berechnung}, $M$ \bi{akzeptiert Wort} $x$.
|
||||
Anderenfalls ist $C$ eine \bi{verwerfende Berechnung} und $M$ \bi{verwirft (akzeptiert nicht) das Wort} $x$
|
||||
\item \bi{Akzeptierte Sprache} $L(M) = \{ w \in \Sigma^* \divides \text{$M$ akzeptiert das Wort } w \text{ und $M$ endet in Endkonfig.} \}$
|
||||
\item $\mathcal{L}_{EA} = \{ L(M) | M \text{ ist ein EA}\}$ ist die Klasse aller Sprachen die von endlichen Automaten akzeptiert werden, auch genannt \bi{Klasse der regulären Sprachen} und für jede Sprache $L \in \mathcal{L}_{EA}$ gilt: $L$ regulär
|
||||
\end{itemize}
|
||||
\end{definition}
|
||||
Die Übergangsfunktion kann auch gut graphisch oder tabellarisch (wie eine Truth-Table) dargestellt werden.
|
||||
|
||||
$M$ ist in der Konfiguration $(q, w) \in Q \times \word$, wenn $M$ in Zustand $q$ ist und noch das Suffix $w$ zu lesen hat (also auf dem Eingabeband hinter dem Zeiger noch $w$ steht)
|
||||
|
||||
\begin{definition}[]{Reflexive und transitive Hülle}
|
||||
Sei $M = (Q, \Sigma, \delta, q_0, F)$ ein endlicher Automat. Die reflexive und transitive Hülle $\bigvdash{M}{*}$ der Schrittrelation $\bigvdash{M}{}$ von $M$ als
|
||||
$(q, w) \bigvdash{M}{*} (p, u) \Leftrightarrow (q = p \land w = u) \lor \exists k \in \N - \{ 0 \}$ so dass
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $w = a_1\ldots a_ku, a_i \in \Sigma$ für $i = 1, \ldots, k$
|
||||
\item $\exists r_1, \ldots, r_{k - 1} \in Q$, so dass
|
||||
$(q, w) \bigvdash{M}{} (r_1, a_2 \ldots a_k u) \bigvdash{M}{} (r_2, a_3 \ldots a_k u) \bigvdash{M}{} \ldots (r_{k - 1}, a_k u) \bigvdash{M}{} (p, u)$
|
||||
\end{enumerate}
|
||||
Wir definieren $\hat{\delta}: Q \times \Sigma^* \rightarrow Q$ durch
|
||||
\rmvspace
|
||||
\rmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $\hat{\delta}(q, \lambda) = q \smallhspace \forall q \in Q$
|
||||
\item $\hat{\delta}(q, wa) = \delta(\hat{\delta}(q, w), a) \forall a \in \Sigma, w \in \Sigma^*, q \in Q$
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
\end{definition}
|
||||
|
||||
\begin{intuition}[]{$\bigvdash{M}{*}$ und $\hdelta(q, w)$}
|
||||
$(q, w) \bigvdash{M}{*} (p, u)$ bedeutet, dass es eine Berechnung von $M$ gibt, die von der Konfiguration $(q, w)$ zu $(p, u)$ führt.
|
||||
Eine wichtiger Aspekt ist die Transitivität, was ja dann bedeutet, dass es (beliebig viele) Zwischenschritte gibt, so dass die Relation erfüllt ist.
|
||||
Oder noch viel einfacher: Es gibt irgendwieviele Zwischenschritte zwischen dem linken und rechten Zustand
|
||||
|
||||
$\hdelta(q, w) = p$ repräsentiert den letzen Zustand der Berechnung ausgehend von $(q, w)$.
|
||||
Etwas formaler bedeutet dies $(q, w) \bigvdash{M}{*} (p, \lambda)$, also falls $M$ im Zustand $q$ das Wort $w$ zu lesen beginnt, $M$ im Zustand $p$ endet.
|
||||
\end{intuition}
|
||||
Also gilt $L(M) = \{ w \in \Sigma^* \divides (q_0, w) \bigvdash{M}{*} (p, \lambda) \smallhspace \forall p \in F \} = \{ w \in \Sigma^* \divides \hdelta(q_0, w) \in F \}$.
|
||||
|
||||
Das folgende Lemma bezieht sich auf den Automaten $M$, den wir in der Tabelle weiter unten definieren.
|
||||
Der Automat entscheidet, ob die beiden Zahlen gerade oder ungerade sind.
|
||||
Dies kann man aber auch folgendermassen in formaler Ausdrucksweise ausdrücken:
|
||||
|
||||
\inlinelemma $L(M) = \{ w \in \{ 0, 1 \}^* \divides |w|_0 + |w|_1 \equiv 0 \text{ mod } 2 \}$
|
||||
|
||||
Jeder EA teilt die Menge $\Sigma^*$ in $|Q|$ Klassen
|
||||
$\class[p] = \{ w \in \Sigma^* \divides \hdelta(q_0, w) = p \} = \{ w \in \Sigma^* \divides (q_0, w) \bigvdash{M}{*} (p, \lambda) \}$ auf
|
||||
und entsprechend gilt:
|
||||
\begin{align*}
|
||||
\bigcup_{p \in Q} \class[p] = \Sigma^* \text{ und } \class[p] \cup \class[q] = \emptyset \smallhspace \forall p \neq q \in Q
|
||||
\end{align*}
|
||||
|
||||
In dieser Terminologie gilt dann $L(M) = \bigcup_{p \in F} \class[p]$.
|
||||
Die Notation $|w|_i$ bedeutet die Länge der Buchstaben $i$ in $w$.
|
||||
|
||||
Wir können $L(M)$ mit Klassen bestimmen und haben eine Äquivalenzrelation $x R_\delta y \Leftrightarrow \hat{\delta}(q_0, x) = \hat{\delta}(q_0, y)$ auf $\Sigma^*$.
|
||||
Man beweist die Korrektheit der gewählten Klassen oft mithilfe von Induktion über die Länge der Wörter.
|
||||
Wir beginnen mit der Länge an Wörtern der Länge kleiner gleich zwei und erhöhen dies dann während unseres Induktionsschrittes.
|
||||
|
||||
\inlineintuition Die Klassen sind Mengen, die hier Wörter mit gewissen Eigenschaften, die der EA bestimmt hat, wenn er in Zustand $q_i$ endet, enthalten.
|
||||
Diese Eigenschaften sind beispielsweise, dass alle Wörter, für die der EA in Zustand $q_i$ endet mit einer gewissen Sequenz enden, sie einen gewissen Zahlenwert haben, etc.
|
||||
|
||||
Die Klassen bestimmen wir vor dem Beginn der Induktion auf und jede Klasse repräsentiert einen der Zustände.
|
||||
\begin{wrapfigure}[5]{l}{0.3\textwidth}
|
||||
\begin{tables}{ccc}{Zustand & 0 & 1}
|
||||
$q_0$ & $q_2$ & $q_1$ \\
|
||||
$q_1$ & $q_3$ & $q_0$ \\
|
||||
$q_2$ & $q_0$ & $q_3$ \\
|
||||
$q_3$ & $q_1$ & $q_2$ \\
|
||||
\end{tables}
|
||||
\end{wrapfigure}
|
||||
Haben wir einen EA $M$ mit nebenstehender Tabelle, so sind die Klassen $\class[q_0], \ldots, \class[q_3]$, definiert durch:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\class[q_0] & = \{ w \in \wordbool \divides |w|_0 \text{ und } |w|_1 \text{ sind gerade} \} \\
|
||||
\class[q_1] & = \{ w \in \wordbool \divides |w|_0 \text{ ist gerade, } |w|_1 \text{ ist ungerade} \} \\
|
||||
\class[q_2] & = \{ w \in \wordbool \divides |w|_0 \text{ ist ungerade, } |w|_1 \text{ ist gerade} \} \\
|
||||
\class[q_3] & = \{ w \in \wordbool \divides |w|_0 \text{ und } |w|_1 \text{ sind ungerade} \}
|
||||
\end{align*}
|
||||
%
|
||||
Falls ein EA $A$ genügend anschaulich und strukturiert dargestellt ist, kann man die Sprache $L(A)$ auch ohne Beweis bestimmen.
|
||||
|
||||
Idealerweise konstruieren wir einen EA so, dass wir die Menge aller Wörter aus $\Sigma^*$ so in Klassen aufteilen,
|
||||
sodass Wörter mit denselben Eigenschaften in derselben Klasse liegen und wir dann Übergangsfunktionen zu anderen Klassen finden,
|
||||
die nur einen Buchstaben aus $\Sigma$ zum Wort hinzufügen
|
||||
|
||||
\inlineex Das Buch enthält einige zwei gute Beispiele (Beispiel 3.1 und 3.2) mit ausführlichen Erklärungen ab Seite 58 (= Seite 73 im PDF).
|
||||
@@ -0,0 +1,29 @@
|
||||
% Starting P63 = P78
|
||||
\subsection{Simulationen}
|
||||
Der Begriff der Simulation ist nicht ein formalisiert, da er je nach Fachgebiet, eine etwas andere Definition hat.
|
||||
Die engste Definition fordert, dass jeder elementare Schritt der zu Berechnung, welche simuliert wird, durch eine Berechnung in der Simulation nachgemacht wird.
|
||||
Eine etwas schwächere Forderung legt fest, dass in der Simulation auch mehrere Schritte verwendet werden dürfen.
|
||||
|
||||
Es gibt auch eine allgemeinere Definition, die besagt, dass nur das gleiche Eingabe-Ausgabe-Verhalten gilt und der Weg, oder die Berechnungen, welche die Simulation geht, respektive durchführt, wird ignoriert, respektive wird nicht durch die Definition beschränkt.
|
||||
|
||||
\textit{Hier werden wir aber die enge Definition verwenden}
|
||||
|
||||
\fancylemma{Produktautomaten} Wir haben zwei EA $M_1 = (Q_1, \Sigma, \delta_1, q_{01}, F_1)$ und $M_2 = (Q_2, \Sigma, \delta_2, q_{02}, F_2)$, die auf dem Alphabet $\Sigma$ operieren.
|
||||
Für jede Mengenoperation $\odot \in \{ \cup, \cap, - \}$ existiert ein EA $M$, so dass $L(M) = L(M_1) \odot L(M_2)$
|
||||
|
||||
Was dieses Lemma nun aussagt ist folgendes: Man kann einen endlichen Automaten bauen, so dass das Verhalten von zwei anderen EA im Bezug auf die Mengenoperation simuliert wird.
|
||||
Ein guter, ausführlicher Beweis dieses Lemmas findet sich im Buch auf Seite 64 (= Seite 79 im PDF)
|
||||
|
||||
Dieses Lemma hat weitreichende Nutzen.
|
||||
Besonders ist es also möglich einen modularen EA zu bauen, in dem Teile davon in kleinere und einfachere EA auszulagern, die dann wiederverwendet werden können.
|
||||
|
||||
\begin{intuition}[]{Produktautomaten}
|
||||
Produktautomaten erstellt man, in dem man die (meist zwei) Automaten als einen Gridgraph aufschreibt und eine Art Graph-Layering betreibt,
|
||||
so dass der eine Graph horizontal und der andere Graph vertikal orientiert ist.
|
||||
Dann werden die Übergänge folgendermassen definiert:
|
||||
Für jeden Eingang liefert der Graph, der horizontal ausgerichtet ist, ob wir nach links oder rechts gehen (oder bleiben),
|
||||
während der vertikal ausgerichtete Graph entscheidet, ob wir nach oben oder unten gehen (oder bleiben).
|
||||
\end{intuition}
|
||||
|
||||
\stepLabelNumber{example}
|
||||
\inlineex Dieses Beispiel im Buch ist sehr gut erklärt und findet sich auf Seiten 65, 66 \& 67 (= Seite 80, 81 \& 82 im PDF)
|
||||
@@ -0,0 +1,138 @@
|
||||
\newpage
|
||||
\subsection{Beweise der Nichtexistenz}
|
||||
Im Gegensatz zum Beweis, dass eine bestimmte Klasse von Programmen (Algorithmen) ein Problem lösen kann
|
||||
(was ein einfacher Existenzbeweis ist, bei welchem man eine korrekte Implementation liefern kann),
|
||||
ist der Beweis, dass diese Klasse von Programmen (Algorithmen) dies nicht tun kann viel schwieriger,
|
||||
da man (logischerweise) nicht für alle (unendlich vielen) Programme zeigen kann, dass sie das Problem nicht lösen.
|
||||
|
||||
In diesem Kurs werden wir aber vorerst nur die Klasse der endlichen Automaten behandlen, welche sehr stark eingeschränkt sind,
|
||||
was diese Beweise verhältnismässig einfach macht.
|
||||
Falls also ein EA $A$ für zwei unterschiedliche Wörter $x$ und $y$ im gleichen Zustand endet (also $\hdelta(q_0, x) = \hdelta(q_0, y))$),
|
||||
so heisst das für uns von jetzt an, dass $A$ nicht zwischen $x$ und $y$ unterscheiden kann:
|
||||
|
||||
\begin{lemma}[]{Unterscheidung von Wörtern}
|
||||
Sei $A$ ein EA über $\Sigma$ und $x \neq y \in \Sigma^*$ so dass
|
||||
\begin{align*}
|
||||
(q_0, x) \bigvdash{A}{*} (p, \lambda) \text{ und } (q_0, y) \bigvdash{A}{*} (p, \lambda)
|
||||
\end{align*}
|
||||
für ein $p \in Q$ (also $\hdelta_A (q_0, x) = \hdelta(q_0, y) = p(x, y \in \class [p])$).
|
||||
Dann existiert für jedes $z \in \Sigma^*$ ein $r \in Q$, so dass $xz, yz \in \class[r]$, also gilt insbesondere
|
||||
\begin{align*}
|
||||
xz \in L(A) \Longleftrightarrow yz \in L(A)
|
||||
\end{align*}
|
||||
\end{lemma}
|
||||
Das obenstehende Lemma 3.3 ist ein Spezialfall einer Eigenschaft, die für jedes (deterministische) Rechnermodell gilt.
|
||||
Es besagt eigentlich nichts anderes, als dass wenn das Wort $xz$ akzeptiert wird, so wird auch das Wort $yz$
|
||||
|
||||
Mithilfe von Lemma 3.3 kann man für einen grossteil Sprachen deren Nichtregularität beweisen.
|
||||
|
||||
\numberingOff
|
||||
\inlineex Sei $L = \{ 0^n1^n \divides n \in \N \}$.
|
||||
Intuitiv ist diese Sprache Nichtregulär, da $n$ unendlich gross sein kann, aber ein EA logischerweise endlich ist.
|
||||
Wir müssen hier nur formal ausdrücken, dass das Zählen benötigt wird, dass $L$ akzeptiert wird:
|
||||
|
||||
Dazu benutzen wir einen Widerspruchsbeweis. Sei $A$ ein EA über $\alphabets{bool}$ und $L(A) = L$.
|
||||
Wir nehmen an, dass $L$ regulär ist und betrachten die Wörter $0^1, 0^2, \ldots, 0^{|Q| + 1}$.
|
||||
Weil wir $|Q| + 1$ Wörter haben, existiert per Pigeonhole-Principle o.B.d.A $i < j \in \{ 1, 2, \ldots, |Q| + 1 \}$
|
||||
(die Ungleichheit kann in komplexeren Beweisen sehr nützlich werden, da wir dann besser mit Längen argumentieren können),
|
||||
so dass $\hdelta_A(q_0, 0^i) = \hdelta_A(q_0, 0^j)$, also gilt nach Lemma $0^i z \in L \Leftrightarrow 0^j z \in L \smallhspace \forall z \in \wordbool$.
|
||||
Dies gilt jedoch nicht, weil für jedes $z = 1^i$ zwar jedes $0^i 1^i \in L$ gilt, aber $0^i 1^j \notin Lh$
|
||||
|
||||
\numberingOn
|
||||
|
||||
Um die Nichtregularität konkreter Sprachen zu beweisen, sucht man nach einfach verifizierbaren Eigenschaften,
|
||||
denn wenn eine Sprache eine dieser Eigenschaften \textit{nicht} erfüllt, so ist sie nicht regulär.
|
||||
|
||||
|
||||
\vspace{0.3cm}
|
||||
\hrule
|
||||
\vspace{0.2cm}
|
||||
|
||||
\fhlc{Cyan}{Pumping}
|
||||
|
||||
Eine weitere Methode zum Beweis von Aussagen $L \notin \mathcal{L}_{\text{EA}}$ nennt sich \bi{Pumping} und basiert auf folgender Idee:\\
|
||||
Wenn für ein Wort $x$ und einen Zustand $p$ gilt, dass $(p, x) \bigvdash{A}{*} (p, \lambda)$, so gilt auch für alle $i \in \N$, dass $(p, x^i) \bigvdash{A}{*} (p, \lambda)$.
|
||||
Also kann $A$ nicht zwischen $x$ und $x^i$ unterscheiden, oder in anderen Worten, wie viele $x$ er gelesen hat,
|
||||
also akzeptiert $A$ entweder alle Wörter der Form $yx^iz$ (für $i \in \N$) oder keines davon
|
||||
|
||||
\begin{lemma}[]{Pumping-Lemma für reguläre Sprachen}
|
||||
Sei $L$ regulär. Dann existiert eine Konstante $n_0 \in \N$, so dass sich jedes Wort $w \in \word$ mit $|w| \geq n_0$ in $w = yxz$ zerlegen lässt, wobei
|
||||
\rmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $|yx| \leq n_0$
|
||||
\item $|x| \geq 1$
|
||||
\item Für $X = \{ yx^kz \divides k\in \N \}$ \textit{entweder} $X \subseteq L$ oder $X \cap L = \emptyset$ gilt
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
\end{lemma}
|
||||
Bei der Wahl von den Teilen von $w$ sollte man idealerweise einen Teil (der dann $=y$ in $w = yxz$ ist) bereits gross genug zu wählen, so dass (i) zutrifft, was es nachher einfacher macht.
|
||||
|
||||
\newpage
|
||||
\numberingOff
|
||||
\inlineex Wir verwenden wieder die Sprache $L = \{ 0^n 1^n \divides n \in \N \}$ und wieder einen Widerspruchsbeweis:
|
||||
|
||||
Wir nehmen an, dass $L$ regulär ist, also gilt Lemma 3.4 und es existiert eine Konstante $n_0$ so dass $|w| \geq n_0$.
|
||||
Um zu zeigen, dass eine Sprache nicht regulär ist, reicht es aus, zu zeigen, dass es ein (hinreichend langes) Wort gibt, für das eine der Eigenschaften in Lemma 3.4 nicht zutrifft.
|
||||
|
||||
Wir wählen $w = 0^{n_0} 1^{n_0}$, also ist $|w| = 2n_0 \geq n_0$.
|
||||
Zudem müssen wir eine sinnvolle Zerlegung wählen -- denn eine solche existiert für jedes Wort $w$ mit $|w| \geq n_0$ laut Lemma 3.4 --
|
||||
wir wählen $yx = 0^{n_0}$, also ist $y = 0^l$ und $x = 0^m$ für irgendwelche $l, m \in \N$, so dass $l + m \leq n_0$.
|
||||
|
||||
Nach Lemma 3.4 (ii) ist $m \neq 0$ ($|x| \geq 1$).
|
||||
Nun, da $w = 0^{n_0} 1^{n_0} \in L$, ist $\{ yx^kz \divides k \in \N \} = \{ 0^{n_0 - m + km} 1^{n_0} \divides k \in \N \} \subseteq L$, was aber ein Widerspruch ist,
|
||||
da $yx^0z = yz = 0^{n_0 - m} 1^{n_0} \notin L$ ($0^{n_0}1^{n_0}$ ist sogar das einzige Wort aus der Menge, das in $L$ liegt)
|
||||
|
||||
\inlineintuition Woher kommt $0^{n_0 - m + km}$?
|
||||
Das Ganze wird mit Klammern bedeutend offensichtlicher: $0^{(n_0 - m) + (km)}$.
|
||||
Also ist der Ursprung der Koeffizienten auch klar, und sie kommen von $|y| = n_0 - m$ und $|x^k| = km$.
|
||||
Die Addition im Exponent kommt dann deshalb zustande, da dies ja nicht ein Exponent ist, sondern die Anzahl der Repetitionen.
|
||||
|
||||
\numberingOn
|
||||
|
||||
|
||||
\vspace{0.3cm}
|
||||
\hrule
|
||||
\vspace{0.2cm}
|
||||
|
||||
\fhlc{Cyan}{Kolmogorov-Komplexität basiert}
|
||||
|
||||
\begin{theorem}[]{Kolmogorov-Komplexität regulärer Sprachen}
|
||||
Sei $L \subseteq \wordbool$ eine reguläre Sprache. Sei $L_x = \{ y \in \wordbool \divides xy \in L \}$ für jedes $x \in \wordbool$.
|
||||
Dann existiert eine Konstante $c$, so dass für alle $x, y \in \wordbool$ gilt, dass
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
K(y) \leq \ceil{\log_2(n + 1)} + c
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
falls $y$ das $n$-te Wort in der Sprache $L_x$ ist
|
||||
\end{theorem}
|
||||
|
||||
\numberingOff
|
||||
\inlineex Wir verwenden wieder die Sprache $L = \{ 0^n 1^n \divides n \in \N \}$ und wieder einen Widerspruchsbeweis:
|
||||
|
||||
Dazu nehmen wir wieder an, dass $L$ regulär ist. Für jedes $m \in \N$ ist $1^m$ das erste Wort in der Sprache $L_{0^m} = \{ y \divides 0^m y \in L \} = \{ 0^j 1^{m + j} \divides j \in \N \}$.
|
||||
Die zweite Menge beinhaltet also alle möglichen Wörter $y$, die noch immer in $L$ sind, wenn man sie mit $0^m$ als $0^m 0^j 1^{m + j}$ konkateniert
|
||||
und ist deshalb eine konkrete Beschreibung von $L_{0^m}$.
|
||||
|
||||
Also gibt es laut Satz 3.1 eine Konstante $c$, die unabhängig von $x = 0^m$ und $y = 1^m$ und somit von $m$ ist, so dass $K(1^m) \leq \ceil{\log_2(1 + 1)} + c = 1 + c$
|
||||
($n = 1$ hier, da $1^m$ das erste Wort in $L_{0^m}$ ist und wir dieses Wort betrachten wollen),
|
||||
also gilt für eine Konstante $d = 1 + c$, dass $K(1^m) \leq d$.
|
||||
Dies ist aber unmöglich, da:
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item die Anzahl aller Programme, deren Länge $\leq d$ ist, ist höchstens $2^d$ und entsprechend endlich
|
||||
\item die Menge $\{ 1^m \divides m \in \N \}$ unendlich ist
|
||||
\end{enumerate}
|
||||
|
||||
Für komplexere Sprachen ist es oft einfach, $L_x$ so zu wählen, dass $x = a^{\alpha + 1}$ ist, wobei $\alpha$ der Exponent (nach Variabelnwechsel) aus der Sprache ist.
|
||||
Also beispielsweise für $L = \{ 0^{n^2 \cdot 2n \divides n \in \N }\}$ ist $\alpha = m^2 \cdot 2m$, also ist $x = 0^{m^2 \cdot 2m + 1}$.
|
||||
$y_1$ (das erste Wort der Sprache $L_x$) ist dann $y_1 = 0^{(m + 1)^2 \cdot 2(m + 1) - m^2 \cdot 2m + 1}$.
|
||||
|
||||
Wir können dann mit der Länge des Wortes $|y_1|$ und dem Theorem 3.1 argumentieren, dass wir einen Widerspruch erreichen und so also die Sprache nichtregulär ist.
|
||||
|
||||
Dazu sagen wir, dass für jedes $m \in \N$ eine Konstante $c$ existiert, so dass $K(y_1) \leq \ceil{\log_2(1 + 1)} + c = 1 + c$.
|
||||
Da unser Wort $y_1$ unendlich lang werden kann, gibt es unendlich viele solcher Wörter.
|
||||
Dies widerspricht jedoch dem Fakt, dass es nur endlich viele Programme mit Kolmogorov-Komplexität $\leq 1 + c$ gibt.
|
||||
|
||||
\numberingOn
|
||||
@@ -0,0 +1,131 @@
|
||||
\newpage
|
||||
\subsection{Nichtdeterminismus}
|
||||
Einfach gesagt werden hier Automaten behandelt, die zufällige (genannt \bi{nichtdeterministische}) Entscheidungen treffen.
|
||||
Beispielsweise für ein Entscheidungsproblem $(\Sigma, L)$ bedeutet dies, dass ein nichtdeterministischer EA $A$ eine Sprache $L$ akzeptiert,
|
||||
falls für jedes $x \in L$ mindestens eine akzeptierende Berechnung von $A$ auf $x$ existiert und für $y \in \word - L$ keine solve existiert.
|
||||
|
||||
Wir notieren das Ganze in graphischer Darstellung so, dass wir aus einem Zustand mehrere Übergänge mit dem gleichen Eingabesymbol erlauben.
|
||||
|
||||
\begin{definition}[]{nichtdeterministischer Endlicher Automat (NEA)}
|
||||
Ein NEA ist eine Quitupel $M = (Q, \Sigma, \delta, q_0, F)$:
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item \bi{Zustandsmenge:} $Q$ ist eine endliche Menge
|
||||
\item \bi{Eingabealphabet:} $\Sigma$ ist ein Alphabet
|
||||
\item \bi{Übergangsfunktion:} $\delta : Q \times \Sigma \rightarrow \mathcal{P}(Q)$. $\mathcal{P}(Q)$ ist das Powerset hierbei
|
||||
\item \bi{Anfangszustand:} $q_0 \in Q$
|
||||
\item \bi{Akzeptierende Zustände:} $F \subseteq Q$
|
||||
\end{enumerate}
|
||||
Ein \bi{Schritt} in der $\delta$-Notation ist im Vergleich zum deterministischen EA nicht $\delta(q, a) = p$,
|
||||
sondern $p \in \delta(q, a)$ ist, da die Übergangsfunktion ja jetzt ins Powerset von $Q$,
|
||||
anstelle von nach $Q$ direkt mapped. Die komplette Definition des Schritts ist also:
|
||||
\begin{align*}
|
||||
(q, w) \bigvdash{M}{} (p, x) \Longleftrightarrow w = ax \text{ für ein } a \in \Sigma \text{ und } p \in \delta(q, a)
|
||||
\end{align*}
|
||||
|
||||
Eine \bi{Berechnung von $M$} ist eine endliche Folge $D_1, D_2, \ldots, D_k$ von Konfigurationen,
|
||||
wobei $D_i \bigvdash{M}{} D_{i + 1}$ für $i = 1, \ldots, k - 1$
|
||||
|
||||
Eine \bi{Berechnung von $M$ auf $x$} hingegen ist eine Berechnung $C_0, C_1, \ldots, C_m$ von $M$,
|
||||
wobei $C_0 = (q_0, x)$ und entweder $C_m \in Q \times \{ \lambda \}$ oder $C_M = (q, ay)$ für ein $a \in \Sigma, y \in \word$ und $q \in Q$,
|
||||
so dass $\delta(q, a) = \emptyset$.
|
||||
|
||||
$C_0, \ldots, C_m$ ist \bi{akzeptierend} falls $C_m = (p, \lambda)$ für ein $p \in F$
|
||||
|
||||
Die Sprache $L(M) = \{ w \in \word \divides (q_0, w) \bigvdash{M}{*} (p, \lambda) \text{ für ein } p \in F \}$
|
||||
|
||||
Für die $\hdelta$-Funktion, gilt nun $\hdelta(q, \lambda) = \{ q \}$ für jedes $q \in Q$ und wir definieren:
|
||||
\begin{align*}
|
||||
\hdelta(q, wa) & = \{ p \in Q \divides \text{es existiert ein } r \in \hdelta(q, w), \text{ so dass } p \in \delta(r, a) \} \\
|
||||
& = \bigcup_{r \in \hdelta(q, w)} \delta(r, a) \smallhspace \forall q \in Q, a \in \Sigma, w \in \word
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
Ein Wort ist in $L(M)$, falls $M$ mindestens eine akzeptierende Berechnung auf $x$ hat.
|
||||
|
||||
Bei einer akzeptierenden Berechnung \textit{auf} $x$ wird wie beim EA gefordert, dass das ganze Wort $x$ gelesen worden ist und $M$ nach dem Lesen in einem akzeptierenden Zustand ist.
|
||||
|
||||
Bei NEA kann eine nicht akzeptierende Berechnung auch vor Beendung des Lesevorgangs enden, da wir hier nicht vorschreiben,
|
||||
dass es für jedes Symbol des Eingabealphabets eine definierte Übergangsfunktion gibt, es ist also erlaubt, dass bspw. $\delta(q, a) = \emptyset$.
|
||||
|
||||
Zudem haben wir aus der Definition von $\hdelta$ eine alternative Definition der von $M$ akzeptierten Sprache:
|
||||
$L(M) = \{ w \in \word \divides \hdelta(q_0, w) \cap F \neq \emptyset \}$
|
||||
|
||||
Für NEA kann man einen \bi{Berechnungsbaum $\mathcal{B}_M(x)$ von $M$ auf $x$} erstellen, der dann anschaulich alle möglichen Enden der Berechnung darstellt.
|
||||
Wir beginnen den Baum mit Konfiguration $(q_0, x)$ und führen dann mit den Kanten alle möglichen Berechnungen aus, die mit dem ersten Symbol des Wortes möglich sind.
|
||||
|
||||
Wir erreichen so also zum Beispiel die Konfiguration $(q_1, x_1)$, wobei $x_1$ $x$ ohne das erste Zeichen ist.
|
||||
|
||||
|
||||
\fancylemma{NEA aus Abbildung 3.15 im Buch} Sei $M$ der NEA aus Abbildung 3.15 im Buch (auf Seite 77 (= 92 im PDF) zu finden).
|
||||
Dann ist $L(M) = \{ x11y \divides x, y \in \wordbool \}$
|
||||
|
||||
Der Beweis für eine solche Aussage läuft oft über Teilmengen (also mit $X \subseteq Y \land Y \subseteq X \Leftrightarrow X = Y$).
|
||||
|
||||
|
||||
Eine zentrale Frage dieses Kapitels ist es, ob $\mathcal{L}_{\text{NEA}} = \mathcal{L}_{\text{EA}}$, wobei $\mathcal{L}_{\text{NEA}} = \{ L(M) \divides M \text{ ist ein NEA} \}$.
|
||||
In anderen Worten: Können EA die Arbeit von NEA simulieren?
|
||||
|
||||
Ja, es ist möglich und gilt allgemein, dass die Simulation von Nichtdeterminismus durch Determinismus nur dann realisierbar ist,
|
||||
wenn es möglich ist, alle nichtdeterministischen Berechnungen durch deterministische Berechnungen nachzuahmen.
|
||||
|
||||
Bei EA (nennen einen $A$ im Folgenden) basiert diese Idee auf BFS der Berechnungsbäume von $M$.
|
||||
Die Idee ist dann, dass alle Knoten mit Entfernung $i$ von der Wurzel die ersten $i$ Symbole von $x$ gelesen haben.
|
||||
Da NEA endlich viele Konfigurationen bei Entfernung $i$ haben ist es möglich, die Transformation durchzuführen.
|
||||
Wenn es zwei Knoten $u \neq v$ identisch sind, so müssen wir nur in einem der Teilbäume nach einer akzeptierenden Berechnung suchen.
|
||||
|
||||
\bi{Potenzmengenkonstruktion:} Ein Zustand $\langle P \rangle$ von $A$ für $P \subseteq Q$ erhält die Bedeutung,
|
||||
dass nach der gegebenen Anzahl an Berechnungsschritten genau die Zustände aus $P$ in den Berechnungen von $M$ auf der gegebenen Ebene erreichbar sind, also $P = \hdelta(q_0, z)$.
|
||||
Ein Berechnungsschritt in $A$ aus einem Zustand $\langle P \rangle$ für ein gelesenes Symbol $a$ bedeutet die Bestimmung der Menge $\bigcup_{p \in P} \delta(p, a)$,
|
||||
also aller Zustände, die aus irgendeinem Zustand $p \in P$ beim Lesen von $a$ erreichbar sind.
|
||||
|
||||
Dabei benutzen wir $\langle P \rangle$ statt $P$, um zu verdeutlichen, dass wir eine Zustand von $A$ und nicht die Menge der Zustände von $M$ bezeichnen.
|
||||
|
||||
Ein EA, der die Sprache, bei welcher das $k$-letzte Symbol $1$ ist, benötigt $2^k$ Zustände.
|
||||
Er wird dabei aus dem NEA dieser Sprache mit der Potenzmengenkonstruktion gebildet.
|
||||
|
||||
\inlinetheorem Zu jedem NEA $M$ existiert ein EA $A$, so dass $L(M) = L(A)$
|
||||
|
||||
Um $L(M) = L(A)$ zu zeigen, müssen wir folgende Äquivalenz beweisen:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\forall x \in \word : \hdelta_M(q_0, x) = P \Longleftrightarrow \hdelta(q_{0 A}, x) = \langle P \rangle
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
Wir können dies über einen Induktionsbeweis tun und ein vollständiger Beweis findet sich unten auf Seite 82 (= Seite 97 im PDF) im Buch.
|
||||
|
||||
Wir sagen, dass zwei Automaten \bi{äquivalent} sind, falls $L(A) = L(B)$.
|
||||
|
||||
Eine Folge von Satz 3.2 ist eben, dass $\mathcal{L}_{\text{EA}} = \mathcal{L}_{\text{NEA}}$, also sind die EA genau so stark wie die NEA im Bezug auf die Sprachakzeptierung.
|
||||
Was hingegen ein Problem sein kann, ist dass die durch die Potenzmengenkonstruktion erzeugten Automaten (exponentiell) grösser sind als die NEA.
|
||||
|
||||
Es gibt gewisse NEA, bei welchen man bei der Simulation des Nichtdeterminismus durch Determinismus unausweichlich in exponentiell grösseren EA resultiert.
|
||||
Man kann beweisen (siehe Seiten 83 und 84 mit Abbildung 3.19 im Buch (= Seiten 98 \& 99 im PDF)), dass man die Potenzmengenkonstruktion nicht allgemein verbessern kann.
|
||||
|
||||
\inlinelemma Für alle $k \in \N - \{ 0 \}$ muss jeder EA, der $L_k = \{ x1y \divides x \in \wordbool, y \in (\alphabetbool)^{k - 1} \}$ akzeptiert, mindestens $2^k$ Zustände haben.
|
||||
|
||||
% FIXME: Verify with TA that this is correct too
|
||||
% Else: Note an example from the worked example, TA's approach from the slides or from the book on P100 (PDF)
|
||||
\fhlc{ForestGreen}{Worked Example} Zeige, das jeder endliche Automat, der die Sprache
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
L = \{ w \in \{ a , b \}^* \divides w \text{ enthält Teilwort $ab$ gleich oft wie das Teilwort $ba$ enthält} \}
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
mindestens $n := 5$ Zustände haben muss.
|
||||
|
||||
\begin{table}[h!]
|
||||
\begin{center}
|
||||
\begin{tabular}[c]{c|ccccc}
|
||||
& $ab$ & $(ab)^2$ & $(ab)^3$ & $(ab)^4$ & $(ab)^5$ \\
|
||||
\hline
|
||||
$ab$ & - & $(ba)^2$ & $(ba)^3$ & $(ba)^4$ & $(ba)^5$ \\
|
||||
$(ab)^2$ & & - & $(ba)^3$ & $(ba)^4$ & $(ba)^5$ \\
|
||||
$(ab)^3$ & & & - & $(ba)^4$ & $(ba)^5$ \\
|
||||
$(ab)^4$ & & & & - & $(ba)^5$ \\
|
||||
$(ab)^5$ & & & & & - \\
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
\end{table}
|
||||
Sei $S = \{ ab, (ab)^2, (ab)^3, (ab)^4, (ab)^5 \}$.
|
||||
Laut Lemma 3.3
|
||||
Reference in New Issue
Block a user