[TI] Prepare next section

semester3/numcs/numcs-summary.tex

@@ -132,6 +132,8 @@ Moral of the story: Use descriptive variable names and do NOT use $t$, $tt$, $tt
 \input{parts/01_interpolation/02_piece-wise/01_hermite-interpolation.tex}
 \input{parts/01_interpolation/02_piece-wise/02_splines.tex}
 
+
+% ── quadrature ──────────────────────────────────────────────────────
 \newsection
 \section{Numerische Quadratur}
 \input{parts/02_quadrature/00_introduction.tex}
@@ -144,4 +146,21 @@ Moral of the story: Use descriptive variable names and do NOT use $t$, $tt$, $tt
 \input{parts/02_quadrature/06_reduction-of-variance.tex}
 
 
+% ── zeros ───────────────────────────────────────────────────────────
+\newsection
+\section{Nullstellensuche}
+\input{parts/03_zeros/00_intro.tex}
+\input{parts/03_zeros/01_termination-criteria.tex}
+\input{parts/03_zeros/02_fix-point-iteration.tex}
+\input{parts/03_zeros/03_bisection-method.tex}
+\input{parts/03_zeros/04_newton-one-d.tex}
+\input{parts/03_zeros/05_sectant-method.tex}
+\input{parts/03_zeros/06_newton-nd.tex}
+\input{parts/03_zeros/07_damped-newton.tex}
+\input{parts/03_zeros/08_quasi-newton.tex}
+
+\newsection
+\section{Intermezzo: Lineare Algebra}
+\input{parts/04_linalg/00_intro.tex}
+
 \end{document}

semester3/numcs/parts/02_quadrature/03_adaptive.tex

@@ -1,3 +1,7 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
 \newsection
 \subsection{Adaptive Quadratur}
 Der lokale Fehler einer zusammengesetzten Quadraturformel auf dem Gitter $\mathcal{M} := \{ a = x_0 < x_1 < \dots < x_m = b \}$ ist (für $f \in C^2([a, b])$):

semester3/numcs/parts/02_quadrature/04_in-rd.tex

@@ -1,3 +1,7 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
 \newsectionNoPB
 \subsection{Quadratur in $\R^d$ und dünne Gitter}
 Eine einfache Option wäre natürlich, zwei eindimensionale Quadraturformeln aneinander zu hängen.

semester3/numcs/parts/02_quadrature/05_monte-carlo.tex

@@ -1,3 +1,7 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
 \newsection
 \newcommand{\tsigma}{\tilde{\sigma}}
 \subsection{Monte-Carlo Quadratur}

semester3/numcs/parts/02_quadrature/06_reduction-of-variance.tex

@@ -1,3 +1,7 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
 \newsection
 \subsection{Methoden zur Reduktion der Varianz}
 % NOTE: Mostly from TA slides, as the script is quite convoluted there

semester3/numcs/parts/03_zeros/00_intro.tex

