|
|
\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 Domins 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 aös 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
|
|
|
|
|
|
\end{document}
|
