[TI] Introduction to automata

semester3/ti/parts/01_languages-problems/00_alphabet.tex

@@ -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.

semester3/ti/parts/01_languages-problems/01_algorithmic-problems.tex

@@ -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}

semester3/ti/parts/01_languages-problems/02_kolmogorov-complexity.tex

@@ -0,0 +1,101 @@
+\newpage
+\subsection{Kolmogorov-Komplexität}
+\setcounter{definitions}{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 im Buch erklärt