@@ -0,0 +1,81 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
+\subsection{Iterative Verfahren}
+\inlinedef Ein iteratives Verfahren ist ein Algorithmus $\phi_F$, der die Folge $x^{(0)}, x^{(1)}, \ldots$ von approximativen Lösungen $x^{(j)}$ generiert.
+Die Definition ist dabei rekursiv: $x^{(k)} := \phi_F(x^{(k - 1)})$, sofern $x^{(0)}$ und $\phi$ gegeben sind.
+
+\setLabelNumber{all}{5}
+\fancydef{Konvergenz} $\phi_F$ zur Lösung $F(x^*) = 0$ konvergiert, wenn $x^{(k)} \rightarrow x^*$, mit $x^*$ die Nullstelle.
+
+\setLabelNumber{all}{8}
+\fancydef{Norm}
+
+\innumpy haben wir \texttt{numpy.linalg.norm}, welches zwei Argumente nimmt. Dabei ist das erste Argument der Vektor und das Zweite die Art der Norm.
+Ohne zweites Argument wird die Euklidische Norm $||x||_2$, mit Argument $1$ wird die $1$-Norm $||x||_1 := |x_1| + \ldots + |x_n|$
+und mit mit \texttt{inf} als Argument wird die $\infty$-Norm, bzw. die Max-Norm $||x||_\infty := \max\{ |x_1|, \ldots, |x_n| \}$ berechnet.
+
+\stepLabelNumber{all}
+\inlinedef Zwei Normen $||\cdot||_1$ und $||\cdot||_2$ sind äquivalent auf $\cV$, falls es Konstanten $\underline{C}$ und $\overline{C}$ gibt so dass
+\rmvspace
+\begin{align*}
+    \underline{C} \cdot ||v||_1 \leq ||v||_2 \leq \overline{C} \cdot ||v||_1 \mediumhspace \forall v \in \cV, \text{ mit } \cV \text{ ein linearer Raum}
+\end{align*}
+
+\drmvspace
+\inlinetheorem Falls $\dim(\cV) < \infty$, dann sind alle Normen auf $\cV$ äquivalent
+
+\stepLabelNumber{all}
+\fancydef{Lineare Konvergenz} $x^{(k)}$ konvergiert linear gegen $x^*$, falls es ein $L < 1$ gibt, so dass
+\rmvspace
+\begin{align*}
+    ||x^{(k + 1)} - x^*|| \leq L||x^{(k)} - x^*|| \smallhspace \forall k \geq k_0, \smallhspace L \text{ genannt Konvergenzrate }
+\end{align*}
+
+\drmvspace\stepLabelNumber{all}
+\fancydef{Konvergenzordnung} $p$ für das Verfahren, falls es ein $C > 0$ gibt, so dass
+\rmvspace
+\begin{align*}
+    ||x^{(k + 1)} - x^*|| \leq C||x^{(k)} - x^*||^p \smallhspace \forall k \in \N \text{ mit } C < 1 \text{ für } p = 1
+\end{align*}
+
+\drmvspace
+Wir nehmen dabei an, dass $||x^{(0)} - x^*|| < 1$, damit wir eine konvergente Folge haben.
+Man kann die Konvergenzordnung folgendermassen abschätzen, mit $\varepsilon_k := ||x^{(k)} - x^*||$ (Konvergenzrate in Bemerkung \ref{all:6-1-19}):
+\rmvspace
+\begin{align*}
+    p \approx \frac{\log(\varepsilon_{k + 1}) - \log(\varepsilon_k)}{\log(\varepsilon_k) - \varepsilon_{k - 1}}
+\end{align*}
+
+\drmvspace
+Intuitiv haben wir Quadratische (oder Kubische, etc.) Konvergenzordnung, wenn sich die Anzahl Nullen im Fehler jede Iteration verdoppeln (verdreifachen, etc.)
+
+\numberingOff
+\inlineremark Eine höhere Konvergenzordnung ist in Lin-Log-Skala an einer gekrümmten Konvergenzkurve erkennbar.
+\numberingOn
+
+\rmvspace\setLabelNumber{all}{19}
+\fancyremark{Abschätzung der Konvergenzrate} Sei $\varepsilon_k := ||x^{(k)} - x^*||$ die Norm des Fehlers im $k$-ten Schritt.
+\drmvspace\rmvspace
+\begin{align*}
+    \varepsilon_{k + 1} \approx L \cdot \varepsilon_k \Longrightarrow \log(\varepsilon_{k + 1}) \approx \log(L) + \log(\varepsilon_k)
+    \Longrightarrow \varepsilon_{k + 1} \approx k \log(L) + \log(\varepsilon_0)
+\end{align*}
+
+\drmvspace
+Untenstehender Code berechnet den Fehler und die Konvergenzrate von $\displaystyle x^{(k + 1)} = x^{(k)} + \frac{\cos(x^{(k)}) + 1}{\sin(x^{(k)})}$.
+Dabei verwenden wir $x^{(15)}$ anstelle von $x^*$ zur Berechnung der Konvergenzrate, da $x^*$ meist unbekannt ist.
+
+\drmvspace
+\begin{code}{python}
+    def linear_convergance(x):
+        y = []  # container for the x(j)
+        for k in range(15):
+            x = x + (np.cos(x) + 1) / np.sin(x)  # apply the iteration formula
+            y += [x]  # store the value in the container
+        err = abs(np.array(y) - x)  # estimation for the error
+        rate = err[1:] / err[:-1]
+        # estimation for convergence rate
+        return err, rate
+\end{code}

semester3/numcs/parts/03_zeros/01_termination-criteria.tex

