\documentclass[11pt]{scrartcl}
\usepackage[utf8]{inputenc}
\usepackage[ngerman]{babel}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{multicol}
\usepackage{framed}
%\usepackage{booktabs}
%\usepackage{pstricks}
%\usepackage{pst-node}
\usepackage[paper=a4paper,left=30mm,right=20mm,top=20mm,bottom =25mm]{geometry}
\usepackage[
	pdftitle={Berechenbarkeits.- Komplex.Th.},
	pdfsubject={Mitschrift der Vorlesung "Berechenbarkeits.- Komplex.Th." an der HTW-Aalen, bei Herrn Thierauf.},
	pdfauthor={Thomas Battermann},
	pdfkeywords={Berechenbarkeits.- Komplex.Th.},
	pdfborder={0 0 0}
]{hyperref}
\usepackage{tabularx}
%\usepackage{graphicx}
\usepackage[usenames,dvipsnames]{color}
\usepackage{lastpage}
\usepackage{fancyhdr}
\setlength{\parindent}{0ex}
\setlength{\parskip}{2ex}
\setcounter{secnumdepth}{4}
\setcounter{tocdepth}{4}
\definecolor{darkgreen}{rgb}{0,0.5,0}
\definecolor{darkblue}{rgb}{0,0,0.5}
\definecolor{greenblue}{rgb}{0,0.5,0.5}
\definecolor{lightgreen}{rgb}{0.5,1,0.5}

