\documentclass[11pt]{scrartcl}
\usepackage[utf8]{inputenc}
\usepackage[ngerman]{babel}
\usepackage{amsmath}
\usepackage{amssymb}
%usepackage{multicol}
%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}

\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{\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.)

\end{document}