@@ -0,0 +1,16 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
+\newsection
+\subsection{Abbruchkriterien}
+Wir müssen irgendwann unsere Iteration abbrechen können, dazu haben wir folgende Möglichkeiten:
+\begin{fullTable}{p{2.5cm}p{5.5cm}p{3cm}p{4.5cm}}{Typ & Idee                                                                                    & Vorteile                  & Nachteile}{Vergleich der Abbruchkriterien}
+    \bi{A priori}                        & Fixe Anzahl $k_0$ Schritte                                                              & Einfach zu implementieren & Zu ungenau                                                                        \\
+    \bi{A posteriori}                    & Berechnen bis Toleranz $\varepsilon < \tau$ erreicht                                    & Präzise                   & Man kennt $x^*$ nicht                                                             \\
+    \bi{Ungefähr gleich}                 & Itaration bis$x^{(k + 1)} \approx x^{(k)}$                                              & Keine Voraussetzungen     & Ineffizient                                                                       \\
+    \bi{Residuum}                        & Abbruch wenn $||F(x^{(k)})|| < \tau$ (wir also fast bei $0$ sind mit dem Funktionswert) & Einfach zu implementieren & Bei flachen Funktionen kann $||F(x^{(k)}||$ klein sein, aber $\varepsilon$ gross) \\
+\end{fullTable}
+
+\drmvspace
+\inlineremark Für das \textit{a posteriori} Abbruchkriterium mit linearer Konvergenz und bekanntem $L$ gilt die Abschätzung aus Lemma \ref{all:6-3-6} mit Korollar \ref{all:6-3-17}

semester3/numcs/parts/03_zeros/02_fix-point-iteration.tex

