mirror of
https://github.com/janishutz/eth-summaries.git
synced 2026-01-12 14:18:23 +00:00
[TI] Cleaner structure
This commit is contained in:
BIN
semester3/ti/main/assets/binomialExpansion.png
Normal file
BIN
semester3/ti/main/assets/binomialExpansion.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 190 KiB |
BIN
semester3/ti/main/assets/overview.png
Normal file
BIN
semester3/ti/main/assets/overview.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 442 KiB |
114
semester3/ti/main/parts/01_languages-problems/00_alphabet.tex
Normal file
114
semester3/ti/main/parts/01_languages-problems/00_alphabet.tex
Normal file
@@ -0,0 +1,114 @@
|
||||
\subsection{Alphabete, Wörter, Sprachen}
|
||||
|
||||
\begin{definition}[]{Alphabet}
|
||||
Eine endliche, nicht leere Menge $\Sigma$. Elemente sind Buchstaben (Zeichen \& Symbole).
|
||||
|
||||
Beispiele: $\alphabets{bool}$, $\alphabets{lat}$ latin characters, $\alphabets{Tastatur}$, $\Sigma_m$ $m$-adische Zahlen ($m$-ary numbers, zero index)
|
||||
\end{definition}
|
||||
|
||||
\begin{definition}[]{Wort}
|
||||
Über $\Sigma$ eine (möglicherweise leere) Folge von Buchstaben aus $\Sigma$. Leeres Wort $\lambda$ (ab und zu $\varepsilon$) hat keine Buchstaben.
|
||||
|
||||
$|w|$ ist die Länge des Wortes (Anzahl Buchstaben im Wort), während $\Sigma^*$ die Menge aller Wörter über $\Sigma$ ist und $\Sigma^+ = \Sigma^* - \{\lambda\}$
|
||||
|
||||
In diesem Kurs werden Wörter ohne Komma geschrieben, also $x_1x_2\ldots x_n$ statt $x_1, x_2, \ldots, x_n$.
|
||||
Für das Leersymbol gilt $|\text{\textvisiblespace}|$, also ist es nicht dasselbe wie $\lambda$
|
||||
\end{definition}
|
||||
|
||||
Für viele der Berechnungen in Verbindung mit der Länge der Wörter kann Kombinatorik nützlich werden.
|
||||
In Kapitel \ref{sec:combinatorics} findet sich eine Zusammenfassung über jenes Thema (in English)
|
||||
|
||||
Ein mögliches Alphabet beispielsweise um einen Graphen darzustellen ist folgendes:
|
||||
|
||||
Angenommen, wir speichern den Graphen als Adjezenzmatrix ab, dann können wir beispielsweise mit dem Alphabet $\Sigma = \{0, 1, \#\}$ diese Matrix darstellen, in dem wir jede neue Linie mit einem $\#$ abgrenzen.
|
||||
Das Problem hierbei ist jedoch, dass dies nicht so effizient ist, besonders nicht, wenn der Graph sparse ist, da wir dann viele \# im Vergleich zu nützlicher Information haben.
|
||||
|
||||
\begin{definition}[]{Konkatenation}
|
||||
$\Sigma^* \times \Sigma^* \rightarrow \Sigma^*$, so dass Kon$(x, y) = x \cdot y = xy \smallhspace \forall x, y \in \Sigma^*$.
|
||||
|
||||
Intuitiv ist dies genau das was man denkt: Wörter zusammenhängen (wie in Programmiersprachen).
|
||||
Die Operation ist assoziativ und hat das Neutralelement $\lambda$, was heisst, dass $(\Sigma^*, \text{Kon})$ ein Monoid ist.
|
||||
|
||||
Offensichtlich ist die Konkatenation nur für ein-elementige Alphabete kommutativ.
|
||||
|
||||
Die Notation $(abc)^n$ wird für die $n$-fache Konkatenation von $abc$ verwendet
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Umkehrung}
|
||||
Sei $a = a_1 a_2 \ldots a_n$, wobei $a_i \in \Sigma$ für $i \in \{1, 2, \ldots, n\}$, dann ist die Umkehrung von $a$, $a^\tR = a_n a_{n - 1} \ldots a_1$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Iteration}
|
||||
Die $i$-te Iteration $x^i$ von $x \in \Sigma^*$ für alle $i \in \N$ ist definiert als $x^0 = \lambda$, $x^1 = x$ und $x^i = xx^{i - 1}$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Teilwort, Präfix, Suffix}
|
||||
Seien $v, w \in \Sigma^*$
|
||||
\begin{itemize}
|
||||
\item $v$ heisst \bi{Präfix} von $w \Longleftrightarrow \exists y \in \Sigma^* : w = vy$
|
||||
\item $v$ heisst \bi{Suffix} von $w \Longleftrightarrow \exists x \in \Sigma^* : w = xv$
|
||||
\item $v$ heisst \bi{Teilwort} von $w \Longleftrightarrow \exists x, y \in \Sigma^* : w = xvy$
|
||||
\item $v \neq \lambda$ heisst \bi{echtes} Teilwort (gilt auch für Präfix, Suffix) von $w$ genau dann, wenn $v \neq w$ und $v$ ein Teilwort (oder eben Präfix oder Suffix) von $w$ ist
|
||||
\end{itemize}
|
||||
\end{definition}
|
||||
|
||||
\begin{definition}[]{Kardinalität, Vorkommen und Potenzmenge}
|
||||
Für Wort $x \in \Sigma^*$ und Buchstabe $a \in \Sigma$ ist $|x|_a$ definiert als die Anzahl Male, die $a$ in $x$ vorkommt.
|
||||
|
||||
Für jede Menge $A$ ist $|A|$ die Kardinalität und $\mathcal{P}(A) = \{S | S \subseteq A\}$ die Potenzmenge von $A$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Kanonische Ordnung}
|
||||
Wir definieren eine Ordnung $s_1 < \ldots < s_m$ auf $\Sigma$. Die \bi{kanonische Ordnung} auf $\Sigma^*$ für $u, v \in \Sigma^*$ ist definiert als:
|
||||
\begin{align*}
|
||||
u < v \Longleftrightarrow |u| < |v| \lor (|u| = |v| \land u = x \cdot s_i \cdot u' \land v = x \cdot s_j \cdot v') \text{ für beliebige $x, u', v' \in \Sigma^*$ und $i < j$}
|
||||
\end{align*}
|
||||
|
||||
Oder in Worten, geordnet nach Länge und dann danach für den ersten nicht gemeinsamen Buchstaben, nach dessen Ordnung.
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Sprache}
|
||||
$L \subseteq \Sigma^*$ ist eine Sprache, deren Komplement $L^C = \Sigma^* - L$ ist.
|
||||
Dabei ist $L_{\emptyset}$ die \bi{leere Sprache} und $L_{\lambda}$ die einelementige Sprache die nur aus dem leeren Wort besteht.
|
||||
|
||||
Die \bi{Konkatenation} von $L_1$ und $L_2$ ist $L_1 \cdot L_2 = L_1 L_2 = \{ vw \divides v \in L_1 \land w \in L_2 \}$ und $L^0 := L_{\lambda}$ und $L^{i + 1} = L^i \cdot L \smallhspace \forall i \in \N$ und $L^* = \bigcup_{i \in \N} L^{i}$ ist der \bi{Kleene'sche Stern} von $L$, wobei $L^+ = \bigcup_{i \in \N - \{0\}} L^i = L \cdot L^*$
|
||||
\end{definition}
|
||||
|
||||
Für jede Sprache $L$ gilt $L^2 \subseteq L \Longrightarrow L = \emptyset \lor L = \{ \lambda \} \lor L$ ist undendlich.
|
||||
Diese Aussage muss jedoch an der Prüfung bewiesen werden (nicht im Buch vorhanden)
|
||||
|
||||
Da Sprachen Mengen sind, gelten auch die Üblichen Operationen, wie Vereinigung ($\cup$) und Schnitt ($\cap$).
|
||||
Die Gleichheit von zwei Sprachen bestimmen wir weiter mit $A \subseteq B \land B \subseteq A \Rightarrow A = B$.
|
||||
Um $A \subseteq B$ zu zeigen reicht es hier zu zeigen dass für jedes $x \in A$, $x \in B$ hält.
|
||||
Wir betrachten nun, wie die üblichen Operationen mit der neu hinzugefügten Konkatenation interagieren.
|
||||
|
||||
\begin{lemma}[]{Distributivität von Kon und $\cup$}
|
||||
Für Sprachen $L_1, L_2$ und $L_3$ über $\Sigma$ gilt: $L_1 L_2 \cup L_1 L_3 = L_1 (L_2 \cup L_3)$
|
||||
\end{lemma}
|
||||
|
||||
Der Beweis hierfür läuft über die oben erwähnte ``Regel'' zur Gleichheit.
|
||||
Um das Ganze einfacher zu machen, teilen wir auf: Wir zeigen also erst $L_1 L_2 \subseteq L_1(L_2 \cup L_3)$ und dann equivalent für $L_1 L_3$.
|
||||
|
||||
|
||||
\begin{lemma}[]{Distributivität von Kon und $\cap$}
|
||||
Für Sprachen $L_1, L_2$ und $L_3$ über $\Sigma$ gilt: $L_1 (L_2 \cap L_3) \subseteq L_1 L_2 \cap L_1 L_3$
|
||||
\end{lemma}
|
||||
|
||||
\shortlemma Es existieren $U_1, U_2, U_3 \in \wordbool$, so dass $U_1 (U_2 \cap U_3) \subsetneq U_1 U_2 \cap U_1 U_3$
|
||||
|
||||
|
||||
|
||||
\begin{definition}[]{Homomorphismus}
|
||||
$\Sigma_1, \Sigma_2$ beliebige Alphabete. Ein \bi{Homomorphismus} von $\wordm{1}$ nach $\wordm{2}$ ist jede Funktion $h: \Sigma_1^* \rightarrow \Sigma_2^*$ mit:
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $h(\lambda) = \lambda$
|
||||
\item $h(uv) = h(u) \cdot h(v) \smallhspace \forall u, v \in \Sigma_1^*$
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
|
||||
Erneut gilt hier, dass im Vergleich zu allgemeinen Homomorphismen, es zur Definition von einem Homomorphismus ausreichtt, $h(a)$ für alle Buchstaben $a \in \Sigma_1$ festzulegen.
|
||||
@@ -0,0 +1,22 @@
|
||||
\newpage
|
||||
\subsection{Algorithmische Probleme}
|
||||
Ein Algorithmus $A : \Sigma_1^* \rightarrow \Sigma_2^*$ ist eine Teilmenge aller Programme, wobei ein Program ein Algorithmus ist, sofern es für jede zulässige Eingabe eine Ausgabe liefert, es darf also nicht eine endlosschleife enthalten.
|
||||
|
||||
\begin{definition}[]{Entscheidungsproblem}
|
||||
Das \bi{Entscheidungsproblem} $(\Sigma, L)$ ist für jedes $x \in \Sigma^*$ zu entscheiden, ob $x \in L$ oder $x \notin L$.
|
||||
Ein Algorithmus $A$ löst $(\Sigma, L)$ (erkennt $L$) falls für alle $x \in \Sigma^*$: $A(x) = \begin{cases}
|
||||
1, &\text{ falls } x \in L\\
|
||||
0, &\text{ falls } x \notin L
|
||||
\end{cases}$.
|
||||
\end{definition}
|
||||
|
||||
\begin{definition}[]{Funktion}
|
||||
Algorithmus $A$ berechnet (realisiert) eine \bi{Funktion (Transformation)} $f: \Sigma^* \rightarrow \Gamma^*$ falls $A(x) = f(x) \smallhspace \forall x \in \Sigma^*$ für Alphabete $\Sigma$ und $\Gamma$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Berechnung}
|
||||
Sei $R \subseteq \Sigma^* \times \Gamma^*$ eine Relation in den Alphabeten $\Sigma$ und $\Gamma$.
|
||||
Ein Algorithmus $A$ \bi{berechnet} $R$ (\bi{löst das Relationsproblem} $R$) falls für jedes $x \in \Sigma^*$, für das ein $y \in \Gamma^*$ mit $(x, y) \in R$ existiert gilt:
|
||||
$(x, A(x)) \in R$
|
||||
\end{definition}
|
||||
@@ -0,0 +1,101 @@
|
||||
\newpage
|
||||
\subsection{Kolmogorov-Komplexität}
|
||||
\setLabelNumber{definition}{17}
|
||||
Falls ein Wort $x$ eine kürzere Darstellung hat, wird es \bi{komprimierbar genannt} und wir nennen die Erzeugung dieser Darstellung eine \bi{Komprimierung} von $x$.
|
||||
|
||||
Eine mögliche Idee, um den Informationsgehalt eines Wortes zu bestimmen, wäre einem komprimierbaren Wort einen kleinen Informationsgehalt zuzuordnen und einem unkomprimierbaren Wort einen grossen Informationsgehalt zuzuordnen.
|
||||
|
||||
Wenn wir also das Wort $011011011011011011011011$ haben, so kann man es auch als $(011)^8$ darstellen und hat so also einen kleineren Informationsgehalt als bspw. $0101101000101101001110110010$.
|
||||
|
||||
Die Idee mit der Komprimierung den Informationsgehalt zu bestimmen ist jedoch nicht ideal, da für jede Komprimierung bei unendlich langen Wörtern immer eine weitere Komprimierung existiert, die für unendlich viele Wörter besser geeignet ist.
|
||||
|
||||
Hier kommt die Kolmogorov-Komplexit zum Zuge: Sie bietet eine breit Gültige Definition des Komplexitätsmasses.
|
||||
|
||||
|
||||
\begin{definition}[]{Kolmogorov-Komplexität}
|
||||
Für jedes Wort $x \in \wordbool$ ist die \bi{Kolmogorov-Komplexität $K(x)$ des Wortes $x$} das Minimum der binären Längen der Pascal-Programme, die $x$ generieren.
|
||||
\end{definition}
|
||||
|
||||
Hierbei ist mit der binären Länge die Anzahl Bits gemeint, die beim Übersetzen des Programms in einen vordefinierten Maschinencode entsteht.
|
||||
|
||||
Ein Pascal-Programm in diesem Kurs ist zudem nicht zwingend ein Programm in der effektiven Programmiersprache Pascal, sondern eine Abwandlung davon, worin es auch erlaubt ist, gewisse Prozesse zu beschreiben und nicht als Code auszuformulieren, da das nicht das Ziel dieses Kurses ist.
|
||||
|
||||
|
||||
\begin{lemma}[]{Kolmogorov-Komplexität}
|
||||
Für jedes Wort $x \in \wordbool$ existiert eine Konstante $d$ so dass $K(x) \leq |x| + d$
|
||||
\end{lemma}
|
||||
\inlineproof Für jedes $x \in \wordbool$ kann folgendes Programm $A_x$ verwendet werden:
|
||||
|
||||
\begin{code}{pascal}
|
||||
$A_x$: begin
|
||||
write(x);
|
||||
end
|
||||
\end{code}
|
||||
Alle Teile, ausser $x$ sind dabei von konstanter Länge, also ist die Länge der Bit-repräsentation des Programms ausschliesslich von der binären Länge des Wortes $x$ abhängig.
|
||||
|
||||
\proven
|
||||
|
||||
|
||||
Für regelmässige Wörter gibt es natürlich Programme, bei denen das Wort nicht als komplette Variable vorkommt.
|
||||
Deshalb haben diese Wörter auch (meist) eine kleinere Kolmogorov-Komplexität.
|
||||
|
||||
|
||||
\fancydef{$K(n)$ für $n \in \N$} Die \bi{Kolmogorov-Komplexität einer natürlichen Zahl $n$} ist $K(n) = K(\text{Bin}(n))$,
|
||||
wobei $|\text{Bin}(x)| = \ceil{\log_2(x + 1)}$
|
||||
|
||||
\inlinelemma Für jede Zahl $n \in \N - \{ 0 \}$ existiert ein Wort $w_n \in (\alphabets{bool})^n$ so dass $K(w_n) \geq |w_n| = n$, oder in Worten, es existiert für jedes $n$ ein nicht komprimierbares Wort.
|
||||
|
||||
Eine wichtige Eigenschaft der Kolmogorov-Komplexität ist, dass sie nicht wirklich von der gewählten Programmiersprache abhängt.
|
||||
Man kann also beliebig auch \texttt{C++}, \texttt{Swift}, \texttt{Python}, \texttt{Java} oder welche auch immer, ohne dass die Kolmogorov-Komplexität um mehr als eine Konstante wächst (auch wenn diese bei \texttt{Java} sehr gross ist):
|
||||
|
||||
\begin{theorem}[]{Unterschiedliche Programmiersprachen}
|
||||
Für jede Programmiersprachen $A$ und $B$ existiert eine Konstante $c_{A,B}$, die nur von $A$ und $B$ abhängig ist, so dass für alle $x \in \wordbool$ gilt:
|
||||
\begin{align*}
|
||||
|K_A(x) - K_B(x)| \leq c_{A, B}
|
||||
\end{align*}
|
||||
\end{theorem}
|
||||
|
||||
\fhlc{orange}{Anwendungen der Kolmogorov-Komplexität}
|
||||
|
||||
\shade{orange}{Zufall} Der Zufall ist ein intuitiver, aber nicht sehr formeller Begriff, der mit der Kolmogorov-Komplexität formalisiert werden kann:
|
||||
\begin{definition}[]{Zufall}
|
||||
Ein Wort $x \in \wordbool$ (eine Zahl $n$) heisst \bi{zufällig}, falls $K(x) \geq |x|$ ($K(n) = K(\text{Bin}(n)) \geq \ceil{\log_2(n + 1)} - 1$)
|
||||
\end{definition}
|
||||
|
||||
\shade{orange}{Existenz eines Programms vs Kolmogorov-Komplexität}
|
||||
\begin{theorem}[]{Programm vs Komplexität}
|
||||
Sei $L$ eine Sprache über $\alphabets{bool}$ und für jedes $n \in \N - \{0\}$ sei $z_n$ das $n$-te Wort in $L$ bezüglich der kanonischen Ordnung.
|
||||
Falls ein Programm $A_L$ existiert, das das Entscheidungsproblem $(\alphabets{bool}, L)$ löst, so gilt für alle $n \in \N - \{ 0 \}$ dass
|
||||
\begin{align*}
|
||||
K(z_n) \leq \ceil{\log_2(n + 1)} + c & & (c \text{ ist eine von } n \text{ unabhängige Konstante })
|
||||
\end{align*}
|
||||
\end{theorem}
|
||||
|
||||
\shade{orange}{Primality testing}
|
||||
\begin{theorem}[]{Primzahlensatz}
|
||||
\vspace{-0.3cm}
|
||||
\begin{align*}
|
||||
\limni \frac{\text{Prim}(n)}{\frac{n}{\ln(n)}} = 1
|
||||
\end{align*}
|
||||
\end{theorem}
|
||||
Die Annäherung von $\text{Prim}(n)$ and $\frac{n}{\ln(n)}$ wird durch folgende Ungleichung gezeigt:
|
||||
\begin{align*}
|
||||
\ln(n) - \frac{3}{2} < \frac{n}{\text{Prim}(n)} < \ln(n) - \frac{1}{2} \smallhspace \forall n \geq 67 \in \N
|
||||
\end{align*}
|
||||
|
||||
\begin{lemma}[]{Anzahl Primzahlen mit Eigenschaften}
|
||||
Sei $n_1, n_2, \ldots$ eine stetig steigende unendliche Folge natürlicher Zahlen mit $K(n_i) \geq \frac{\ceil{\log_2(n_i)}}{2}$.
|
||||
Für jedes $i \in \N - \{ 0 \}$ sei $q_i$ die grösste Primzahl, die $n_i$ teilt.
|
||||
Dann ist die Menge $Q = \{ q_i \divides i \in \N - \{ 0 \} \}$ unendlich.
|
||||
\end{lemma}
|
||||
|
||||
Lemma 2.6 zeigt nicht nur, dass es unendlich viele Primzahlen geben muss, sondern sogar, dass die Menge der grössten Primzahlfaktoren einer beliebigen unendlichen Folge natürlicher Zahlen mit nichttrivialer Kolmogorov-Komplexität unendlich ist.
|
||||
|
||||
\begin{theorem}[]{Untere Schranke für Anzahl Primzahlen}
|
||||
Für unendlich viele $k \in \N$ gilt
|
||||
\begin{align*}
|
||||
\text{Prim}(k) \geq \frac{k}{2^{17} \log_2(k) \cdot (\log_2(\log_2(k)))^2}
|
||||
\end{align*}
|
||||
\end{theorem}
|
||||
|
||||
Der Beweis hierfür ist sehr ausführlich ab Seite 42 (= 57 im PDF) im Buch erklärt
|
||||
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
|
||||
52
semester3/ti/main/parts/03_turing_machines/00_intro.tex
Normal file
52
semester3/ti/main/parts/03_turing_machines/00_intro.tex
Normal file
@@ -0,0 +1,52 @@
|
||||
% Starts on Page 94 (= 108 in PDF)
|
||||
\subsection{Das Modell der Turingmaschine}
|
||||
Eine Turingmaschine (oft auch Turing-Maschine geschrieben) besteht informell aus
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item einer endlichen Kontrolle, die das Programm enthält
|
||||
\item einem Arbeitsband unendlicher Länge (das es Erlaubt, im Vergleich zum EA, Daten zu speichern)
|
||||
\item einem Lese-/Schreibkopf, der sich in beide Richtungen auf dem Band bewegen kann
|
||||
\end{enumerate}
|
||||
Formaler:
|
||||
\begin{definition}[]{Turingmaschine (TM)}
|
||||
Eine \bi{Turingmaschine} ist eine $7$-Tupel $M = (Q, \Sigma, \Gamma, \delta, q_0, \qacc, \qrej)$, wobei:
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item $Q$ ist die \bi{Zustandsmenge}
|
||||
\item $\Sigma$ ist das \bi{Eingabealphabet} mit $\cent, \textvisiblespace \notin \Sigma$
|
||||
\item $\Gamma$ ist das \bi{Arbeitsalphabet} mit $\Sigma \subseteq \Gamma$, $\cent, \textvisiblespace \in \Gamma$ und $\Gamma \cap Q = \emptyset$
|
||||
($\cent$ = Startmarker, $\textvisiblespace$ = Blanksymbol)
|
||||
\item $\delta : (Q - \{ \qacc, \qrej \}) \times \Gamma \longrightarrow Q \times \Gamma \times \{ L, R, N \}$ ist die \bi{Übergangsfunktion von $M$},
|
||||
wobei $\{ L, R, N \}$ die möglichen Bewegunsrichtungen des Lese-/Schreibkopfs sind
|
||||
und hat die Eigenschaft $\delta(q, \cent) \in Q \times \{ \cent \} \times \{ R, N \}$ für alle $q \in Q$
|
||||
\item $q_0$ ist der \bi{Anfangszustand}
|
||||
\item $\qacc$ ist der \bi{akzeptierende Zustand} (genau einer in jedem $M$)
|
||||
\item $\qrej$ ist der \bi{verwerfende Zustand} (genau einer in jedem $M$)
|
||||
\end{enumerate}
|
||||
Eine \bi{Konfiguration} $C$ von $M$ ist ein Element aus $\text{Konf}(M) = \{ \cent \} \cdot \Gamma^* \cdot Q \cdot \Gamma^+ \cup Q \cdot \{ \cent \} \cdot \Gamma^+$
|
||||
(wobei $\cdot$ die Konkatenation ist)
|
||||
|
||||
Eine \bi{Startkonfiguration} für ein Eingabewort $x$ ist $q_0\cent x$
|
||||
|
||||
Ein \bi{Schritt von $M$} ist eine Relation $\bigvdash{M}{}$ auf der Menge der Konfigurationen, also $\bigvdash{M}{} \subseteq \text{Konf}(M) \times \text{Konf}(M)$.
|
||||
|
||||
$\mathcal{L}_{RE} = \{ L(M) \divides M \text{ ist eine Turingmaschine} \}$
|
||||
|
||||
Der Rest der Definition findet sich auf Seiten 96 - 98 (= Seiten 110 - 112 im PDF)
|
||||
\end{definition}
|
||||
Turingmaschinen, die immer halten, repräsentieren Algorithmen, die immer terminieren und die richtige Ausgabe liefern.
|
||||
Rekursive Sprachen und entscheidbare Entscheidungsprobleme sind algorithmisch erkennbar, respektive lösbar.
|
||||
|
||||
Es gibt auch definitionen der TM, die ohne Startmarker $\cent$ auskommen, bei denen ist das Arbeitsband in beide Richtungen unendlich.
|
||||
|
||||
Graphisch stellt man Turingmaschinen folgendermassen dar:
|
||||
Wir haben wieder einen Graphen mit gerichteten Kanten.
|
||||
Für $\delta(q, a) = (p, b, X)$ mit $q, p \in Q$, $a, b \in \Sigma$ und $X \in \{ L, R, N \}$ werden die Kanten mit folgendem Format beschriftet:
|
||||
$q \rightarrow a, X$.
|
||||
|
||||
Mit einem TM die Sprache $\{ 0^n 1^n \divides n \in \N \}$ erkennen kann man nun, indem man jeweils das linkeste und rechteste Symbol durch ein anderes Symbol ersetzt,
|
||||
beispielsweise, wenn das Eingabealphabet $\Sigma = \{ 0, 1 \}$, dann könnte man $\Gamma$ das Symbol $2$ hinzufügen, mit dem man jedes bearbeitete Symbol ersetzt.
|
||||
|
||||
Im Buch wird als Beispiel auf Seite 99ff (= Seite 114ff im PDF) ein komplexeres Wort gewählt,
|
||||
bei welchem ein Zeichen $a \in \alphabetbool$ durch $(a, B) \in \alphabetbool \times \{ A, B \}$ ersetzt wird,
|
||||
da wir zwei Phasen haben und zwischen denen unterscheiden wollen können.
|
||||
|
||||
% 113
|
||||
@@ -0,0 +1,88 @@
|
||||
\newsection
|
||||
\subsection{Mehrband-Turingmaschinen und Church'sche These}
|
||||
Die Turingmaschinen sind das Standardmodell der Berechenbarkeitstheorie, aber benötigen einige Modifikationen, um wirklich geeignet zu sein
|
||||
(da das Von-Neumann Modell physisch unterschiedliche CPU, Eingabemedium und Speicher für Programme und Daten fordert, aber die TM ein gemeinsames Eingabemedium und Speicher hat).
|
||||
|
||||
Eine $k$-Band-Turingmaschine (für $k \in \N_0$) hat folgende Komponenten:
|
||||
\begin{itemize}
|
||||
\item eine endliche Kontrolle (= Programm)
|
||||
\item ein endliches Band mit einem Lesekopf
|
||||
\item $k$ Arbeitsbänder, jedes mit eigenem Lese-/Schreibkopf
|
||||
\end{itemize}
|
||||
Zu Beginn ist die MTM in folgender Situation:
|
||||
\begin{itemize}
|
||||
\item Das Eingabeband enthält $\cent w \$$, wobei $\cent$ und $\$$ die linke / rechte Seite der Eingabe markieren
|
||||
\item Der Lesekopf des Eingabebands zeigt auf $\cent$
|
||||
\item Alle Arbeitsbänder beinhalten $\cent \text{\textvisiblespace\textvisiblespace} \ldots$ und deren Lese-/Schreibköpfe zeigen auf $\cent$
|
||||
\item Die endliche Kontrolle ist im Anfangszustand $q_0$
|
||||
\end{itemize}
|
||||
Alle $k + 1$ Köpfe dürfen sich während der Berechnung in beide Richtungen bewegen (solange das nicht out-of-bounds geht).
|
||||
Zudem darf der Lesekopf nicht schreiben, also beleibt der Inhalt des Eingabebands gleich.
|
||||
|
||||
Gleich wie bei einer TM ist das Arbeitsalphabet der Arbeitsbänder $\Gamma$ und alle Felder der Arbeitsbänder sind von links nach rechts nummeriert, wobei $0$ bei $\cent$ liegt.
|
||||
|
||||
Eine Konfiguration einer $k$-Band-TM $M$ ist $(q, w, i, u_1, i_1, u_2, i_2, \ldots, u_k, i_k) \in Q \times \word \times \N \times (\Gamma^* \times \N)^k$,
|
||||
wobei $q$ der Zustand ist, der Inhalt des Eingabebands ist $\cent w \$$, der Lesekopf zeigt auf das $i$-te Feld,
|
||||
für $j \in \{ 1, 2, \ldots, k \}$ ist der Inhalt des $j$-ten Bandes $\cent u_k \text{\textvisiblespace} \ldots$ und $i_j \leq |u_j|$ ist die Position des Feldes.
|
||||
|
||||
Ein Berechnungsschritt von $M$ kann mit
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\delta: Q \times (\Sigma \cup \{ \cent, \$ \}) \times \Gamma^k \rightarrow Q \times \{ L, R, N \} \times (\Gamma \times \{ L, R, N \})^k
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
dargestellt werden, wobei die Argumente $(q, a, b_1, \ldots, b_k)$ der aktuelle Zustand $q$, das gelesene Eingabesymbol $a$ und die $k$ Symbole $b_i \in \Gamma$,
|
||||
auf welchen die Köpfe der Arbeitsbänder stehen.
|
||||
|
||||
Die Eingabe $w$ wird von $M$ akzeptiert, falls $M$ den Zustand $\qacc$ erreicht und falls $M$ den Zustand $\qrej$ erreicht oder nicht terminiert, wird die Eingabe verworfen.
|
||||
|
||||
\vspace{0.3cm}
|
||||
\hrule
|
||||
\vspace{0.2cm}
|
||||
|
||||
Wir sagen, dass eine Maschine $A$ äquivalent zu einer Maschine $B$ ist, falls für jede Eingabe $x \in \wordbool$ gilt:
|
||||
$A \text{ $<$property$>$ } x \Longleftrightarrow B \text{ $<$property$>$ } x$ mit
|
||||
$<$property$> \ \in \{ \text{akzeptiert}, \text{ verwrift}, \text{ arbeitet unendlich lange auf} \}$, also ist $L(A) = L(B)$
|
||||
|
||||
\inlinelemma Zu jeder TM $A$ existiert eine zu $A$ äquivalente $1$-Band-TM $B$
|
||||
|
||||
\inlinelemma Zu jeder Mehrband-Turingmaschine $A$ existiert eine zu $A$ äquivalente TM $B$
|
||||
|
||||
Die Beweise dazu finden sich auf Seite 107, beziehungsweise Seite 109 (= 121 \& 123 im PDF).
|
||||
|
||||
In diesem Kurs müssen wir glücklicherweise meist nicht Beweise der Äquivalenz durchführen, wie auch nicht dass die TM die gewünschte Tätigkeit realisiert.
|
||||
|
||||
\inlinedef Zwei Maschinenmodelle (Maschinenklassen) $\mathcal{A}$ und $\mathcal{B}$ sind äquivalent wenn beides zutrifft:
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item für jede Maschine $A \in \mathcal{A}$ eine zu $A$ äquivalente Maschine $B \in \mathcal{B}$ existiert
|
||||
\item für jede Maschine $C \in \mathcal{B}$ eine zu $C$ äquivalente Maschine $D \in \mathcal{A}$ existiert
|
||||
\end{enumerate}
|
||||
|
||||
\inlinetheorem Die Maschinenmodelle von Turingmaschinen und Mehrband-Turingmaschinen sind äquivalent
|
||||
|
||||
\inlineproof Impliziert von Lemmas \ref{lemma:4-1} und \ref{lemma:4-2}
|
||||
|
||||
Um zu beweisen, dass Turing-Maschinen äquivalent zu höheren Programmiersprachen sind argumentiert man über die Existenz eines Interpreters für TM.
|
||||
|
||||
|
||||
% ────────────────────────────────────────────────────────────────────
|
||||
\subsubsection{Church'sche These}
|
||||
\begin{center}
|
||||
\fbox{
|
||||
\parbox{16cm}{
|
||||
\textit{Die Turingmaschinen sind die Formalisierung des Begriffes ``Algorithmus'', das heisst,
|
||||
die Klasse der rekursiven Sprachen (der entscheidbaren Entscheidungsproblem)
|
||||
stimmt mit der Klasse der algorithmisch (automatisch) erkennbaren Sprache überein
|
||||
}
|
||||
}
|
||||
}
|
||||
\end{center}
|
||||
Die These ist nicht beweisbar, da dazu der Begriff des Algorithmus formalisiert werden müsste, was er bekanntlich nicht ist.
|
||||
|
||||
Dies führt zu einer interessanten Situation, in welcher es \textit{theoretisch} möglich wäre, dass jemand ein stärkeres Modell findet, als die TM sind,
|
||||
eines nämlich, welches Entscheidungsprobleme lösen kann, die die TM nicht kann.
|
||||
|
||||
Wir nehmen also (wie in vielen Bereichen der Physik (die Relativitätstheorie ist ein gutes Beispiel) und Mathematik) und postulieren sie als Axiom.
|
||||
|
||||
\shade{Orange}{Fun fact} Die Church'sche These ist das Einzige informatikspezifische Axiom.
|
||||
@@ -0,0 +1,43 @@
|
||||
\newpage
|
||||
\subsection{Nichtdeterministische Turingmaschinen}
|
||||
Die Ideen sind hier sehr ähnlich wie der Übergang zwischen deterministischen und nichtdeterministischen Endlichen Automaten.
|
||||
|
||||
\begin{definition}[]{Nichtdeterministische Turingmaschine (NTM)}
|
||||
\begin{scriptsize}
|
||||
Hier werden nur die wichtigsten Unterschiede aufgezeigt. Formale Definition auf Seiten 113ff. (= Seiten 127ff im PDF) im Buch.
|
||||
\end{scriptsize}
|
||||
|
||||
Die Übergangsfunktion geht wieder in die Potenzmenge, also gilt:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\delta : (Q - \{ \qacc, \qrej \}) \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times \{ L, R, N \})
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
und $\delta(p, \cent) \subseteq (\{ (q, \cent, X) \divides q \in Q, X \in \{R, N\} \})$\\
|
||||
|
||||
Die von der NTM $M$ akzeptierte Sprache ist:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
L(M) = \{ w \in \word \divides q_0\cent w \bigvdash{M}{*}y\qacc z \text{ für irgendwelche } y, z \in \Gamma^* \}
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
Ein gutes Beispiel für eine NTM findet sich auf Seiten 114ff. im Buch (= Seite 128ff. im PDF)
|
||||
|
||||
|
||||
\begin{definition}[]{Berechnungsbaum}
|
||||
Ein Berechnungsbaum $T_{M, x}$ von $M$ (eine NTM) auf $x$ (Wort aus Eingabealphabet von $M$) ist ein (potentiell un)gerichteter Baum mit einer Wurzel:
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item Jeder Knoten von $T_{M, x}$ ist mit einer Konfiguration beschriftet
|
||||
\item Die Wurzel ist der einzige Knoten mit $\deg_{\text{in}}(v) = 0$, ist die Startkonfiguration $q_0\cent x$
|
||||
\item Jeder mit $C$ beschriftete Knoten hat genauso viele Kinder wie $C$ Nachfolgekonfigurationen hat und die Kinder sind mit diesen Nachfolgekonfigurationen markiert.
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
Diese Bäume können natürlich auch für nichtdeterministischen MTM verwendet werden.
|
||||
|
||||
Im Vergleich zu den Berechnungsbäumen von NEA sind die Bäume von NTM nicht immer endlich.
|
||||
|
||||
\inlinetheorem Sei $M$ eine NTM. Dann existiert eine TM $A$, so dass $L(M) = L(A)$
|
||||
und falls $M$ keine unendlichen Berechnungen auf Wörtern aus $(L(M))^C$ hat, dann hält $A$ immer.
|
||||
|
||||
\inlineproof Auf Seite 117 im Buch (= 131 im PDF). Die Idee zur Umwandlung von $M$ in die TM $A$ ist, dass $A$ Breitensuche im Berechnungsbaum von $M$ durchführt.
|
||||
50
semester3/ti/main/parts/04_computability/00_intro.tex
Normal file
50
semester3/ti/main/parts/04_computability/00_intro.tex
Normal file
@@ -0,0 +1,50 @@
|
||||
\subsection{Diagonalisierung}
|
||||
Wir definieren $\text{KodTM}$ als die \textit{Menge der binären Kodierungen aller Turingmaschinen}.
|
||||
Wir haben $\text{KodTM} \subseteq \wordbool$ und die obere Schranke der Kardinalität ist $|\wordbool|$, da es unendlich viele Turingmaschinen gibt.
|
||||
|
||||
Im Folgenden wird wieder Cantor's Diagonalisierungsmethode verwendet
|
||||
\begin{recall}[]{Cantor's Diagonalization Argument}
|
||||
% TODO: Finish
|
||||
\TODO Finish
|
||||
\end{recall}
|
||||
|
||||
\inlinedef $A$ und $B$ sind Mengen. Dann ist $|A| \leq |B|$ falls eine \textit{injektive} Funktion $f$ von $A$ nach $B$ existiert;
|
||||
$|A| = |B|$ falls $|A| \leq |B|$ und $|B| \leq |A|$ (es existiert eine Bijektion);
|
||||
$|A| < |B|$ falls $|A| \leq |B|$ und keine injektive Abbildung von $B$ nach $A$ existiert.
|
||||
|
||||
Um zu zeigen, dass es nicht rekursiv aufzählbare (also von Turingmaschinen nicht erkennbare) Sprachen gibt.
|
||||
Also müssen wir laut Definition \ref{definition:5-1} nur zeigen, dass keine Injektion von $\wordbool$ nach $\mathcal{L}_{RE}$ existiert.
|
||||
|
||||
\fancydef{Abzählbarkeit} $A$ heisst abzählbar, falls $A$ endlich ist oder $|A| = |\N|$
|
||||
|
||||
\inlinelemma Sei $\Sigma$ ein beliebiges Alphabet. Dann ist $\word$ abzählbar
|
||||
|
||||
\inlinetheorem Die Menge $\text{KodTM}$ der Turingmaschinenkodierungen ist abzählbar
|
||||
|
||||
\inlinelemma $(\N - \{ 0 \}) \times (\N - \{ 0 \})$ ist abzählbar. Die Idee ist dieselbe wie für $|Q^+| = |\N|$, nämlich, dass wir jedem Element einen Index zuordnen können.
|
||||
|
||||
\inlinetheorem $\Q^+$ ist abzählbar. Die Idee für den Beweis ist eine Bijektion nach obiger Menge zu finden.
|
||||
|
||||
\inlinetheorem $[0, 1] \subseteq \R$ ist nicht abzählbar. Dies kann mit Cantor's Diagonalization Argument bewiesen werden.
|
||||
|
||||
\inlinetheorem $\mathcal{P}(\wordbool)$ ist nicht abzählbar
|
||||
|
||||
\inlinecorollary $|\text{KodTM}| < |\mathcal{P}(\wordbool)|$ und es existieren also unendlich viele nicht rekursiv aufzählbare Sprachen.
|
||||
|
||||
Um für eine spezifische Sprache zu beweisen, dass sie rekursiv aufzählbar ist, können wir einfach eine Turingmaschine konstruieren.
|
||||
Für eine Beweis dafür, dass eine Sprache nicht rekursiv aufzählbar ist können wir folgende Methode verwenden. Sei dazu mit $d_{ij} = 1 \Longleftrightarrow M_i \text{ akzeptiert } w_j$
|
||||
\begin{align*}
|
||||
L_{\text{diag}} & = \{ w \in \wordbool \divides w = w_i \text{ für ein } i \in \N - \{ 0 \} \text{ und } M_i \text{ akzeptiert } w_i \text{ nicht} \} \\
|
||||
& = \{ w \in \wordbool \divides w = w_i \text{ für ein } i \in \N - \{ 0 \} \text{ und } d_{ii} = 0 \}
|
||||
\end{align*}
|
||||
|
||||
\inlinetheorem $L_{\text{diag}} \notin \mathcal{L}_{RE}$
|
||||
\inlineproof Zum Widerspruch nehmen wir an, dass $L_\text{diag} \in \mathcal{L}_{RE}$.
|
||||
Dann gilt, dass $L_\text{diag} = L(M)$ für eine Turingmaschine $M$.
|
||||
$M$ ist eine Turingmaschine in der kanonischen Ordnung der Turingmaschinen, also existiert ein $i \in \N - \{ 0 \}$, so dass $M = M_i$.
|
||||
|
||||
Dies führt zu einem Widerspruch, denn $L_\text{diag}$ kann nicht gleich $L(M_i)$ sein, da
|
||||
\begin{align*}
|
||||
w_i \in L_\text{diag} \Longleftrightarrow d_{ii} = 0 \Longleftrightarrow w_i \notin L(M_i)
|
||||
\end{align*}
|
||||
also ist $w_i$ genau dann in $L_\text{diag}$ wenn $w_i$ \textit{nicht} in $L(M_i)$ ist. (= in genau einer der Sprachen $L_\text{diag}$ oder $L(M_i)$)
|
||||
75
semester3/ti/main/parts/04_computability/01_reduction.tex
Normal file
75
semester3/ti/main/parts/04_computability/01_reduction.tex
Normal file
@@ -0,0 +1,75 @@
|
||||
\newpage
|
||||
\subsection{Die Methode der Reduktion}
|
||||
% TODO: Add guide for reducing languages
|
||||
\fancydef{Rekursiv reduzierbare Sprache} Eine Sprache $L_1 \subseteq \word_1$ ist auf $L_2 \subseteq \word_2$ rekursiv reduzierbar, geschrieben $L_1 \leq_R L_2$,
|
||||
falls $L_2 \in \cL_R \Rightarrow L_1 \in \cL_R$.
|
||||
|
||||
\shade{teal}{Intuition:} $L_2$ ist bezüglich der algorithmischen Lösbarkeit mindestens so schwer wie $L_1$. $\cL_R$ ist die Menge aller rekursiv reduzierbaren Sprachen.
|
||||
Ist also $L_2$ lösbar, so muss auch $L_1$ lösbar sein.
|
||||
|
||||
\fancydef{EE-reduzierbare Sprache} $L_1$ ist auf $L_2$ \bi{EE-reduzierbar}, geschrieben $L_1 \leq_{EE} L_2$, wenn eine TM $M$ existiert,
|
||||
die eine Abbildung $f_M : \word_1 \rightarrow \word_2$ mit der Eigenschaft $x \in L_1 \Leftrightarrow f_M(x) \in L_2$ für alle $x \in \word_1$ berechnet.
|
||||
Anders ausgedrückt: die TM $M$ reduziert die Sprache $L_1$ auf die Sprache $L_2$
|
||||
|
||||
\inlinelemma Falls $L_1 \leq_{EE} L_2$, dann auch $L_1 \leq_R L_2$. \inlineproof Im Buch auf Seite 135 (= 148 im PDF)
|
||||
|
||||
Wir müssen also nur zeigen, dass $L_1 \leq_{EE} L_2$ um zu zeigen, dass $L_1 \leq_R L_2$
|
||||
|
||||
\inlinelemma Für jede Sprache $L \subseteq \word$ gilt: $L \leq_R L^C$ und $L^C \leq_R L$
|
||||
|
||||
\inlinecorollary $(L_\text{diag})^C \notin \cL_R$
|
||||
\inlineproof Folgt davon, dass $L_\text{diag} \notin \cL_{RE}$ (was heisst, dass $L_\text{diag} \notin \cL_R$)
|
||||
und nach Lemma 5.4 $L_\text{diag} \leq_R (L_\text{diag})^C$ und das umgekehrte gelten muss.
|
||||
|
||||
\inlinelemma $(\ldiag)^C \in \cL_{RE}$
|
||||
\inlineproof Auf Seite 137 (= 150 im PDF) wird eine Turingmaschine aufgezeigt, die $(L_\text{diag})^C$ akzeptiert.
|
||||
|
||||
\inlinecorollary $(\ldiag)^C \in \cL_{RE} - \cL_R$ und daher $\cL_R \subsetneq \cL_{RE}$
|
||||
|
||||
Folgende Sprachen sind nicht rekursiv, liegen aber in $\cL_{RE}$
|
||||
|
||||
\fancydef{Universelle Sprache} $L_U = \{ \text{Kod}(M)\# w \divides w \in \wordbool \text{ und TM } M \text{ akzeptiert } w \}$
|
||||
|
||||
\fancytheorem{Universelle TM} Eine TM $U$, so dass $L(U) = L_U$, also gilt $L_U \in \cL_{RE}$\\
|
||||
%
|
||||
\inlineproof Auf Seite 138 (= 151 im PDF)
|
||||
|
||||
Was dies bedeutet, es existiert eine TM ohne Haltegarantie, die eine beliebige Turingmaschine auf einer gegebenen Eingabe simulieren kann.
|
||||
Untenstehendes Resultat bedeutet, dass man das Resultat der Berechnung einer TM $M$ auf einer Eingabe $x$ anders berechnen kann, als die Berechnung von $M$ auf $x$ zu simulieren.
|
||||
|
||||
\inlinetheorem $L_U \notin \cL_R$
|
||||
|
||||
Wenn jetzt aber $M$ unendlich lange auf $x$ arbeitet, so wissen wir nicht, ob wir die Simulation beenden können. Dies führt zum Halteproblem
|
||||
|
||||
\begin{definition}[]{Halteproblem}
|
||||
Das Halteproblem ist das Entscheidungsproblem $(\{ 0, 1, \# \}, L_H)$ mit
|
||||
\begin{align*}
|
||||
L_H = \{ \text{Kod}(M)\# x \divides x \in \{ 0, 1 \}^* \text{ und } M \text{ hält auf } x \}
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
|
||||
Dies scheint vorerst nicht ein allzu grosses Problem zu sein, jedoch besagt das nächste Resultat, dass es keinen Algorithmus gibt,
|
||||
der testen kann, ob ein gegebenes Programm immer terminiert.
|
||||
|
||||
\inlinetheorem $L_H \notin \cL_R$
|
||||
\inlineproof Auf Seiten 140 - 142 (153 - 155 im PDF)
|
||||
|
||||
Betrachten wir die Sprache $\lempty = \{ \text{Kod}(M) \divides L(M) = \emptyset \}$, die die Kodierungen aller Turingmaschinen enthält,
|
||||
die die leere Menge (kein Wort) akzeptieren. Es gilt
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
(\lempty)^C = \{ x \in \wordbool \divides x \notin \text{Kod}(\overline{M}) \forall \text{ TM } \overline{M} \text{ oder } x = \text{Kod}(M) \text{ und } L(M) \neq \emptyset \}
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
\inlinelemma $(\lempty)^C \in \cL_{RE}$
|
||||
\inlineproof Auf Seiten 142 - 143 (155 - 156 im PDF)
|
||||
|
||||
\inlinelemma $(\lempty)^C \notin \cL_R$
|
||||
|
||||
Wir haben als wiederum die Nichtexistenz eines Algorithmus zur Überprüfung, ob ein gegebenes Programm die leere Menge akzeptiert.
|
||||
Ein Beweis dazu findet sich auf Seiten 143 und 144 im Buch (156 - 157 im PDF)
|
||||
|
||||
\inlinecorollary $\lempty \notin \cL_R$
|
||||
|
||||
\inlinecorollary $L_{EQ} = \{ \text{Kod}(M)\# \text{Kod}(\overline{M}) \divides L(M) = L(\overline{M}) \}$ ist nicht entscheidbar (also $L_{EQ} \notin \cL_R$)
|
||||
18
semester3/ti/main/parts/04_computability/02_rice.tex
Normal file
18
semester3/ti/main/parts/04_computability/02_rice.tex
Normal file
@@ -0,0 +1,18 @@
|
||||
\subsection{Der Satz von Rice}
|
||||
\inlinedef $L$ heisst \bi{semantisch nichttriviales Entscheidungsproblem über Turingmaschinen}, falls folgende Bedingungen gelten:
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item Es gibt eine TM $M_1$, so dass $\text{Kod}(M_1) \in L$ (also $L \neq \emptyset$)
|
||||
\item Es gibt eine TM $M_2$, so dass $\text{Kod}(M_2) \notin L$ (also sind nicht alle Kodierungen in $L$)
|
||||
\item für zwei TM $A$ und $B$: $L(A) = L(B) \Rightarrow \text{Kod}(A) \in L \Leftrightarrow \text{Kod}(B) \in L$
|
||||
\end{enumerate}
|
||||
|
||||
Sei $L_{H, \lambda} = \{ \text{Kod}(M) \divides M \text{ hält auf } \lambda \}$ ein spezifisches Halteproblem.
|
||||
|
||||
\inlinelemma $L_{H, \lambda} \notin \cL_R$
|
||||
\inlineproof Auf Seite 146 im Buch (= 159 im PDF)
|
||||
|
||||
\begin{theorem}[]{Satz von Rice}
|
||||
Jedes semantisch nichttriviale Entscheidungsproblem über Turingmaschinen ist unentscheidbar.
|
||||
\end{theorem}
|
||||
\inlineproof Ausführlich im Buch auf Seiten 146 - 149 beschrieben (= 159 - 162 im PDF)
|
||||
\stepcounter{subsection}
|
||||
@@ -0,0 +1,6 @@
|
||||
\subsection{Die Methode der Kolmogorov-Komplexität}
|
||||
\inlinetheorem Das Probelem, für jedes $x \in \wordbool$ die Kolmogorov-Komplexität $K(x)$ von $x$ zu berechnen ist algorithmisch unlösbar.
|
||||
|
||||
\inlinelemma Falls $L_H \in \cL_R$, dann existiert ein Algorithmus zur Berechnung der Kolmogorov-Komplexität $K(x)$ für jedes $x\in \wordbool$
|
||||
|
||||
% TODO: See if we need to do these kinds of proofs and if so, elaborate
|
||||
61
semester3/ti/main/parts/05_complexity/00_intro.tex
Normal file
61
semester3/ti/main/parts/05_complexity/00_intro.tex
Normal file
@@ -0,0 +1,61 @@
|
||||
\subsection{Komplexitätsmasse}
|
||||
\begin{definition}[]{Zeitkomplexität}
|
||||
Sei $M$ eine Mehrband-TM oder TM, die immer hält, $x \in \word$ und $D = C_1, C_2, \ldots, C_k$ die Berechnung von $M$ auf $x$, deren Zeitkomplexität definiert ist durch:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\tc_M(x) = k - 1
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
also durch die Anzahl der Berechnungsschritte in $D$
|
||||
Die Zeitkomplexität der TM $M$ ist dabei definiert durch:
|
||||
\drmvspace
|
||||
\begin{align*}
|
||||
\tc_M(n) = \max\{ \tc_M(x) \divides x \in \Sigma^n \}
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
Wir können weiterhin die big-O-notation verwenden um den Worstcase anzugeben.
|
||||
|
||||
\begin{definition}[]{Speicherplatzkomplexität}
|
||||
Sei $C = (q, x, i, \alpha_1, i_1, \alpha_2, i_2, \ldots, \alpha_k, i_k)$ mit $0 \leq i \leq |x| + 1$ und $0 \leq i_j \leq |\alpha_j|$
|
||||
für $j = 1, \ldots, k$ eine Konfiguration von $M$, welche eine $k$-Band TM ist.
|
||||
\bi{Die Speicherplatzkomplexität von} $C$ ist
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\spc_M(C) = \max\{ |\alpha_i| \divides i = 1, \ldots, k \}
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
Für die Berechnung $C_1, C_2, \ldots, C_l$ von $M$ auf $x$ haben wir:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\spc_M(x) = \max\{ \spc_M(C_i) \divides i = 1, \ldots, l \}
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
Und die \bi{Speicherplatzkomplexität von} $M$ ist
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\spc_M(n) = \max\{ \spc_M(x) \divides x \in \Sigma^n \}
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
Es ist auch möglich $\spc_M(n)$ als eine Summe zu definieren, aber laut Lemma \ref{lemma:4-2} wissen wir, dass man eine $k$-Band-TM mit einer $1$-Band-TM simulieren kann.
|
||||
|
||||
\inlinelemma Sei $k \in \N$. Für jede $k$-Band-TM $A$, die immer hält existiert eine äquivalente $1$-Band-TM $B$, so dass $\spc_B(n) \leq \spc_A(n)$
|
||||
|
||||
\inlinelemma Für jede $k$-Band-TM $A$, existiert eine äquivalente $k$-Band-TM $B$, so dass $L(A) = L(B)$ und $\spc_B(n) \leq \frac{\spc_A(n)}{2} + 2$
|
||||
|
||||
\inlinedef Wir notieren mit der big-O-notation folgendermassen: Falls $r \in \tco{f(n)}$, so wächst $r$ asymptotisch nicht schneller als $f$.
|
||||
Äquivalent für $s \in \tcl{g(n)}$ und $l \in \tct{h(n)}$ sagen wir asymptotisch mindestens so (gleich) schnell.
|
||||
Falls $\limni \frac{f(n)}{g(n)} = 0$, dann wächst $g$ asymptotisch schneller als $f$ und $f(n) = o(g(n))$
|
||||
% TODO: Check if above really is a typo (pretty sure it is)
|
||||
|
||||
\inlinetheorem Es existiert ein Entscheidungsproblem $(\alphabetbool, L)$, so dass für jede MTM $A$, die $(\alphabetbool, L)$ entscheidet,
|
||||
eine MTM $B$ existiert, die es auch entscheidet und für die gilt: $\tc_B(n) \leq \log_2(\tc_A(n))$ für alle $n \in \N$
|
||||
|
||||
\begin{definition}[]{Schranken, Optimal}
|
||||
$\tco{g(n)}$ ($\tcl{f(n)}$) ist eine \bi{obere (untere) Schranke für die Zeitkomplexität von} $L$,
|
||||
falls eine MTM $A$ ($B$) existiert, die $L$ entscheidet und $\tc_A(n) \in \tco{g(n)}$ ($\tc_B(n) \in \tcl{f(n)}$)
|
||||
|
||||
Eine MTM $C$ heisst \bi{optimal für} $L$, falls $\tc_C(n) \in \tco{f(n)}$ gilt und $\tcl{f(n)}$ eine untere Schranke für die Zeitkomplexität von $L$ ist.
|
||||
\end{definition}
|
||||
84
semester3/ti/main/parts/05_complexity/01_class_p.tex
Normal file
84
semester3/ti/main/parts/05_complexity/01_class_p.tex
Normal file
@@ -0,0 +1,84 @@
|
||||
\newpage
|
||||
\subsection{Komplexitätsklassen und die Klasse P}
|
||||
\begin{definition}[]{Komplexitätsklasen}
|
||||
Für alle Funktionen $f, g : \N \rightarrow \R^+$ definieren wir:
|
||||
\begin{align*}
|
||||
\text{TIME}(f) & = \{ L(B) \divides B \text{ ist eine MTM mit } \tc_B(n) \in \tco{f(n)} \} \\
|
||||
\text{SPACE}(g) & = \{ L(A) \divides A \text{ ist eine MTM mit } \spc_A(n) \in \tco{g(n)} \} \\
|
||||
\text{DLOG} & = \text{SPACE}(\log_2(n)) \\
|
||||
\text{P} & = \bigcup_{c \in \N} \text{TIME}(n^c) \\
|
||||
\text{PSPACE} & = \bigcup_{c \in \N} \text{SPACE}(n^c) \\
|
||||
\text{EXPTIME} & = \bigcup_{d \in \N} \text{TIME}(2^{n^d})
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
|
||||
\inlinelemma Für alle $t : \N \rightarrow \R^+$ gilt $\text{TIME}(t(n)) \subseteq \text{SPACE}(t(n))$
|
||||
\inlinecorollary $\text{P} \subseteq \text{PSPACE}$
|
||||
|
||||
\begin{definition}[]{Platz- und Zeitkonstruierbarkeit}
|
||||
Eine Funktion $s : \N \rightarrow \N$ heisst \bi{platzkonstruierbar}, falls eine $1$-Band-TM $M$ existiert, so dass
|
||||
\begin{enumerate}
|
||||
\item $\spc_M(n) \leq s(n) \smallhspace \forall n \in \N$
|
||||
\item für jede Eingabe $0^n$ für $n \in \N$, generiert $M$ das Wort $0^{s(n)}$ auf ihrem Arbeitsband und hält in $\qacc$
|
||||
\end{enumerate}
|
||||
|
||||
\vspace{0.25cm}
|
||||
|
||||
Eine Funktion $t : \N \rightarrow \N$ heisst \bi{zeitkonstruierbar}, falls eine MTM $A$ existiert, so dass
|
||||
\begin{enumerate}
|
||||
\item $\tc_A(n) \in \tco{t(n)}$
|
||||
\item für jede Eingabe $0^n$ für $n \in \N$, generiert $A$ das Wort $0^{t(n)}$ auf dem ersten Arbeitsband und hält in $\qacc$
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
Wichtig ist, dass wir hier nicht \textit{zwingend} eine $1$-Band-TM konstruieren müssen, eine MTM geht auch.
|
||||
|
||||
\inlinelemma Sei $s$ platzkonstruierbar und $M$ eine MTM mit $\spc_M(x) \leq s(|x|) \ \forall x \in L(M)$.
|
||||
Dann existiert MTM $A$ mit $L(A) = L(M)$ und $\spc_A(n) \leq s(n)$, es gilt also $\spc_A(y) \leq s(|y|) \ \forall y \in \Sigma_M$
|
||||
|
||||
\inlinelemma Sei $t$ zeitkonstruierbar und $M$ eine MTM mit $\tc_M(x) \leq t(|x|) \ \forall x \in L(M)$.
|
||||
Dann existiert eine MTM $A$ mit $L(A) = L(M)$ und $\tc_A(n) \in \tco{t(n)}$
|
||||
|
||||
\inlinetheorem Für jede Funktion $s$ mit $s(n) \geq \log_2(n)$ gilt $\text{SPACE}(s(n)) \subseteq \bigcup_{c\in \N} \text{TIME}(c^{s(n)})$
|
||||
|
||||
Obiger Satz trifft auch für $s(n)$-platzbeschränkten TM zu, die nicht halten, aber nur, wenn $s(n)$ platzkonstruierbar ist.
|
||||
|
||||
\inlinecorollary $\text{DLOG} \subseteq \text{P}$ und $\text{PSPACE} \subseteq \text{EXPTIME}$
|
||||
|
||||
Die Korollare \ref{corollary:6-1} und \ref{corollary:6-2} geben zusammen $\text{DLOG} \subseteq \text{P} \subseteq \text{PSPACE} \subseteq \text{EXPTIME}$
|
||||
|
||||
|
||||
\inlinetheorem Für $s_1, s_2 : \N \rightarrow \N$ mit folgenden Eigenschaften:
|
||||
\drmvspace
|
||||
\begin{multicols}{3}
|
||||
\begin{enumerate}
|
||||
\item $s_2(n) \geq \log_2(n)$
|
||||
\item $s_2$ ist platzkonstruierbar
|
||||
\item $s_1(n) = o(s_2(n))$
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
|
||||
\drmvspace\rmvspace
|
||||
Dann gilt: $\text{SPACE}(s_1) \subsetneq \text{SPACE}(s_2)$
|
||||
|
||||
|
||||
\inlinetheorem Für $t_1, t_2 : \N \rightarrow \N$ mit folgenden Eigenschaften:
|
||||
\drmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{enumerate}
|
||||
\item $t_2$ ist platzkonstruierbar
|
||||
\item $t_1(n) \cdot \log_2(t_1(n)) = o(t_2(n))$
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
|
||||
\drmvspace\rmvspace
|
||||
Dann gilt: $\text{TIME}(s_1) \subsetneq \text{TIME}(s_2)$
|
||||
|
||||
In den Sechzigerjahren entstand folgende ``Definition'' von parktisch lösbaren Problemen:
|
||||
\begin{center}
|
||||
\fbox{
|
||||
\parbox{16cm}{
|
||||
\textit{Ein Problem ist praktisch lösbar genau dann, wenn ein polynomialer Algorithmus zu seiner Lösung existiert.
|
||||
Die Klasse P ist die Klasse der praktisch entscheidbaren Probleme}
|
||||
}
|
||||
}
|
||||
\end{center}
|
||||
@@ -0,0 +1,65 @@
|
||||
\newpage
|
||||
\subsection{Nichtdeterministische Komplexitätsmasse}
|
||||
|
||||
\begin{definition}[]{Zeit- und Speicherkomplexität}
|
||||
Sei $M$ eine NMTM oder MTM und $x \in L(M) \subseteq \word$. $\tc_M(x)$ ist die länge einer kürzesten akzeptierenden Berechnung von $M$ auf $x$
|
||||
und $\tc_M(n) = \max(\{ \tc_M(x) \divides x \in L(M) \text{ und }|x| = n \} \cup \{ 0 \} )$.
|
||||
|
||||
\vspace{0.25cm}
|
||||
|
||||
$\spc_M(C_i)$ ist die Speicherkomplexität von Konfiguration $C_i$ und $\spc_M(C) = \max\{ \spc_M(C_i) \divides i = 1, 2, \ldots, m \}$.
|
||||
Zudem ist $\spc_M(x) = \min\{ \spc_M(C) \divides C \text{ ist akzeptierende Berechnung von $M$ auf } x \}$.
|
||||
Ausserdem ist $\spc_M(n) = \max(\{ \spc_M(x) \divides x \in L(M) \text{ und } |x| = n \} \cup \{ 0 \})$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{definition}[]{Komplexitätsklassen}
|
||||
Für alle $f, g : \N \rightarrow \R^+$ definieren wir:
|
||||
\begin{align*}
|
||||
\text{NTIME}(f) & = \{ L(M) \divides M \text{ ist eine NMTM mit } \tc_M(n) \in \tco{f(n)} \} \\
|
||||
\text{NSPACE}(g) & = \{ L(M) \divides M \text{ ist eine NMTM mit } \spc_M(n) \in \tco{g(n)} \} \\
|
||||
\text{NLOG} & = \text{NSPACE}(\log_2(n)) \\
|
||||
\text{NP} & = \bigcup_{c \in \N} \text{NTIME}(n^c) \\
|
||||
\text{NPSPACE} & = \bigcup_{c \in \N} \text{NSPACE}(n^c)
|
||||
\end{align*}
|
||||
\end{definition}
|
||||
|
||||
|
||||
\inlinelemma Für alle $t$ und $s$ mit $s(n) \geq \log_2(n)$ gilt: $\text{NTIME}(t) \subseteq \text{NSPACE}(t)$, $\text{NSPACE}(s) \subseteq \bigcup_{c \in \N} \text{NTIME}(c^{s(n)})$
|
||||
|
||||
\inlinetheorem Für jedes $t : \N \rightarrow \R^+$ und jedes platzkonstruierbare $s$ mit $s(n) \geq \log_2(n)$ gilt:
|
||||
\rmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item $\text{TIME}(t) \subseteq \text{NTIME}(t)$
|
||||
\item $\text{SPACE}(t) \subseteq \text{NSPACE}(t)$
|
||||
\item $\text{NTIME}(s(n)) \subseteq \text{SPACE}(s(n)) \subseteq \bigcup_{c \in \N} \text{TIME}(c^{s(n)})$
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
|
||||
\drmvspace
|
||||
\inlinecorollary $\text{NP} \subseteq \text{PSPACE}$
|
||||
|
||||
\inlinetheorem Für jede platzkonstruierbare Funktion $s$ mit $s(n) \geq \log_2(n)$ gilt
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\text{NSPACE}(s(n)) \subseteq \bigcup_{c \in \N} \text{TIME}(c^{s(n)})
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
\inlinecorollary $\text{NLOG} \subseteq \text{P}$ und $\text{NPSPACE} \subseteq \text{EXPTIME}$
|
||||
|
||||
|
||||
\fancytheorem{Satz von Savitch} Sei $s$ mit $s(n) \geq \log_2(n)$ eine platzkonstruierbare Funktion. Dann gilt:
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\text{NSPACE}(s(n)) \subseteq \text{SPACE}(s(n)^2)
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
\inlinecorollary $\text{PSPACE} = \text{NPSPACE}$
|
||||
|
||||
Aus den obigen Resultaten resultiert die Komplexitätsklassenhierarchie der sequentiellen Berechnungen:
|
||||
\begin{align*}
|
||||
\text{DLOG} \subseteq \text{NLOG} \subseteq \text{P} \subseteq \text{NP} \subseteq \text{PSPACE} \subseteq \text{EXPTIME}
|
||||
\end{align*}
|
||||
35
semester3/ti/main/parts/05_complexity/03_class-np.tex
Normal file
35
semester3/ti/main/parts/05_complexity/03_class-np.tex
Normal file
@@ -0,0 +1,35 @@
|
||||
\newpage
|
||||
\subsection{Die Klasse NP und Beweisverifikation}
|
||||
Da praktische Lösbarkeit eines Problems mit polynomieller Zeit verbunden wird, ist es wichtig zu wissen, welche Probleme in polynomieller Zeit lösbar sind und welche nicht.
|
||||
|
||||
Der Vergleich zwischen den Klassen $P$ und $NP$ ist äquivalent zu der Frage, ob es einfacher ist, gegebene Beweise zu verifizieren, als sie herzustellen.
|
||||
|
||||
Betrachten wir folgendes: Sei $L = SAT$, wobei
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
SAT = \{ x \in \words{logic} \divides x \text{ kodiert eine erfüllbare Formel in CNF} \}.
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
Dann ist die Aussage $\Phi \in SAT$ äquivalent zu der Behauptung ``$\Phi$ ist eine erfüllbare Formel in CNF''
|
||||
|
||||
Für nichtdeterministische Berechnungen nennen wir $\alpha_1, \ldots, \alpha_n$ \bi{Zertifikate} für eine Aussage $\Xi$, falls für diese $\Xi(\alpha_1, \ldots, \alpha_n)$ hält.
|
||||
|
||||
\begin{definition}[]{Verifizierer}
|
||||
Sei $L \subseteq \word$ und $p : \N \rightarrow \N$.
|
||||
Eine MTM $A$ ist ein $p$-Verifizierer und $V(A) = L$, falls $A$ mit folgenden Eigenschaften auf allen Eingaben aus $\word \times \wordbool$ arbeitet:
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item $\tc_A(w, x) \leq p(|w|)$ für jede Eingabe $(w, x) \in \word \times \wordbool$
|
||||
\item Für jedes $w \in L$ existiert ein $x \in \wordbool$, so dass $|x| \leq p(|w|)$ und $(w, x) \in L(A)$. $x$ ist \bi{Zeugen} (oder \bi{Beweis}) der Behauptung $w \in L$
|
||||
\item Für jedes $y \notin L$ gilt $(y, z) \notin L(A)$ für alle $z \in \wordbool$
|
||||
\item Falls $p(n) \in \tco{n^k}$ für ein $k \in \N$, so ist $p$ ein \bi{Polynomialzeit-Verifizierer}. Die Klasse ist
|
||||
\vspace{-0.8pc}
|
||||
\begin{align*}
|
||||
VP = \{ V(A) \divides A \text{ ist ein Polynomialzeit-Verifizierer } \}
|
||||
\end{align*}
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
|
||||
\inlinetheorem $VP = NP$
|
||||
|
||||
Der Beweis für obiges Resultat ist auf Seiten 193 - 194 im Buch (= 205 - 206 im PDf) zu finden
|
||||
124
semester3/ti/main/parts/05_complexity/04_np-completeness.tex
Normal file
124
semester3/ti/main/parts/05_complexity/04_np-completeness.tex
Normal file
@@ -0,0 +1,124 @@
|
||||
\newpage
|
||||
\subsection{NP-Vollständigkeit}
|
||||
Es sind mittlerweile über 3000 Probleme bekannt, für welche wir keinen Algorithmus kennen, der in polynomieller Zeit läuft.
|
||||
Es ist aber bis jetzt niemandem gelungen, eine höhere untere Schranke für alle zu beweisen, als $\tcl{n}$.
|
||||
|
||||
Wie bereits bei der Berechenbarkeit benutzen wir eine Reduktion.
|
||||
Falls jedes Problem aus $NP$ effizient auf ein Problem $L \in NP$ reduzierbar ist, so ist $L$ schwer.
|
||||
|
||||
\begin{definition}[]{Polynomielle Reduktion}
|
||||
$L_1 \subseteq \word_1$ ist \bi{polynomiell reduzierbar auf} $L_2 \subseteq \word_2$, geschrieben $L_1 \leq_p L_2$,
|
||||
falls eine polynomielle TM $A$ existiert, die für jedes Wort $x \in \word_1$ ein Word $A(x) \in \word_2$ berechnet, so dass
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
x \in L_1 \Longleftrightarrow A(x) \in L_2
|
||||
\end{align*}
|
||||
|
||||
\drmvspace
|
||||
$A$ wird eine polynomielle Reduktion von $L_1$ auf $L_2$ genannt.
|
||||
\end{definition}
|
||||
Wieder bedeutet $L_1 \leq_p L_2$, dass $L_2$ mindestens so schwer ist wie $L_1$
|
||||
|
||||
\begin{definition}[]{$NP$-Schwer}
|
||||
Eine Sprache $L$ ist \bi{$NP$-Schwer}, falls für alle $L' \in NP$ gilt $L' \leq_p L$.
|
||||
|
||||
Eine Sprache $L$ ist \bi{$NP$-Vollständig}, falls
|
||||
\drmvspace
|
||||
\begin{multicols}{2}
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $L \in NP$
|
||||
\item $L$ $NP$-Schwer ist.
|
||||
\end{enumerate}
|
||||
\end{multicols}
|
||||
\end{definition}
|
||||
|
||||
|
||||
\inlinelemma Falls $L \in P$ und $L$ ist $NP$-schwer, dann gilt $P = NP$
|
||||
|
||||
\fancytheorem{Cook} $SAT$ ist $NP$-Vollständig
|
||||
|
||||
Der Beweis hierfür liefert eine grobe Struktur für weitere Beweise dieser Art und ist auf Seiten 199 - 205 im Buch (= Seiten 211 - 217 im PDF) zu finden.
|
||||
Jedoch sind diese Beweise sehr gross und deshalb nicht prüfungsrelevant.
|
||||
|
||||
|
||||
\inlinelemma Falls $L_1 \leq_p L_2$ und $L_1$ ist $NP$-Schwer, so ist auch $L_2$ $NP$-Schwer
|
||||
|
||||
Betrachten wir folgende Sprachen:
|
||||
\begin{align*}
|
||||
SAT & = \{ \Phi \divides \Phi \text{ ist eine erfüllbare Formel in CNF} \} \\
|
||||
CLIQUE & = \{ (G, k) \divides G \text{ ist ein ungerichteter Graph, der eine $k$-clique enthält} \} \\
|
||||
VC & = \{ (G, k) \divides G \text{ ist ein ungerichteter Graph mit einer Kontenüberdeckung der Mächtigkeit höchstens } k \}
|
||||
\end{align*}
|
||||
Wir erinnern uns daran, dass eine Kontenüberdeckung eines Graphen $G = (V, E)$ jede Menge von Konten $U \subseteq V$ ist,
|
||||
so dass jede Kante aus $E$ mindestens einen Endpunkt in $U$ hat.
|
||||
|
||||
\inlinelemma $SAT \leq_p CLIQUE$
|
||||
|
||||
\inlinelemma $CLIQUE \leq_p VC$
|
||||
|
||||
\inlinelemma $SAT \leq_p 3SAT$, wobei wir beim $3SAT$-Problem bestimmen wollen, ob eine Formel in $3CNF$ (CNF, aber alle Klauseln enthalten höchstens $3$ Variabeln) erfüllbar ist.
|
||||
|
||||
|
||||
\begin{definition}[]{$NPO$}
|
||||
$NPO$ ist die Klasse der Optimierungsprobleme, mit $U = (\Sigma_I, \Sigma_O, L, \cM, \text{cost}, \text{goal}) \in NPO$, falls folgende Bedingungen erfüllt sind:
|
||||
\begin{enumerate}[label=\textit{(\roman*)}]
|
||||
\item $L \in P$
|
||||
\item Es existiert ein Polynom $p_U$, so dass
|
||||
\begin{enumerate}[label=(\alph*)]
|
||||
\item Für jedes $x \in L$ und jedes $y \in \cM(x)$, $|y| \leq p_U(|x|)$
|
||||
\item es existiert ein polynomieller Algorithmus $A$, der für jedes $y \in \word_O$ und jedes $x \in L$ mit $|y| \leq p_U(|x|)$ entscheidet,
|
||||
ob $y \in \cM(x)$ oder nicht
|
||||
\end{enumerate}
|
||||
\item Die Funktion $\text{cost}$ kann man in polynomieller Zeit berechnen.
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
|
||||
\newpage
|
||||
Ein Optimierungsproblem $U$ ist also in $NPO$, falls
|
||||
\rmvspace
|
||||
\begin{enumerate}[noitemsep]
|
||||
\item man effizient überprüfen kann, ob ein gegebenes Wort ein Problemfall von $U$ ist
|
||||
\item die Grösse der Lösungen polynomiell in der Grösse des Problemfalls (Eingabe) und in polynomieller Zeit verifizert werden kann,
|
||||
ob $y$ eine zulässige Lösung für einen gegebenen Problemfall ist
|
||||
\item man die Kosten der zulässigen Lösung effizient berechnen kann
|
||||
\end{enumerate}
|
||||
|
||||
$\text{MAX-SAT}$ liegt in $NPO$
|
||||
|
||||
\begin{definition}[]{PO}
|
||||
$PO$ ist die Klasse von Optimierungsproblemen $U = (\Sigma_I, \Sigma_O, L, \cM, \text{cost}, \text{goal})$, so dass
|
||||
\begin{enumerate}[label=(\roman*)]
|
||||
\item $U \in NPO$
|
||||
\item $\exists$ polynomieller Algorithmus $A$, so dass $A(x)$ für jedes $x \in L$ die optimale Lösung für $x$ ist.
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
|
||||
\begin{definition}[]{Schwellenwert-Sprache}
|
||||
Die Schwellenwert-Sprache für $U$ (ein Optimierungsproblem aus $NPO$) ist
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\text{Lang}_U = \{ (x, a) \in L \times \wordbool \divides \text{Opt}_U(x) \leq \text{Nummer}(a) \}
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
mit $\text{Opt}_U(x)$ die optimale Lösung, falls $\text{goal} = \text{Minimum}$, und
|
||||
\rmvspace
|
||||
\begin{align*}
|
||||
\text{Lang}_U = \{ (x, a) \in L \times \wordbool \divides \text{Opt}_U(x) \leq \text{Nummer}(a) \}
|
||||
\end{align*}
|
||||
|
||||
\rmvspace
|
||||
falls $\text{goal} = \text{Maximum}$
|
||||
|
||||
Wir sagen, dass $U$ \bi{NP-schwer} ist, falls $\text{Lang}_U$ NP-schwer ist.
|
||||
\end{definition}
|
||||
|
||||
\inlinelemma Falls ein Optimierungsproblem $U \in PO$, dann $\text{Lang}_U \in P$
|
||||
|
||||
\inlinetheorem Sei $U \in NPO$. Falls $U$ NP-schwer ist und $P \neq NP$, dann $U \notin PO$
|
||||
|
||||
\inlinelemma MAX-SAT ist NP-schwer.
|
||||
|
||||
\inlinelemma MAX-CL (Das Problem der maximalen Clique) ist NP-schwer
|
||||
|
||||
Um zu zeigen, dass solche Probleme $U$ NP-schwer sind, reicht es zu zeigen, dass $\text{Lang}_U$ NP-schwer ist, was wir mit einer $P$-Reduktion machen können.
|
||||
10
semester3/ti/main/parts/06_grammars/00_intro.tex
Normal file
10
semester3/ti/main/parts/06_grammars/00_intro.tex
Normal file
@@ -0,0 +1,10 @@
|
||||
\subsection{Das Konzept der Grammatiken}
|
||||
Mit Grammatiken haben wir eine alternative formale Beschreibung von Sprachen.
|
||||
Die Idee der Grammatiken ist anstelle der Beschreibung der Eigenschaften einzelner Wörter oder von Maschinen / Automaten, die die Sprachen erkennen,
|
||||
die Erzeugung der Sprachen zu beschreiben.
|
||||
|
||||
\begin{definition}[]{Grammatik}
|
||||
\begin{enumerate}
|
||||
\item
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
121
semester3/ti/main/parts/combinatorics.tex
Normal file
121
semester3/ti/main/parts/combinatorics.tex
Normal file
@@ -0,0 +1,121 @@
|
||||
\newsection
|
||||
\section{Combinatorics}
|
||||
\label{sec:combinatorics}
|
||||
\subsection{Introduction}
|
||||
Combinatorics was developed from the willingness of humans to gamble and the fact that everybody wanted to win as much money as possible.
|
||||
|
||||
\subsection{Simple counting operations}
|
||||
The easiest way to find the best chance of winning is to write down all possible outcomes. This can be very tedious though when the list gets longer.
|
||||
|
||||
We can note this all down as a list or as a tree diagram. So-called Venn Diagrams might also help represent the relationship between two sets or events. Essentially a Venn Diagram is a graphical representation of set operations such as $A \cup B$.
|
||||
|
||||
|
||||
\subsection{Basic rules of counting}
|
||||
\subsubsection{Multiplication rule}
|
||||
If one has $n$ possibilities for a first choice and $m$ possibilities for a second choice, then there are a total of $n \cdot m$ possible combinations.
|
||||
|
||||
When we think about a task, and we have an \textbf{and} in between e.g. properties, we need to multiply all the options.
|
||||
|
||||
\subsubsection{Addition rule}
|
||||
If two events are mutually exclusive, the first has $n$ possibilities and the second one has $m$ possibilities, then both events together have $n+m$ possibilities.
|
||||
|
||||
When we think about a task, and we have an \textbf{or} in between e.g. properties, then we need to add all the options.
|
||||
|
||||
|
||||
\newpage
|
||||
\subsection{Factorial}
|
||||
\begin{definition}[]{Factorial}
|
||||
The factorial stands for the product of the first $n$ natural numbers where $n \ge 1$. Notation: $!$
|
||||
\[
|
||||
n! = n \cdot (n - 1) \cdot (n - 2) \cdot \ldots \cdot 3 \cdot 2 \cdot 1
|
||||
\]
|
||||
Additionally, $0! = 1$. We read $n!$ as ``\textit{n factorial}''
|
||||
\end{definition}
|
||||
|
||||
\subsubsection{Operations}
|
||||
We can rewrite $n!$ as $n \cdot (n - 1)!$ or $n \cdot (n - 1) \cdot (n - 2)!$ and so on.
|
||||
|
||||
It is also possible to write $7 \cdot 6 \cdot 5$ with factorial notation: $\displaystyle \frac{7!}{4!}$, or in other words, for any excerpt of a factorial sequence: \[n \cdot (n - 1) \cdot \ldots \cdot m = \frac{n!}{(m - 1)!}\]
|
||||
|
||||
|
||||
\subsection{Permutations}
|
||||
\begin{definition}[]{Permutations}
|
||||
A permutation of a group is any possible arrangement of the group's elements in a particular order\\
|
||||
|
||||
\textbf{Permutation rule without repetition:} The number of $n$ \textbf{\textit{distinguishable}} elements is defined as: $n!$
|
||||
\end{definition}
|
||||
|
||||
|
||||
\subsubsection{Permutation with repetition}
|
||||
For $n$ elements $n_1,n_2,\ldots,n_k$ of which some are identical, the number of permutations can be calculated as follows:
|
||||
\[
|
||||
p = \frac{n!}{n_1! \cdot n_2! \cdot \ldots \cdot n_k!}
|
||||
\]
|
||||
where $n_k$ is the number of times a certain element occurs.
|
||||
As a matter of fact, this rule also applies to permutations without repetition, as each element occurs only once, which means the denominator is $1$, hence $\displaystyle \frac{n!}{(1!)^n} = n!$
|
||||
|
||||
\inlineex \smallhspace CANADA has $6$ letters, of which $3$ letters are the same. So the word consists of $3$ A's, which can be arranged in $3!$ different ways, a C, N and D, which can be arranged in $1!$ ways each. Therefore, we have:
|
||||
\[
|
||||
\frac{6!}{3!\cdot 1! \cdot 1! \cdot 1!} = \frac{6!}{3!} = 6 \cdot 5 \cdot 4 = 120
|
||||
\]
|
||||
|
||||
Since $1!$ equals $1$, we can always ignore all elements that occur only once, as they won't influence the final result.
|
||||
|
||||
|
||||
\newpage
|
||||
\subsection{Variations}
|
||||
\begin{definition}[]{Variations}
|
||||
A \textbf{\textit{variation}} is a selection of $k$ elements from a universal set that consists of $n$ \textit{distinguishable} elements.\\
|
||||
|
||||
\textbf{Variation rule without repetition:} The $_n\mbox{P}_k$ function is used to \textit{\textbf{place}} $n$ elements on $k$ places. In a more mathematical definition:
|
||||
The number of different variations consisting of $k$ different elements selected from $n$ distinguishable elements can be calculated as follows:
|
||||
|
||||
\[
|
||||
\frac{n!}{(n - k)!} = _n\mbox{P}_k
|
||||
\]
|
||||
\end{definition}
|
||||
|
||||
\subsubsection{Variations with repetition}
|
||||
If an element can be selected more than once and the order matters, the number of different variations consisting of $k$ elements selected from $n$ distinguishable elements can be calculated using $n^k$
|
||||
|
||||
|
||||
|
||||
\subsection{Combinations}
|
||||
\begin{definition}[]{Combination}
|
||||
A combination is a selection of $k$ elements from $n$ elements in total without any regard to order or arrangement.
|
||||
|
||||
\textbf{Combination rule without repetition:} \[
|
||||
_n\mbox{C}_k = {n\choose k} = \frac{_n\mbox{P}_k}{k!} = \frac{n!}{(n - k)! \cdot k!}
|
||||
\]
|
||||
\end{definition}
|
||||
|
||||
\subsubsection{Combination with repetition}
|
||||
In general the question to ask for combinations is, in how many ways can I distribute $k$ objects among $n$ elements?
|
||||
\[
|
||||
_{n + k - 1}\mbox{C}_k = {n + k - 1\choose k} = \frac{(n + k - 1)!}{k!(n - 1)!}
|
||||
\]
|
||||
|
||||
|
||||
|
||||
\subsection{Binomial Expansion}
|
||||
\label{sec:binomial-expansion}
|
||||
Binomial expansion is usually quite hard, but it can be much easier than it first seems. The first term of the expression of $(a + b)^n$ is always $1 a^n b^0$. Using the formula for combination without repetition, we can find the coefficients of each element:
|
||||
|
||||
\begin{center}
|
||||
\includegraphics[width=0.6\linewidth]{./assets/binomialExpansion.png}
|
||||
\end{center}
|
||||
|
||||
This theory is based on the Pascal's Triangle and the numbers of row $n$ correspond to the coefficients of each element of the expanded term.
|
||||
|
||||
We can calculate the coefficient of each part of the expanded term $k$ with combinatorics as follows: $\displaystyle {n\choose k}$
|
||||
|
||||
\begin{formula}[]{Binomial Expansion}
|
||||
\textbf{\textit{\underbar{In general:}}}
|
||||
\[
|
||||
(a + b)^n = 1a^nb^0 + {n\choose 1} a^{n-1}b^{1} + {n\choose 2} a^{n-2}b^{2} + \ldots + {n\choose n - 1} a^{1}b^{n - 1} + {n\choose n} a^{0}b^{n}
|
||||
\]
|
||||
\end{formula}
|
||||
|
||||
|
||||
\subsection{Overview}
|
||||
\includegraphics[width=1\linewidth]{./assets/overview.png}
|
||||
BIN
semester3/ti/main/ti-summary.pdf
Normal file
BIN
semester3/ti/main/ti-summary.pdf
Normal file
Binary file not shown.
119
semester3/ti/main/ti-summary.tex
Normal file
119
semester3/ti/main/ti-summary.tex
Normal file
@@ -0,0 +1,119 @@
|
||||
\documentclass{article}
|
||||
|
||||
\input{~/projects/latex/dist/full.tex}
|
||||
\setLang{de}
|
||||
|
||||
\setup{Theoretische Informatik}
|
||||
|
||||
\newcommand{\hdelta}{\hat{\delta}}
|
||||
\newcommand{\qacc}{q_{\text{accept}}}
|
||||
\newcommand{\qrej}{q_{\text{reject}}}
|
||||
\newcommand{\ldiag}{L_{\text{diag}}}
|
||||
\newcommand{\lempty}{L_{\text{empty}}}
|
||||
\renewcommand{\tc}{\text{Time}}
|
||||
\newcommand{\spc}{\text{Space}}
|
||||
|
||||
\begin{document}
|
||||
\startDocument
|
||||
\usetcolorboxes
|
||||
|
||||
\vspace{2cm}
|
||||
\begin{Huge}
|
||||
\begin{center}
|
||||
TITLE PAGE COMING SOON
|
||||
\end{center}
|
||||
\end{Huge}
|
||||
|
||||
|
||||
\vspace{4cm}
|
||||
\begin{center}
|
||||
\begin{Large}
|
||||
``\textit{Wenn Sie die Turing-Maschine als Touring-Maschine in der Prüfung schreiben, dann macht mich das sehr traurig. Ich seh das jeweils. Teilweise sind das sehr elaborierte Trolle, manchmal Leute die nie in die Vorlesungen kommen} (2025-10-14T08:51Z+02:00``)
|
||||
|
||||
``\textit{Sie können also alle C Programme in Kanonischer Ordnung aufzählen. Sollten Sie dies tun. Wahrscheinlich nicht. Was aber zählt ist, sie \textbf{können} es tun}''
|
||||
\end{Large}
|
||||
|
||||
\hspace{3cm} - Prof. Dr. Dennis Komm, 2025
|
||||
\end{center}
|
||||
|
||||
\vspace{3cm}
|
||||
\begin{center}
|
||||
HS2025, ETHZ\\[0.2cm]
|
||||
\begin{Large}
|
||||
Summary of the book \color{MidnightBlue}\fbox{\href{https://link.springer.com/book/10.1007/978-3-658-06433-4}{Theoretische Informatik}}\color{black}
|
||||
\end{Large}\\[0.2cm]
|
||||
by Prof. Dr. Juraj Hromkovic
|
||||
\end{center}
|
||||
|
||||
\newpage
|
||||
|
||||
\printtoc{Orange}
|
||||
|
||||
\begin{scriptsize}
|
||||
\begin{itemize}
|
||||
\item \textit{Note: Definitions, Lemmas, etc are often 1:1 copies from the book or paraphrased (as I did not find an easier way of stating them)}
|
||||
\item \textit{Note: In case I forgot to add the PDF page numbers, you can take the PDF page number is given by $P_{\text{PDF}} = P_{\text{Book}} + 15$}
|
||||
\end{itemize}
|
||||
\end{scriptsize}
|
||||
|
||||
\newpage
|
||||
|
||||
|
||||
% Combinatorics
|
||||
\input{parts/combinatorics.tex}
|
||||
|
||||
|
||||
% ┌ ┐
|
||||
% │ Alphabets │
|
||||
% └ ┘
|
||||
\newsection
|
||||
\section{Alphabete, Wörter, Sprachen und Darstellung von Problemen}
|
||||
\stepcounter{subsection}
|
||||
\input{parts/01_languages-problems/00_alphabet.tex}
|
||||
\input{parts/01_languages-problems/01_algorithmic-problems.tex}
|
||||
\input{parts/01_languages-problems/02_kolmogorov-complexity.tex}
|
||||
|
||||
|
||||
% ────────────────────────────────────────────────────────────────────
|
||||
% ┌ ┐
|
||||
% │ Automata │
|
||||
% └ ┘
|
||||
\newsection
|
||||
\section{Endliche Automaten}
|
||||
\stepcounter{subsection}
|
||||
\input{parts/02_finite-automata/00_representation.tex}
|
||||
\input{parts/02_finite-automata/01_simulations.tex}
|
||||
\input{parts/02_finite-automata/02_proofs-of-nonexistance.tex}
|
||||
\input{parts/02_finite-automata/03_non-determinism.tex}
|
||||
|
||||
\newsection
|
||||
\section{Turing-Maschinen}
|
||||
\setcounter{subsection}{2}
|
||||
\input{parts/03_turing_machines/00_intro.tex}
|
||||
\input{parts/03_turing_machines/01_multi-band-church-thesis.tex}
|
||||
\input{parts/03_turing_machines/02_non-deterministic.tex}
|
||||
|
||||
\newsection
|
||||
\section{Berechenbarkeit}
|
||||
\stepcounter{subsection}
|
||||
\input{parts/04_computability/00_intro.tex}
|
||||
\input{parts/04_computability/01_reduction.tex}
|
||||
\input{parts/04_computability/02_rice.tex}
|
||||
\input{parts/04_computability/03_kolmogorov.tex}
|
||||
|
||||
\newsection
|
||||
\section{Komplexitätstheorie}
|
||||
\stepcounter{subsection}
|
||||
\input{parts/05_complexity/00_intro.tex}
|
||||
\input{parts/05_complexity/01_class_p.tex}
|
||||
\input{parts/05_complexity/02_non-deterministic-complexity.tex}
|
||||
\input{parts/05_complexity/03_class-np.tex}
|
||||
\input{parts/05_complexity/04_np-completeness.tex}
|
||||
|
||||
\newsection
|
||||
\section{Grammatiken}
|
||||
\stepcounter{subsection}
|
||||
\input{parts/06_grammars/00_intro.tex}
|
||||
|
||||
|
||||
\end{document}
|
||||
Reference in New Issue
Block a user