\renewenvironment{leftbar}[1]{%
    \def\FrameCommand{{{\vrule width #1\relax\hspace {8pt}}}}%
    \MakeFramed {\advance \hsize -\width \FrameRestore }%
}{%
    \endMakeFramed%
}

\pagestyle{fancy} %eigener Seitenstil
\fancyhf{} %alle Kopf- und Fußzeilenfelder bereinigen
\fancyhead[L]{Berechenbarkeits.- Komplex.Th.} %Kopfzeile links
\fancyhead[C]{Semester 3} %zentrierte Kopfzeile
\fancyhead[R]{WS 2011/2012} %Kopfzeile rechts
\renewcommand{\headrulewidth}{0.4pt} %obere Trennlinie
\fancyfoot[C]{Seite \thepage\ von \pageref{LastPage}}
\renewcommand{\footrulewidth}{0.4pt} %untere Trennlinie

\newcommand{\spa}{\hspace*{4mm}} 
\newcommand{\defin}{\textcolor{darkgreen}{\textbf{Def.: }}}
\newcommand{\satz}{\textcolor{darkblue}{\textbf{Satz: }}}
\newcommand{\bew}{\textcolor{greenblue}{\textbf{Beweis: }}}
\newcommand{\bsp}{\textcolor{lightgreen}{\textbf{Bsp.: }}}
\newcommand{\rrfloor}{\right\rfloor}
\newcommand{\llfloor}{\left\lfloor}

\title{Berechenbarkeits.- Komplex.Th.}
\author{Mitschrift von Thomas Battermann}
\date{3. Semester}

\begin{document}
	\pagestyle{empty}
	
	\maketitle\thispagestyle{empty}
	\tableofcontents\thispagestyle{empty}
	
	\newpage
	\pagestyle{fancy}
	\setcounter{page}{1}

	\section{Turingmaschinen}	

	Eingabe und Arbeitsband
	\begin{tabular}{c|c|c|c|c|c|c}
		\hline
			& \color{Orange}{\(x_1\)} & \(x_2\) & \(x_3\) & … & \(x_n\) & \\
		\hline
	\end{tabular}
	{\color{Orange}Lese- Schreibkopf}

	Abhängig vom Zustand und vom gelesenen Zeichen auf dem Band kann die Maschine:
	\begin{itemize}
		\item den Zustand wechseln
		\item das gelesene Zeichen überschreiben
		\item den Lese-Schreib-Kopf um \( \le 1\) Feld auf dem Band nach links oder rechts bewegen.
	\end{itemize}

	Formal:\\
	Ein \underline{Turingmaschine} (TM) M hat 8 Komponenten,\\
	\spa \( M = (Z, \Sigma, \Gamma, \delta, Z_0, Z_a, Z_V,\Box ) \)\\
	wobei:
	\begin{itemize}
		\item \(Z\) – Zustände
		\item \(\Sigma\) – Eingabealphabet
		\item \(\Gamma\) – Arbeitalphabet
		\item \(Z_0\) – Anfangszustand
		\item \(Z_a\) – akzeptierender Zustand
		\item \(Z_V\) – verwerfender Zustand
		\item \(\Box\) – Blank \( \in \Gamma  \) – \(\Sigma\)
	\end{itemize}

	Die Übergangsfunktion S,\\
	\spa \( \delta: Z \times \Gamma \to Z \times \Gamma \times \{ L,N,R \} \)\\
	D.\,h. typische Anweisung ist\\
	\spa \( \delta(z,a) = (Z',b,x) \)\\
	Wenn M im Zustand z ist und das Zeichen a liest, dann wechselt M in den Zustand \(Z'\), überschreibt a mit b und bewegt den Lese-Schreibkopf um ein Feld nach links, falls \( X=L\)
	\begin{itemize}
		\item um ein Feld nach rechts, falls \( X=R\)
		\item bleibt stehen, falls \( X=N\)
	\end{itemize}

	Rechnung von M auf Eingabe \( x = x_1 … x_n \in \Sigma^x \):\\
	Initial steht x auf dem Eingabeband und der Lese-Schreibkopf auf dem 1. Zeichen \(x_1\) .\\
	Links und rechts der Eingabe steht \(\Box\) auf allen Feldern (Beidseitig unbeschränktes Band).\\
	Anfangszustand ist \(Z_0\)
	Dann fährt die Maschine Schritte gemäß \(\delta\). Die Rechnung stoppt, wenn \(Z_a\) oder \( Z_V\) erreicht wird. x wird akzeptiert, falls \(Z_a\) erreicht wird, sonst wird x verworfen.

	Die von \underline{M akzeptierte Sprache} ist\\
	\spa \( L(M) = \{ x \in \Sigma* \mid M \text{ akzeptiert } x \} \)
	Bsp. Sei \( \Sigma = \{ 0,1 \} \)\\
	\spa Berechne \(f(x) = x+1 \)\\
	\begin{tabular}{c|c|c|c|c}
		\hline
		\(\Box\) & 1& 0 & 1 & \(\Box\) \\
		\hline
	\end{tabular} \( \to \)
	\begin{tabular}{c|c|c|c|c}
		\hline
		\(\Box\) & 1& 1 & 0 & \(\Box\) \\
		\hline
	\end{tabular}

	Der berechnete Funktionswert ist definiert als das Wort \( \in \Sigma* \) von der Position des Lese-Schreibkopfs nach rechts, bis zu 1. Blank.\\
	In \(Z_a\).

	\( \sigma(Z_0,0) = (Z_0, 0, R) \)\\
	\( \sigma(Z_0,1) = (Z_0, 1, R) \)\\
	\( \sigma(Z_0,\Box) = (Z_1, \Box, L) \)\\
	\( \sigma(Z_1,0) = (Z_2, 1, L) \)\\
	\( \sigma(Z_1,1) = (Z_1, 0, L) \)\\
	\( \sigma(Z_2,0) = (Z_2, 0, L) \)\\
	\( \sigma(Z_2,1) = (Z_2, 1, L) \)\\
	\( \sigma(Z_2,\Box) = (Z_a, \Box, R) \)\\
	\( \sigma(Z_1,\Box) = (Z_a, 1, N) \)

	Als Diagramm
	% TODO

	\( L = \{ 0^{2^n} \mid n \ge 0 \} \)\\
	\( 0, 00, 0^4, 0^8, …\)

	\begin{tabular}{c|c|c|c|c|c}
		\hline
		 & 0 & 0 & 0 & 0 & \\
		\hline
	\end{tabular}

	\begin{enumerate}
		\item Vorschlag: Zähle\\
			\begin{tabular}{c|c|c|c|c|c}
				\hline
				& \( \not0\) & 0 & … 0 & \( \Box \) & 0\\
				\hline
			\end{tabular}
		\item Vorschlag:\\
			\begin{enumerate}
				\item streiche jede 2. Null, teste dabei, ob Anzahl gerade
				\item iteriere Schritt 1\\
					bis nur noch eine Null bleibt.\\
					% TODO: Diagramm
					\( 0000 \to 0x0x \to 0xxx \)
			\end{enumerate}
	\end{enumerate}
	
	\subsection{Erweiterungen}

	\subsubsection{Mehrband-Turingmaschine}

		Turingmaschine mit fester Anzahl k von Bändern. Davon eins ausgezeichnet für die Eingabe.\\
		\( \delta: Z \times \Gamma^k \to Z \times \Gamma^k \times \{ L,N,R \}^k \)

		Bsp.:\\
		\( \delta(Z,a,b) = \delta(Z', c,d,L,R) \)

		Bsp.: \( L = \left\{ w \# w \mid w \in \{0,1\}^k \right\} \)\\
		\( 100\#100 \to x00\#x00 …\)

		\underline{2-Band-Turingmaschine}\\
		kopiert w auf 2. Band\\
		\spa \( \delta(Z_0, a, \Box) = (Z_0,a,a,R,R) \) für \( a \in \{1,0\}\)\\
		\spa \( \delta(Z_0, \#,\Box) = (Z_1, \#,\Box, N,L) \)\\
		\spa \( \delta(Z_1, \#,\Box) = (Z_1, \#,a, N,L)\)\\
		\spa \( \delta(Z_1, \#,\Box) = (Z_2, \#,\Box,R,R) \)\\
		\spa \( \delta(Z_2, a,a) = (Z_2,a,a,R,R) \)\\
		\spa \( \delta(Z_2, \Box,\Box) = (Z_a, \Box,\Box,N,N) \)

		Alles was fehlt geht nach \( Z_V \)

	\subsubsection{Nichtdeterministische Turingmaschine (NTM)}

		Definiert wie Turingmaschine, mit:\\
		\spa \( \delta: Z\times \Gamma \to \mathcal{P}(Z \times \Gamma \times \{ L,N,R \}) \)\\
		z.\,B. \( \delta(Z,a) = \{ (Z_1,b,L) , (Z_2,c,N) \} \)

		M akzeptiert x, falls es eine akzeptierende Rechnung gibt.

	\subsubsection{Nichtdeterministische Mehrband Turingmaschine}

	Bsp. \( L = \{ x0y \mid \left|x\right| = \left|y\right| \}\)\\
	über \( \Sigma = \{0,1\}\)

	\begin{align*}
		\delta(Z_0, 1, \Box) &= \{( Z_0,1,1,R,R )\}\\
		\delta(Z_0,0,\Box) &= \{ (Z_0,0,0,R,R), (Z_1,0,\Box,R,L) \}	\\
		\delta(Z_1,a,b) &= \{ (Z_1,a,b,R,L) \} \quad a,b \rightarrow \{0,1\}\\
		\delta(Z_1,\Box,\Box) &= \{ (Z_a,\Box,\Box,N,N) \}\\
		\delta(Z_0,\Box,\Box) &= \{ (Z_v,\Box,\Box,N,N) \}\\
	\end{align*}
	(fehlende Anweisungen verwerfen.)

	Deterministisch: \(\delta: Z\times \Gamma \to Z \times \Gamma \times \{ L,N,R\} \)\\
	Nicht Deterministisch: \(\delta: Z\times \Gamma \to \mathcal P(Z \times \Gamma \times \{ L,N,R\}) \)

	\satz Zu jeder k-Band Turingmaschine gibt es eine äquivalente (1-Band) Turingmaschine\\
	\underline{Bew.:} (Idee)\\
	k-Band Turingmaschine M\\\
	\begin{tabular}{c|c|c|c|c} \hline & x & & & \\\hline & & y & & \\\hline & & & z & \\\hline \end{tabular}

	TM M'\\
	\begin{tabular}{c|c|c|c|c|c|c|c|c|c|c|c|c|c|c}
		\hline & \# & x & & & \# & & y & & \# & & & z & \# &  \\\hline
	\end{tabular}

	M:\\	
	\begin{tabular}{c|c|c|c|c|c}
		\hline
		\(\Box\)&a&b&a&c&\(\Box\)\\
		\hline
		\(\Box\)&c&c&\(\Box\)\\
		\hline
		\(\Box\)&b&a&a&a&\(\Box\)\\
		\hline
	\end{tabular}

	M':\\
	\begin{tabular}{c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c}
		\hline
		\# & \(\Box\)& a& \(\dot b\)& a&c&\(\Box\)&\#&\(\Box\)&\(\dot c\)&a&\(\Box\) & \# & \(\dot\Box\) & b&a&a&a&\(\Box\)&\#\\
		\hline
	\end{tabular}\\
	\( \dot b \rightarrow \Gamma' - \Gamma \)

	M' läuft 2x mal über das gesamte Band (und zurück)
	\begin{enumerate}
		\item M' merkt sich alle Zeichen, die die Lese-Schreibköpfe aktuell lesen
		\item M' führt die Änderungen gemäß \(\delta\) von M auf allen Bändern aus.
	\end{enumerate}

	Merke Zeichen im Zustand:\\
	\spa \( Z_{Z,b,c,\Box} \)\\
	d.\,h. \(\left|Z\right| \cdot \left|\Gamma\right|^3 \) viele Zustände, also endlich.

	Initial:\\
	\begin{tabular}{c|c|c|c|c|c|c}
		\hline
		\# & x & \# & \(\Box\) & \# & \(\Box\) &\#\\
		\hline
	\end{tabular}

	Zeit: M macht t Schritte auf Eingabe X.\\
	Alle Bänder von M' sind also mit Wörtern beschriftet mit Länge \(\le t\)\\
	\(\to\) Beschrifteter Teil des Bands von M hat Länge \(\le k \cdot t \)

	Pro Schritt von M macht M'
	\begin{itemize}
		\item \( \le 2 \cdot 2 \cdot t \) Schritte für die beiden Durchläufe.
		\item verschieben zum Platz schaffen \( \le k \cdot 2\cdot t\)
		\item Zusammen \( \le (k+2) \cdot 2\cdot t = \mathcal O(t)\).\\
			M macht t Schritte \( \Rightarrow M' \) macht \( \mathcal O(t^2) \) Schritte
	\end{itemize}

	\satz Zu jeder NTM gibt es eine äquivalente TM.

	Bew. (Idee):\\
	Sei M NTM

	Strategie: durchsuche Baum "Breite zuerst". Dazu zunächst Mehrband-TM (det.).\\

	Pro Adresse:
	\begin{itemize}
		\item Kopiere x auf das (leere) Simulationsband,
		\item führe Rechnung von M auf x aus, wobei jeweils die Anweisung gemäß Adresse benützt wird.
		\item falls M akzeptiert wird, dann akzeptierte.
	\end{itemize}
	
	Bann lösche Simulationsband, erhöhe Adresse um 1 (zur Basis d) und wiederhole.

	Zeit: Habe jede Rechnung von M die länge \(\le t\)\\
	\(\Rightarrow\) Anzahl der Knoten im Baum ist \( \le d^{t+1} - 1 \)\\
	\(\Rightarrow\) Rechenzeit von M': \(\mathcal O(t+n)\cdot d^t\)\\
	\(\Rightarrow\) Rechenzeit der det. 1-Band TM M'' ist dann \( \mathcal O\left(\left(\left(t+n\right) \cdot d^t\right)^2\right) \)

	\begin{align*}
		  &\mathcal O(t^2 2^{2t \cdot \log d})\\
		= &\mathcal O(2^{2 \log t} \cdot 2^{2 \cdot \log d})\\
		= &\mathcal O(2^{2t \log d + 2 \log t})\\
		= &\mathcal O(2^{2^{2t(\log d + 1)}})\\
		= & 2^{\mathcal O(t)}
	\end{align*}

	Weitere Rechenmodelle haben sich alle als äquivalent zur TM erwiesen. Insbesondere lässt sich jedes C-Programm in eine äquivalente TM umschreiben.

	\underline{These von Turing/Church}

	Algorithmus = TM
	intuitiver Begriff = formal 

	\subsection{Kodierung von Turingmaschinen}

	Sei M TM mit \( Z = \{ Z_1, Z_2, …, Z_k \}\) und \( \Sigma \le \Gamma = \{ a_1, a_2, …, a_m \} \)\\
	Sei \( \delta(Z_i,a_j) = (Z_{i'}, a_{j'}, d) \)\\
	\( d = \{ L,M,R \} \)

	Kodiere mit:\\
	\( x_{i,j} = 0 1^i 0 1^j 0 1^{i'} 0 1^{j'} 0 1^{d'} 0 \)

	mit \( d = \begin{cases} 1 & \text{,falls d = L} \\ 2 & \text{,falls d = N} \\ 3 & \text{,falls d = R} \end{cases} \)

	Kodiere M durch\\
	\( x = x_{1,1} x_{1,2} … x_{1,m} x_{2,1} … x_{k,m} \)

	Dabei lege fest: \(Z_1\) ist Startzustand; \( Z_{k-1} \) ist \(Z_V\); \(Z_k\) ist \( Z_a \)\\
	und \( a_1 = \Box \)

	Damit besitzt jede Turingmaschine M eine Kodierung \( x \in \{0,1\}^* \). x heißt auch \underline{Index} oder \underline{Gödelnummer von M}\\
	Nicht jedes Wort aus \(\{0,1\}^*\) taucht als Kodierung gemäß obigem Schema auf.\\
	Deswegen: Für \(x\in \{0,1\}^* \)\\
	\( x \to \begin{cases} M_x & \text{, falls Kodierung von } M_x x \text{ ergibt}\\ M_0 & \text{, sonst} \end{cases} \)\\
	\(M_0\) fest, mit \( L(M_0) = \emptyset \)

	Mit dieser Festlegung kodiert \underline{jedes} Wort \( x \in \{0,1\}^* \) eine TM \(M_x\).

	D.\,h. \( \{0,1\}^* = \{ \epsilon, 0, 1, 00, 01, 10, 11, 000, … \} \)\\
	dies ist eine Aufzählung aller 0-1-Wörter und damit auch aller Turingmaschinen.

	\subsection{Das Halteproblem}

	\( H = \{ (x,y) \mid M_y(x) \text{ hält} \} \)\\
	dabei sei \((x,y) = x_1 x_1 x_2 x_2 … x_n x_n 01 y \)\\
	\( (010, 10) = \begin{cases} 000101010 \\ 00 11 00 10 \underbrace{10}_{y} \end{cases} \)

	\subsection{Die Universalsprache}

	\( U = \{ (x,y) \mid M_y \text{ akzeptiert } x \} \)

	Eine Sprache L heißt (Turing-) \underline{akzeptierbar}, falls es eine Turingmaschine M gibt, mit \( L(M) = L \).

	L heißt (Turing-) \underline{entscheidbar}, falls M zusätzlich auf alle Eingaben hält.

	U ist akzeptierbar:\\
	Beschreibe zunächst eine 3-Band-Turingmaschine\\
	M für U\\
	M: \begin{tabular}{c|c|c}
		\hline
		&\((x,y)\)&\\
		\hline
	\end{tabular}\\
	\(\underset{Z_1\text{ Startzustand}}{\to}\)\\
	\begin{tabular}{c|c|c|c|c|c}
		\hline
		&\(x_1\)&\(x_2\)&…&\(x_n\)&\\
		\hline
		& \(Z_1 \) &\\
		\hline
		&\(y\)&\\
		\hline
	\end{tabular}\\
	dann simuliere \(M_y\) auf dem 1. Band

	d.\,h. Suche in y die Stelle wo \( \delta(Z_1,x_1)\) definiert ist und führe dann Änderungen auf dem 1. Band aus. * Dann gehe auf Band 2 und 3 wieder nach links und wiederhole.\
	Abbruch wenn \(M_y\) \(Z_a\) oder \(Z_v\) erreicht.

	* Auf Band 2 ändere den Zustand.

	M akzeptiert, falls \(M_y\) \(Z_a\) erreicht und verwirft bei \(Z_v\).

	Dann gilt:\\
	\begin{itemize}
		\item \((x,y) \in U \Rightarrow M_y(x) \) akzeptiert.\\
			\(\Rightarrow M_y(x)\) kommt nach endlich vielen Schritten nach \(Z_a\)\\
			\(\Rightarrow M(x,y)\) akzeptiert
		\item \( (x,y) \not\in U \Rightarrow M_y(x)\) verwirft.
			\begin{itemize}
				\item[a)] \( M_y(x) \) erreicht \(Z_v\)\\
					\( \Rightarrow M(x,y)\) verwirft.
				\item[b)] \( M_y(x) \) hält nicht\\
					\( \Rightarrow M(x,y) \) hält nicht.\\
					\( \Rightarrow M(x,y) \) verwirft.
			\end{itemize}
	\end{itemize}

	Es gibt also \( L(M) = U \).\\
	Sei \(M_U\) die zu M äquivalente (1-Band) Turingmaschine.\\
	\(M_U\) heißt \underline{universelle Turingmaschine}. 

	Analog ist H akzeptierbar.\\
	(nehme M von oben und akzeptiere auch, wenn \(Z_v\) erreicht wird.)

	Bezeichnungen:\\
	\begin{itemize}
		\item akzeptierbar
			\subitem rekursiv aufzählbar
			\subitem semi-entscheidbar
			\subitem partiell rekursiv
		\item entscheidbar
			\subitem rekursiv
	\end{itemize}

	Wir Konstruieren eine Sprache $D$, die nicht \underline{nicht} akzeptierbar ist.\\
	D.\,h. \( D \not= L(M) \) für alle Turingmaschinen M.

	\begin{tabular}{c|ccccc}
		TM \( \backslash \Sigma^*\) & \(x_1\) &\(x_2\) &\(x_3\) &\(x_4\) & … \\
		\hline
		\(x_1\)    & 0 & 1 & 0 & 0 & …\\
		\(x_2\)    & 1 & 0 & 1 & 1 & \\
		\(x_3\)    & 0 & 0 & 1 & 1 & \\
		\(x_4\)    & 1 & 0 & 1 & 0 & …\\
		\(\vdots\) &   &   &   & \(\vdots\) 
	\end{tabular}\\
	\( M_{x_1} (x_3)\) verwirft\\
	\( M_{x_1} (x_4)\) akzeptiert

	Jede Zeile in der Tabelle beschreibt eine Sprache:\\
	Zeile $i$: die von \( M_{x_i}\) akzeptierte Sprache.\\
	Wir konstruieren $D$ so, dass $D$ mit \underline{keiner} Zeile der Tabelle übereinstimmt.

	\( D = \{ x \mid x \not\in L(M_x)\} \)

	Dann ist $D$ nicht akzeptierbar:

	Angenommen \( D = L(M) = L(M_x) \)\\
	für ein \( x \in \Sigma^* \)

	Es gilt aber \( x\in D \leftrightarrow x \not\in L(M_x) \)\\
	Widerspruch!

	\underline{Diagonalsprache} \( D = \{ x \mid x \not\in L(M_X) \} \) ist nicht \underline{akzeptierbar}.

	%%TODO: Grafik

	\( U = \{ (x,y) \mid i\underbrace{M_y \text{ akzeptiert } x}_{x \in L(M_y)} \} \)

	\satz $H$ und $U$ sind nicht entscheidbar.

	Beweis zu $U$: Angenommen $U$ wäre entscheidbar. D.\,h. es gibt eine Turingmaschine $M$, die $U$ akzeptiert die auf alle Eingaben hält.\\
	Dann entscheidet folgende Turingmaschine $M'$ die Sprache $D$:

		\( D = \{ x \mid (x,x) \not\in U \} \)\\
		\( H = \{ (x,y) \mid M_y \text{ auf } x \text{ hält } \} \)

	$M'$:
	\begin{leftbar}{1mm}
		Eingabe $x$.\\
		Starte $M$ auf Eingabe $(x,x)$\\
		Falls $M$ akzeptiert, dann verwerfe, sonst akzeptiere.
	\end{leftbar}

	Da $M$ immer hält, hält auch $M'$ auf alle Eingaben und $L( M')  = D$.\\
	Widerspruch, da $D$ nicht entscheidbar. $\Box$

	\underline{Zu $H$:} Angenommen $H$ ist entscheidbar, $H=L(M)$.\\
	Konstruiere $M'$ für $D$:\\
	$M'$:
	\begin{leftbar}{1mm}
		Eingabe $x$\\
		Starte $M$ auf Eingabe $(x,x)$.\\
		Falls $M$ akzeptiert
		\begin{leftbar}{1mm}
			dann starte $M_x$ auf $x$\\
			falls $M_x$ akzeptiert, dann verwerfe\\
			sonst akzeptiere
		\end{leftbar}
		sonst akzeptiere
	\end{leftbar}

	\begin{enumerate}
		\item \( (x,x) \in H \to M_x(x) \) hält\\
			und \( x \in D \leftrightarrow M_x \) verwirft
		\item \( (x,x) \not\in H \Rightarrow M_x(x)\) hält nicht\\
			\( \Rightarrow M_x \) verwirft $x$\\
			\( \Rightarrow x \in D \)\\
			Es gilt.: $M'$ hält auf alle Eingaben und \( L(M') = D \). Widerspruch \( \Box\)
	\end{enumerate}

	Das \underline{spezielle Halteproblem}\\
	\spa \( H_0 = \{ x \mid M_x(x) \text{ hält } \} \)\\
	$H_0$ ist akzeptierbar und entscheidbar.

	\underline{Zu $H_0$}: Angenommen $H_0$ ist entscheidbar, \( H_0 = L(M)\).

	\( T = \{ x \mid M_x \text{ hält auf alle Eingabe }\} \)

	Turingmaschine $M$ heißt \underline{total}, falls $M$ auf alle Eingaben hält.

	\( L_E = \{ x \mid M_x \text{ hat Eigenschaft } E \} \)

	\satz $T$ ist nicht entscheidbar.
	
	\bew Sonst wäre $H$ entscheidbar.\\
	Sei $M_T$ Turingmaschine für $T$ (die immer hält)\\
	Turingmaschine $M$ für $H$: Eingabe $(x,y)$.\\
	Betrachte folgende Turingmaschine $M_0$:

	\begin{leftbar}{1mm}
		$M_0$ auf Eingabe $w \in \Sigma^*$:\\
		\spa Simuliere $M_y(x)$\\
		\spa Falls $M_y(x)$  hält, dann akzeptiere
	\end{leftbar}

	\begin{itemize}
		\item[1. Fall:]
			\( (x,y) \in H \Rightarrow M_y(x) \) hält.\\
			\( \Rightarrow M_0 \) akzeptiert\\
			\( L(M_0) = \Sigma^* \)
		\item[2. Fall:]
			\( (x,y) \not\in H \Rightarrow M_0\) hält nicht\\
			\( \Rightarrow M_0 \) verwirft\\
			\( \Rightarrow L(M_0) = \emptyset \)
	\end{itemize}

	Sei $y_0$ Kodierung von $M_0$.\\
	Dann gilt:\\
	\spa \( (x,y) \in H \Leftrightarrow y_0 \in T \)

	$M$ für $H$:\\
	\begin{leftbar}{1mm}
		Eingabe $(x,y)$\\
		Konstruiere Turingmaschine $M_0$ (aus $x$ wird $y$)\\
		Sei $y_0$ Kodierung von $M_0$\\
		Falls $y_0 \in T$, dann akzeptiere\\
		Sonst verwerfe
	\end{leftbar}

	\begin{itemize}
		\item[1. Fall]
			\( (x,y) \in H \Rightarrow M_x(x) \) hält\\
			\( \Rightarrow L(M_0) = \Sigma^* \) \\
			\( \Rightarrow \) insbesondere hält $M_0$ auf alle Eingaben\\
			\( \Rightarrow y_0 \in T \)\\
			\( \Rightarrow M \) akzeptiert \( (x,y) \)
		\item[2. Fall]
			\( (x,y) \not\in H \Rightarrow L(M_0) = \emptyset \) und $M_0$ hält auf \underline{\underline{keine}} Eingabe\\
			d.\,h. $M$ entscheidet $H$ Widerspruch \( \Box \)
	\end{itemize}

	\( L_E = \{ x \mid \text{Turingmaschine } M_x \text{ hat }\underbrace{\text{Eigenschaft}}_{\text{Spracheigenschaft}} E \} \)

	ist unentscheidbar für jede Eigenschaft $E$.
	\underline{Satz von Rice}

	\bsp \( F = \{ x \mid L(M_x) \text{ ist endlich} \} \)

	finite: \( \overline{F} = \{ x \mid L(M_x) \text{ ist unendlich} \} \)

	empty: \( E = \{ x \mid L(M_x) = \emptyset \} \)

	\( S = \{ x \mid L(M_x) = \Sigma^* \)

	Äquivalenz \( = \{ (x,y) \mid L(M_x) = L(M_y) \} \)

	Äquivalenz für alle Sprachen\\
	\spa \( = \{ (x,y) \mid x,y \text{ sind PDAs und } L(M_y) = L(M_y) \} \)\\
	ist unentscheidbar.

	\underline{Gödel}: mehrere Arithmetische Formeln:\\
	\( \forall n \exists m : (n=2m \text{ oder } n=2m-1) \) wahr\\
	\( \forall n \exists m: n=2m \) falsch

	Post’sches Korrespondenz Problem (PCP)

	gegeben sind Dominos der Form \( \left[ \frac x y \right] \)\\
	wobei \(x,y \in \Sigma^* \), endlich viele Typen, von jedem Type beliebig viele.

	\bsp \( D = \{ \left[ \frac{b}{ca} \right], \left[ \frac{a}{ab} \right], \left[ \frac{ca}{a} \right], \left[ \frac{abc}{c} \right] \} \)

	Ziel: lege Dominos so, dass das Wort, das oben steht gleich dem ist, das unten steht.

	\( \left[ \frac{a}{ab} \right] \left[ \frac{b}{ca} \right] \left[ \frac{ca}{a} \right] \left[ \frac{abc}{c} \right] \) Widerspruch!\\
	\( \left[ \frac{a}{ab} \right] \left[ \frac{b}{ca} \right] \left[ \frac{ca}{a} \right] \left[ \frac{a}{ab} \right] \left[ \frac{abc}{c} \right] \)

	$D$ hat Lösung, also \( D \in PCP \)

	\( D_1 = \{ \left[ \frac{ab}{abc} \right] \left[ \frac{c}{ab} \right] \left[ \frac{ac}{cab} \right] \left[ \frac{ba}{acb} \right] \)

	\( \left[ \frac{ab}{abc} \right]\left[ \frac{c}{ab} \right] \)

	hat keine Lösung, da Wörter unten immer Länger als Wörter oben sind. \( D_1 \not\in PCP \)

	\bsp \( \{ \left[ \frac{0}{011} \right] \left[ \frac{001}{1} \right] \left[ \frac{1}{00} \right] \left[ \frac{11}{110} \right] \} \)\\
	Kürzeste Lösung hat 515 Dominos.

	PCP ist unentscheidbar

	Eulerkreise:

	Rundweg in $G$, der über \underline{jede} Kante \underline{genau einmal} führt.\\
	Kreis \( = (1,5,2,3,1,2,4,6,3,4) \)

	Ein Eulescher Kreis besucht jeden Knoten gerade oft, d.\,h. jeder Knoten muss geraden Grad haben.\\
	\satz (Euler) $G$ ungerichtet, zusammenhängend\\
	$G$ hat Eulerkreis \( \Leftrightarrow \) jeder Knoten hat geraden Grad.

	Zu "\(\Leftarrow\)":
	Konstruiere Eulerkreis\\
	Starte an beliebigem Knote, der noch unbesuchte Knoten hat. Laufe in beliebige Richtung, solange bis es nicht mehr weiter geht.\\
	Falls es noch unbesuchte Kanten gibt, wiederhole.\\
	Füge (rekursiv) die Kreise zu einem Kreis zusammen.

	Der Algorithmus funktioniert, weil in jeder Iteration in dem Restgraph mit dem noch unbesuchten Kanten jeder Knoten geraden Grad hat. (Invariante)

	\underline{Hamilton Kreise}

	= Kreise, in denen jeder Knoten genau einmal besucht wird.

	Brute force: teste alle Möglichkeiten.\\
	n Knoten. Liste alle Permutationen der n Knoten auf.\\
	\(1,2, 3, …, n\)\\
	\(2,1,3,…,n\)\\
	…

	für jede Permutation teste, ob sie ein Hamilton Kreis ist d.\,h. ob alle Kreiskanten in $G$ existieren.\\
	Laufzeit \( \ge n! \) (im schlechtesten Fall)\\
	\( n! \approx 2^{n \log n} \ge 2^n \)\\
	also exponentielle Laufzeit.

	(Sehr schneller) Rechner mit \( 10^9 \frac{\text{instructions}}{s} \)\\
	\( n = 100 \)\\
	\begin{tabular}{c|c|c|c|c}
		$t(n)$ & $n$ & $n^2$ & $n^3$ & $2^n$ \\
		\hline
		Zeit   & $\frac{1}{10^7}$ & $\frac{1}{10^4}$ & $\frac{1}{10^2}$ & \( \frac{2^{100}}{10^9}  = \frac{(2^{10})^{10}}{10^9} \approx \frac{(10^3)^{10}}{10^9} = 10^{21} s = 3 * 10^{13} \) Jahre
	\end{tabular}

	Schnellere Hardware:\\
	Sei $n_0$ = Eingabegröße, die in 1h gelöst wird.\\
	Neue Rechner, 1000-mal schneller als bisher.\\
	Berechne $n_1$ = Eingabegröße, die in einer Stunde mit den neuen Rechnern gelöst wird.
	\begin{enumerate}
		\item
			\( t(n) = n \)\\
			1h. \( t(n_1) = 1000 t(n_0) \)\\
			\( n_1 = 1000 * n_0 \)
		\item 
			\( t(n) = n^2: n_1^2 = 1000*n_0^2 \)\\
			\( n1 = \underbrace{\sqrt{1000}}_{\approx 33} * n_0 \)
		\item
			\( t(n) = n^3 \)\\
			\( n_1^3 = 1000*n_0^3 \)\\
			\( n_1 = 10 * n_0 \)
		\item
			\( t(n) = 2^n \)\\
			\( 2^{n_1} = 1000 * 2^{n_0} = 2^{n_0 + \log 1000} \)\\
			\( \Rightarrow n_1 = n_0 + \underbrace{\log 1000}_{\le 10} \)
	\end{enumerate}
\end{document}