@@ -0,0 +1,66 @@
+% ┌                                                ┐
+% │     AUTHOR: Janis Hutz<info@janishutz.com>     │
+% └                                                ┘
+
+\rmvspace\newsectionNoPB
+\subsection{Fixpunktiteration}
+Ein $1$-Punkt-Verfahren benötigt nur den vorigen Wert: $x^{(k + 1)} = \phi(x^{(k)})$
+
+% FIXME: Below konsistent is probably wrong, but is what is in the script
+\inlinedef Eine Fixpunktiteration heisst konsistent mit $F(x) = 0$ falls $F(x) = 0 \Leftrightarrow \phi(x) = x$
+
+\inlineex Für $F(x) = xe^x - 1$ mit $x \in [0, 1]$ liefert $\phi_1(x) = e^{-x}$ lineare Konvergenz,
+$\phi_2(x) = \frac{1 + x}{1 + e^x}$ quadratische Konvergenz und $\phi_3(x) = x + 1 - xe^x$ eine divergente Folge.
+
+\setLabelNumber{all}{5}
+\fancydef{Kontraktion} $\phi$ falls es ein $L < 1$ gibt, so dass $||\phi(x) - \phi(y)|| \leq L||x - y|| \ \forall x, y$
+
+\inlineremark Falls $x^*$ ein Fixpunkt der Kontraktion $\phi$ ist, dann ist
+\drmvspace
+\begin{align*}
+    ||x^{(k + 1)} - x^*|| = ||\phi(x^{(k)}) - \phi(x^*)|| \leq L||x^{(k)} - x^*||
+\end{align*}
+
+\drmvspace
+\begin{theorem}[]{Banach'scher Fixpunktsatz}
+    Sei $D \subseteq \K^n$ ($\K = \R, \C$) mit $D$ abgeschlossen und $\phi: D \rightarrow D$ eine Kontraktion.
+    Dann existiert ein eindeutiger Fixpunkt $x^*$, für welchen also gilt, dass $\phi(x^*) = x^*$.
+    Dieser ist der Grenzwert der Folge $x^{(k + 1)} = \phi(x^{(k)})$.
+\end{theorem}
+
+% NOTE: If need be, we can switch to theorem here, or I can add a new environment for "support theorem" or the like,
+% I however feel like a Lemma suits the idea of "Hilfstheorem" quite well
+\inlinelemma Für $U \subseteq \R^n$ konvex und $\phi : U \rightarrow \R^n$ stetig differenzierbar mit $L := \sup_{x \in U} ||D_\phi(x)|| < 1$
+($D_\phi(x)$ ist die Jacobi-Matrix von $\phi(x)$).
+Wenn $\phi(x^*) = x^*$ für $x^* \in U$, dann konvergiert $x^{(k + 1)} = \phi(x^{(k)})$ gegen $x^*$ lokal mindestens linear.
+Dies ist eine hinreichende (= sufficient) Bedingung.
+
+\setLabelNumber{all}{11}
+\inlinelemma Für $\phi : \R^n \rightarrow \R^n$ mit $\phi(x^*) = x^*$ und $\phi$ stetig differenzierbar in $x^*$.
+Ist $||D_\phi(x^*)|| < 1$, dann konvergiert $x^{(k + 1)} = \phi(x^{(k)})$ lokal und mindestens linear mit $L = ||D_\phi(x^*)||$
+
+\stepLabelNumber{all}
+\fancytheorem{Satz von Taylor} Sei $I \subseteq \R$ ein Intervall, $\phi : I \rightarrow \R$ $(m + 1)$-mal differenzierbar und $x \in I$.
+Dann gilt für jedes $y \in I$
+\drmvspace
+\begin{align*}
+    \phi(y) - \phi(x) = \sum_{k = 1}^{m} \frac{1}{k!} \left( \phi^{(k)}(x) (y - x)^k \right) + \tco{|y - x|^{m + 1}}
+\end{align*}
+
+\drmvspace
+\inlinelemma Sei $I$ und $\phi$ wie in Satz \ref{all:6-3-13}. Sei zudem $\phi^{(l)}(x^*) = 0$ für $l \in \{ 1, \ldots, m \}$ mit $m \geq 1$.
+Dann konvergiert $x^{(k + 1)} = \phi(x^{(k)})$ lokal gegen $x^*$ mit Ordnung $p \geq m + 1$
+
+\stepLabelNumber{all}
+\inlinelemma Konvergiert $\phi$ linear mit $L < 1$, dann gilt:
+\drmvspace
+\begin{align*}
+    ||x^{*} - x^{(k)}|| \leq \frac{L^{k - l}}{1 - L} ||x^{(l + 1)} - x^{(l)}||
+\end{align*}
+
+\drmvspace
+\inlinecorollary für $l = 0$ haben wir ein \textit{a priori} und für $l = k - 1$ ein \textit{a posteriori} Abbruchkriterium:
+\drmvspace
+\begin{align*}
+    ||x^* - x^{(k)}|| \leq \frac{L^k}{1 - L} ||x^{(1)} - x^{(0)}|| \leq \tau & & ||x^* - x^{(k)}|| \leq \frac{L}{1 - L} ||x^{(k)} - x^{(k - 1)}|| \leq \tau
+\end{align*}

semester3/numcs/parts/03_zeros/03_bisection-method.tex

@@ -0,0 +1,13 @@
+\newsection
+\subsection{Intervallhalbierungsverfahren}
+Die Idee hier ist, das Intervall immer weiter zu halbieren und ein bekannterer Namen für dieses Verfahren ist \bi{Bisektionsverfahren}.
+
+\innumpy haben wir \texttt{scipy.optimize.bisect} und \texttt{scipy.optimize.fsolve}, wobei \texttt{fsolve} ein alter Algorithmus ist.
+
+Im Skript auf Seiten 206 - 207 findet sich eine manuelle implementation des Bisektionsverfahren.
+Der Code ist jedoch (at the time of writing) nicht ausführbar aufgrund von \texttt{IndentationErrors}
+
+Das Bisektionsverfahren konvergiert linear und kann nur für Funktionen verwenden, bei welchen die Nullstellen auf beiden Seiten jeweils ungleiche Vorzeichen haben.
+
+Für jeden Iterationsschritt ermitteln wir die Mitte des Intervalls und berechnen die Funktionswerte an den Rändern, wie auch dem Mittelpunkt.
+Dann ersetzen wir den Rand des Intervalls, dessen Funktionswert dasselbe Vorzeichen hat, wie der Funktionswert des Mittelpunkts.

semester3/numcs/parts/03_zeros/04_newton-one-d.tex

@@ -0,0 +1,17 @@
+\newsectionNoPB
+\subsection{Newtonverfahren in 1D}
+Beim Newtonverfahren verwendet man für jeden Iterationsschritt die lineare Funktion $\tilde{F} = F(x^(k)) + F'(x^{(k)})(x - x^{(k)})$. Die Nullstelle ist dann:
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - \frac{F(x^{(k)})}{F'(x^{(k)})}, \mediumhspace \text{falls } F'(x^{(k)}) \neq 0
+\end{align*}
+
+\stepLabelNumber{all}
+\inlineremark Die Newton-Iteration ist eine Fixpunktiteration mit quadratischer lokaler Konvergenz, mit
+\rmvspace
+\begin{align*}
+    \phi(x) = x - \frac{F(x)}{F'(x)} \Longrightarrow \phi'(x) = \frac{F(x) F''(x)}{(F'(x))^2} \Longrightarrow \phi'(x^*) = 0
+\end{align*}
+
+\drmvspace
+falls $F(x^*) = 0$ und $F^(x^*) \neq 0$

semester3/numcs/parts/03_zeros/05_sectant-method.tex

@@ -0,0 +1,8 @@
+\newsectionNoPB
+\subsection{Sekantenverfahren}
+Falls die Ableitung zu teuer oder nicht verfügbar ist, kann man sie durch $q^(k) := \frac{F(x^{(k)}) - F(x^{(k - 1)})}{x^{(k)} - x^{(k - 1)}}$.
+Dann ist ein Schritt:
+\rmvspace
+\begin{align*}
+    \tilde{F}(x) = F(x^{(k)}) + q^{(k)} (x - x^{(k)}) \Longrightarrow x^{(k + 1)} := x^{(k)} - \frac{F(x^{(k)})}{q^{(k)}}, \smallhspace \text{ falls } q^{(k)} \neq 0
+\end{align*}

semester3/numcs/parts/03_zeros/06_newton-nd.tex

@@ -0,0 +1,36 @@
+\newsectionNoPB
+\subsection{Newton-Verfahren in $n$ Dimensionen}
+Sei $D \subseteq \R^n$ und $F: D \rightarrow \R^n$ stetig differenzierbar. Die Nullstelle ist
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - DF(x^{(k)})^{-1} F(x^{(k)})
+\end{align*}
+
+\drmvspace
+wobei $DF(x^{(k)}) =
+    \begin{bmatrix}
+        \frac{\partial F_j}{\partial x_k} (x)
+    \end{bmatrix}_{j, k = 1, 2, \ldots, n}$ die Jacobi-Matrix von $F$ ist.
+
+Wichtig ist dabei, dass wir \bi{niemals} das Inverse der Jacobi-Matrix (oder irgend einer anderen Matrix) von der Form $s = A^{-1} b$,
+sondern immer das Gleichungssystem $As = b$ lösen sollten, da dies effizienter ist:
+
+\begin{code}{python}
+def newton(x, F, DF, tol=1e-12, maxit=50):
+    x = np.atleast_2d(x)  # ’solve’ erwartet x als 2-dimensionaler numpy array
+    # Newton Iteration
+    for _ in range(maxit):
+        s = np.linal.solve(DF(x), F(x))
+        x -= s
+        if np.linalgnorm(s) < tol * np.linalg.norm(x):
+            return x
+\end{code}
+
+Wollen wir aber garantiert einen Fehler kleiner als unsere Toleranz $\tau$ können wir das Abbruchkriterium
+\rmvspace
+\begin{align*}
+    ||DF(x^{(k - 1)})^{-1}F(x^{(k)})|| \leq \tau
+\end{align*}
+
+\drmvspace
+verwenden. Code, welcher dies implementiert findet sich auf Seite 213-216 im Skript.

semester3/numcs/parts/03_zeros/07_damped-newton.tex

@@ -0,0 +1,16 @@
+\newsection
+\subsection{Gedämpftes Newton-Verfahren}
+Wir wenden einen einen Dämpfungsfaktor $\lambda^{(k)}$ an, welcher heuristisch gewählt wird:
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - \lambda^{(k)}DF(x^{(k)})^{-1} F(x^{(k)})
+\end{align*}
+
+\drmvspace
+Wir wählen $\lambda^{(k)}$ so, dass für $\Delta x^{(k)} = DF(x^{(k)})^{-1} F(x^{(k)})$ und $\Delta(\lambda^{(k)}) = DF(x^{(k)})^{-1} F(x^{(k)} - \lambda^{(k)} \Delta x^{(k)})$
+\rmvspace
+\begin{align*}
+    ||\Delta x(\lambda^{(k)})||_2 \leq \left( 1 - \frac{\lambda^{(k)}}{2} \right) ||\Delta x^{(k)}||_2
+\end{align*}
+
+\drmvspace

semester3/numcs/parts/03_zeros/08_quasi-newton.tex

@@ -0,0 +1,13 @@
+\newsectionNoPB
+\subsection{Quasi-Newton-Verfahren}
+Falls $DF(x)$ zu teuer ist oder nicht zur Verfügung steht, können wir im Eindimensionalen das Sekantenverfahren verwenden.
+
+Im höherdimensionalen Raum ist dies jedoch nicht direkt möglich und wir erhalten die Broyden-Quasi-Newton Methode:
+\rmvspace
+\begin{align*}
+    J_{k + 1} := J_k + \frac{F(x^{(k + 1)}) (\Delta x^{(k)})^\top}{||\Delta x^{(k)}||_2^2}
+\end{align*}
+
+\drmvspace
+Dabei ist $J_0$ z.B. durch $DF(x^{(0)})$ definiert.
+% Page 222

semester3/numcs/parts/04_linalg/00_intro.tex

@@ -0,0 +1,44 @@
+Das Skript-Kapitel hierzu existiert nicht. Die Vorlesung orientiert sich an dem äquivalenten Teil des NumCSE Dokuments.
+
+\textbf{Perturbierte LGS}
+
+Statt $Ax = b$ ist das LGS ungenau gegeben: $(A + \Delta A)(\tilde{x} - x) = \Delta b - \Delta Ax$.
+
+$\text{cond}(A) := \left\lvert\left\lvert A^{-1} \right\rvert\right\rvert \cdot \lvert\lvert A \rvert\rvert \in \mathbb{R}$ (Konditionszahl von $A$)
+
+$\text{cond}(A) \gg 1$ bedeutet intuitiv: kleine Änderung der Daten $\mapsto$ grosse Änderung in der Lösung
+
+\textbf{Gauss Elimination / LU Zerlegung}
+
+$A \in \mathbb{R}^{n\times m} = PLU$ wie bekannt.
+
+\textbf{Cholesky Zerlegung} ($A$ pos. def. und hermitesch)
+
+$A = LDL^\top = \underbrace{L\sqrt{D}}_{R^\top}\underbrace{\sqrt{D}L^\top}_{R} = R^\top R$
+
+Kann $Ax = b$ potenziell schneller lösen als LU.
+
+\begin{code}{python}
+    L = np.linalg.solve(A)      # A = L @ L.T
+    y = np.linalg.solve(L, b)
+    x = np.linalg.solve(L.T, y)
+\end{code}
+
+\textbf{Grosse Matrizen}
+
+Passen oft nicht (direkt) in den Speicher: effizientere Speicherung nötig, möglich für z.B. Diagonalmatrizen, Dreiecksmatrizen. Auch für Cholesky möglich.
+
+\textbf{Dünnbesetzte Matrizen}
+
+$\text{nnz}(A) := |\{ (i,j) \ |\ a_{ij} \in A, a_{ij} \neq 0 \}| \ll m\cdot n$
+
+$\underset{l \to \infty}{\lim} \frac{\text{nnz}(A^{(l)})}{n_l m_l} = 0$
+
+Einfacher zu speichern: \verb|val, col, row| vektoren s.d. \verb|val[k]| $ = a_{ij}$ wobei $i=$ \verb|row[k]|, $j=$ \verb|col[k]|. (nur $a_{ij} \neq 0$)
+
+Viele Formate, je nach Anwendung gewisse sinnvoller als andere. (Siehe Tabelle, NumCSE)
+
+\verb|scipy.sparse.csr_matrix(A)| $\mapsto$ Dramatische Speichereinsparung.\\
+Deprecated: \verb|bsr_array| und \verb|coo_array| verwenden, kompatibel mit \verb|numpy| arrays.
+
+\verb|CSC, CSR| erlauben weitere Optimierungen, je nach Gewichtung der $a_{ij}$ auf Zeilen, Spalten.

semester3/ti-compact/parts/01_words-alphabets.tex

@@ -60,7 +60,7 @@ where the Program doesn't have to compile, i.e. we can describe processes inform
 \fancydef{Randomness} $x \in \wordbool$ random if $K(x) \geq |x|$, thus for $n \in \N$, $K(n) \geq \ceil{\log_2(n + 1)} - 1$
 
 \stepLabelNumber{theorem}
-\fancytheorem{Prime number} $\displaystyle \limni \frac{\text{Prime}(n)}{\frac{n}{\ln(n)}}$
+\fancytheorem{Prime number} $\displaystyle \limni \frac{\text{Prime}(n)}{\frac{n}{\ln(n)}} = 1$ with $\text{Prime}(n)$ the number of prime numbers on $[0, n] \subseteq \N$
 
 \fhlc{Cyan}{Proofs} Proofs in which we need to show a lower bound for Kolmogorov-Complexity (almost) always work as follows:
 Assume for contradiction that there are no words with $K(w) > f$ for all $w \in W$.

semester3/ti-compact/parts/02_finite-automata.tex

@@ -146,8 +146,8 @@ Thus, all four words have to lay in pairwise distinct states and we thus need at
 
 
 \subsection{Non-determinism}
-The most notable differences between deterministic and non-deterministic FA is that the transition function maps is different: $\delta: Q \times \Sigma \rightarrow \cP(Q)$.
-I.e., there can be any number of transitions for one symbol from $\Sigma$ from each state.
+The most notable differences between deterministic and non-deterministic FA is that the transition function is different: $\delta: Q \times \Sigma \rightarrow \cP(Q)$.
+I.e., there can be any number of transitions for one symbol of $\Sigma$ for each state.
 This is (in graphical notation) represented by arrows that have the same label going to different nodes.
 
 It is also possible for there to not be a transition function for a certain element of the input alphabet.

semester3/ti/parts/02_finite-automata/02_proofs-of-nonexistance.tex

@@ -24,7 +24,7 @@ so heisst das für uns von jetzt an, dass $A$ nicht zwischen $x$ und $y$ untersc
 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 viele Sprachen deren Nichtregularität beweisen.
+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 \}$.
@@ -36,7 +36,7 @@ Wir nehmen an, dass $L$ regulär ist und betrachten die Wörter $0^1, 0^2, \ldot
 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^j 1^j \notin L$
+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
 
@@ -52,7 +52,7 @@ denn wenn eine Sprache eine dieser Eigenschaften \textit{nicht} erfüllt, so ist
 
 \fhlc{Cyan}{Pumping}
 
-Eine Methode zum Beweis von Aussagen $L \notin \mathcal{L}_{\text{EA}}$ nennt sich \bi{Pumping} und basiert auf folgender Idee:
+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

semester3/ti/parts/04_computability/01_reduction.tex

@@ -1 +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 \in \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$)

semester3/ti/parts/04_computability/02_rice.tex

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

semester3/ti/parts/04_computability/03_kolmogorov.tex

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

semester3/ti/parts/05_complexity/00_intro.tex

@@ -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 |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 $\tct{f(n)}$ eine untere Schranke für die Zeitkomplexität von $K$ ist.
+\end{definition}

semester3/ti/parts/05_complexity/01_class_p.tex

@@ -0,0 +1,86 @@
+\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.
+
+% TODO: Possibly include construction guide here
+
+\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}

semester3/ti/parts/05_complexity/02_non-deterministic-complexity.tex

@@ -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}$
+
+\inlineremark 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*}

semester3/ti/parts/05_complexity/03_class-np.tex

@@ -0,0 +1,2 @@
+\newpage
+\subsection{Die Klasse NP und Beweisverifikation}

semester3/ti/parts/05_complexity/04_np-completeness.tex

@@ -0,0 +1,2 @@
+\newpage
+\subsection{NP-Vollständigkeit}

semester3/ti/ti-summary.tex

@@ -1,8 +1,6 @@
 \documentclass{article}
 
-\newcommand{\dir}{~/projects/latex}
-\input{\dir/include.tex}
-\load{full}
+\input{~/projects/latex/dist/full.tex}
 \setLang{de}
 
 \setup{Theoretische Informatik}
@@ -10,6 +8,10 @@
 \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
@@ -96,6 +98,17 @@
 \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}
 
 
 \end{document}