[TI] Fix some spelling errors

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

@@ -13,7 +13,7 @@ Hier kommt die Kolmogorov-Komplexit zum Zuge: Sie bietet eine breit Gültige Def
 
 
 \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.
+    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.
@@ -22,14 +22,14 @@ Ein Pascal-Programm in diesem Kurs ist zudem nicht zwingend ein Programm in der
 
 
 \begin{lemma}[]{Kolmogorov-Komplexität}
-	Für jedes Wort $x \in \wordbool$ existiert eine Konstante $d$ so dass $K(x) \leq |x| + d$
+    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
+    $A_x$: begin
-        write(x);
+    write(x);
-     end
+    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.
 
@@ -49,10 +49,10 @@ Eine wichtige Eigenschaft der Kolmogorov-Komplexität ist, dass sie nicht wirkli
 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:
+    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*}
+    \begin{align*}
-		|K_A(x) - K_B(x)| \leq c_{A, B}
+        |K_A(x) - K_B(x)| \leq c_{A, B}
-	\end{align*}
+    \end{align*}
 \end{theorem}
 
 \fhlc{orange}{Anwendungen der Kolmogorov-Komplexität}
@@ -62,12 +62,12 @@ Man kann also beliebig auch \texttt{C++}, \texttt{Swift}, \texttt{Python}, \text
     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} 
+\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 })
+        K(z_n) \leq \ceil{\log_2(n + 1)} + c &  & (c \text{ ist eine von } n \text{ unabhängige Konstante })
     \end{align*}
 \end{theorem}
 
@@ -85,7 +85,7 @@ Die Annäherung von $\text{Prim}(n)$ and $\frac{n}{\ln(n)}$ wird durch folgende
 
 \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. 
+    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}
 
@@ -94,7 +94,7 @@ Lemma 2.6 zeigt nicht nur, dass es unendlich viele Primzahlen geben muss, sonder
 \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}
+        \text{Prim}(k) \geq \frac{k}{2^{17} \log_2(k) \cdot (\log_2(\log_2(k)))^2}
     \end{align*}
 \end{theorem}
 

semester3/ti/parts/03_turing_machines/00_intro.tex

@@ -21,7 +21,7 @@ Formaler:
         \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 \} \Gamma^+$
+    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$

semester3/ti/parts/03_turing_machines/02_non-deterministic.tex

@@ -10,7 +10,7 @@ Die Ideen sind hier sehr ähnlich wie der Übergang zwischen deterministischen u
     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 \}
+        \delta : (Q - \{ \qacc, \qrej \}) \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times \{ L, R, N \})
     \end{align*}
 
     \rmvspace

semester3/ti/parts/04_computability/00_intro.tex

@@ -29,7 +29,7 @@ Also müssen wir laut Definition \ref{definition:5-1} nur zeigen, dass keine Inj
 
 \inlinetheorem $\mathcal{P}(\wordbool)$ ist nicht abzählbar
 
-\inlinecorollary $|\text{KodTM}| < |\mathcal{P}(\wordbool)|$ und es existieren also unendlich viele nicht rekursiv aufzählbare Funktionen.
+\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$
@@ -45,6 +45,6 @@ $M$ ist eine Turingmaschine in der kanonischen Ordnung der Turingmaschinen, also
 
 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} \Longleftrightarrow w_i \notin L(M_i)
+    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 und umgekehrt. (= in genau einer der Sprachen $L_\text{diag}$ oder $L(M_i)$)
+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)$)