4. Turingmaschinen

4.1 Das Modell der Turingmaschine

Wir definieren eine Turingmaschine wie folgt:

4.1 Turingmaschine

Eine TM ist ein 7-Tupel $M=(Q,\Sigma ,\Gamma ,\delta ,q_0,q_{accept},q_{reject})$.

1. $Q$ endliche Menge (Zustandsmenge) und $q_0$ Startzustand
2. $\Sigma$ das Eingabealphabet (ohne $\text{textcent}$ und $\bigsqcup$)
3. Arbeitsalphabet $\Gamma$
4. $\Sigma \subseteq \Gamma$
5. $\text{textcent},\bigsqcup \in \Gamma$
6. $Q\cap \Gamma =\varnothing$
7. $\delta :(Q-\{q_{accept},q_{reject}\})\times \Gamma \to Q\times \Gamma \times \{L,R,N\}$ die Übergangsfunktion
8. $\delta (q,\text{textcent})\in Q\times \{\text{textcent}\}\times \{R,N\}$ also man darf nicht nach links (vom Band runter)
9. $q_{accept}$ der akzeptierende Zustantd (accept and reject state → wir wissen sonst nicht ob sie fertig ist)
10. gibt kein eindeutiges ende nach einlesen wie bei EAs mehr
11. unendliche machine States → wegen dem Band
12. $q_{reject}\in Q\setminus \{q_{accept}\}$ der verwerfende Zustand

Band: Das band ist nicht in beide Richtungen unendlich (zumindest bei uns)

• damit wir nummerieren können → linker Rand $\text{textcent}$
• unendlich nach rechts, alle nicht beschriebenen mit $\bigsqcup$ versehen

Konfiguration: $\text{Konf}(M)=\{\text{textcent}\}\cdot {\Gamma }^{\ast }\cdot Q\cdot {\Gamma }^{+}\cup Q\cdot \{\text{textcent}\}\cdot {\Gamma }^{+}$

• note mindestens ein Symbol am ende noch (deswegen +, nicht *) → sonst illegaler Zustand
• oder mit dem Kopf am Anfang $Q\{\text{textcent}\}{\Gamma }^{+}$ → Startconfig $q_0\text{textcent}x$

Schritt von $M$ ist eine Relation ${⊢}_M$ auf $\text{Konf}(M)\times \text{Konf}(M)$ definiert.

• L für links steppen, R für rechts, N für nichts
• wenn rechts noch nichts is, definiert mit $\bigsqcup$ rechts von $q$
  Berechnung von $M$ ist potentiell unendliche Folge von Konfigurationen.

Berechnung:**

• Akzeptierend/Verwerfend → nur wenn es endet
  → nicht-akzeptierende ist entweder unendlich oder verwerfend.

**Sprachen:

Akzeptierende Sprache

Die Akzeptierende Sprache $L(M)$ ist die Menge aller Startconfigs sodass die TM akzeptiert (i.e. endet).

Berechnet

TM berechnet $F$ falls für alle $x\in \Sigma \ast$ gilt $q_0\text{textcent}x{⊢}_M^{\ast }{q}_{accept}\text{textcent}F(x)$. (i.e. immer das gleiche wie die Funktion ausgibt).

Note Eine Funktion $F:{\Sigma }_1^{\ast }\to {\Sigma }_2^{\ast }$ heißt total berechenbar wenn TM existiert, die $F$ berechnet

Rekursiv Aufzählbar

Eine Sprache ist Rekursiv Aufzählbar falls TM $M$ existiert, sodass sie alle $x\in L$ akzeptiert (i.e. $L(M)=L$).
Kann auch unendlich laufen wenn $x\notin L$.
Wir notieren ${\mathcal{L}}_{RE}$ als die Menge aller rekursiv aufzählbarere Sprachen

ACHTUNG: Rekursiv aufzählbar < schwächer Rekursiv

• wenn nur RE → kann auch unendlich laufen.

Wie hier zu sehen $L_R\subset L_{R}E$.

Rekursive Sprachen

Eine Sprache heisst Rekursiv (die Menge ${\mathcal{L}}_R$) der rekursiven, algorithmisch erkennbaren Sprachen falls:

• Für $x\in L$ → halts in $q_{accept}$ (in math: $q_0\text{textcent}x{⊢}_M^{\ast }y{q}_{accept}z$, $y,z\in {\Gamma }^{\ast }$ falls $x\in L$)
• Für $x\in L$ → halts in $q_{reject}$ (in math: $q_0\text{textcent}x{⊢}_M^{\ast }y{q}_{reject}z$, $y,z\in {\Gamma }^{\ast }$ falls $x\notin L$)

It is not allowed to run infinitely!

Note: wir sagen auch das $M$ auf jeder Eingabe hält (oder immer hält).

So sind gerade die rekursiven Sprachen (entscheidbaren Entscheidungsprobleme) die Sprachen (Entscheidungsprobleme), die algorithmisch erkennbar (lösbar) sind.

4.2 Mehrband Turingmaschine und Church’sche These

Note: 1-MTM ist nicht das selbe wie eine TM → TM hat kein separates Eingabe / Ausgabeband

Das Eingabeband ist “read-only” und enthält $\textcent, \

welche den Anfang respektive das Ende der Eingabe repräsentieren. Die Arbeitsbänder werden mit Leerzeichen initialisiert. Eine Konfiguration hat also hier nicht nur einen "Bandzustand", sondern $Q \times \Sigma^* \times \N \times (\Gamma^* \times \N)^k$ wo $k$ die Menge der Bänder ist. -> Als Ausgabe kriegen wir auch $k$ $L, R, N$ Anweisungen The transition function has the following signature:

\delta : Q \times (\Sigma \cup { \textcent, $ }) \times \Gamma^k \to Q \times { L, R, N } \times (\Gamma \times { L, R, N })

hier ist immer "State \* Leseband \* Schreibkopf^k" **Beispiel:** Bestimmte Sprachen können einfacher mit MTM als mit TMs überprüft werden. - $L_{\text{gleich}} = \{ w \# w \mid w \in (\Sigma_{bool})^* \}$ - eine TM müsste hier immer links -> rechts um alle zu vergleichen - MTM Version: (checkt zuerst, ob form $x\#y$ gegeben ist) - läuft bis #, kopiert die Eingabe auf Band 2 - Dann geht sie die zweite Hälfte ab, immer Band 1 und 2 vergleichend > [!DEFINITION] Äquivalent > > Wir sagen, dass eine Maschine $A$ äquivalent zu $B$ ist, falls für jedes $x \in (\Sigma_{bool})^*$ gilt > 1. $A$ akzeptiert $x$ $\iff$ B akzeptiert $x$ > 2. $A$ verwirft $x$ $\iff$ B verwirft $x$ > 3. $A$ arbeitet unendlich lange $\iff$ B arbeitet unendliche lange Also gilt auch $L(A) = L(B)$ für äquivalente Maschinen. *Note:* Aber nur weil $L(A) = L(B)$ $\not \implies$ *nicht dass $A$ und $B$ äquivalent sind*! - es könnte ein $w$ geben, für das $A$ unendliche läuft und $B$ verwirft > [!LEMMA] 4.1 TM $\iff$ 1-Band-MTM > > Sei $A$ eine TM, dann existiert eine *äquivalente* $B$ 1-Band-MTM. **Proof (Idea)**: - B kopiert die Eingabe $w$ auf das Arbeitsband - B simuliert genau Schritt-für-Schritt $A$ auf dem Arbeitsband > [!LEMMA] 4.2 Mehrband TM $A$ $\implies$ TM $B$ > > Für jede Mehrband-TM $A$ existiert eine *äquivalente* TM $B$. Mit der folgenden Konstruktion, können wir eine MTM -> TM mappen. ![[tm-mtm.png]] **Proof:** $B$ speichert den Inhalt aller $k+1$ Bänder von $A$ auf dem einzigen Band, indem wir das Arbeitsalphabet erweitern. - $B$ trennt das eigene Band in $2(k+1)$ Spuren. - $\Gamma_B = \Big( {\color{royalblue}(\Sigma_{A} \cup \{ \text{¢}, \$, \sqcup \})} \times {\color{red}\{ \sqcup, \uparrow \}} \times \big( {\color{green}\Gamma_{A}} \times {\color{red}\{ \sqcup, \uparrow \}} \big)^k \Big) \cup {\color{darkorange}\Sigma_{A} \cup \{ \sqcup, \text{¢} \}}$ - ${\color{royalblue}\big(\Sigma_{A} \cup \{ \text{¢}, \$, \sqcup \}\big)}$ = Eingabeband an dieser Position + ${\color{red}\{ \sqcup, \uparrow \}}$ Position des Eingabe-Lesekopfs - $\big( {\color{green}\Gamma_{A}} \times {\color{red}\{ \sqcup, \uparrow \}} \big)^k$ enthält für jedes Arbeitsband $j = 1,\dots,k$ ein Paar - ${\color{green}\Gamma_{A}}$ = Symbol auf Arbeitsband $j$ - ${\color{red}\{ \sqcup, \uparrow \}}$ = Kopf von Band $j$ - ${\color{darkorange}\Sigma_{A} \cup \{ \sqcup, \text{¢} \}}$ sind die delimiter - $\textcent$ für den aller-ersten Eintrag, $\sqcup$ für die noch leeren - Einen Schritt von $A$ können wir mit $B$ jetzt wie folgt simulieren: - $B$ liest den gesamten Inhalt des Bandes -> findet $k+1$ Kopfpositionen und speichert die Symbole die sie dort gelesen hat - "speichert" -> $B$ hat states $q := Q_1 \times Q_2 \times \dots \times Q_{k+1}$, welche quasi alle möglichen States von allen Köpfen von $A$ *in einem beschreiben*. - Dann bewegt $B$ die $\uparrow$ und überschreibt die Symbole so wie $A$ es tun würde. > [!THEOREM] 4.1 TM and MTM Equivalent > > Die Maschinenmodelle von Turingmaschinen und Mehrband-Turingmaschinen sind äquivalent. ### 4.4.2 Church'sche These Die Church'sche These ist: "Die Turingmaschinen sind die Formalisierung des Begriffes "Algorithmus", d.h. die Klasse der rekursiven Sprachen (entscheidbaren Entscheidungsprobleme) stimmt mit der Klasse der algorithmisch (automatisch) erkennbaren Sprachen überein." ## 4.5 Nicht-deterministische Turingmaschine Wann ist einfacher mit Nicht-deterministisch? Viele ODER -> kann man einfach als set modellieren > [!DEFINITION] NTM > > *Nichtdeterministische Turingmaschine* (NTM) ist ein 7-Tupel $M = (Q, \Sigma, \Gamma, \delta, q_0, q_{accept}, q_{reject})$. Was sich zur TM ändert: - $\delta : (Q - \{ q_{accept}, q_{reject} \}) \times \Gamma \to \mathcal{P}(Q \times \Gamma \times \{ L, R, N \})$, also von einem Zustand können wir nun eine ganze *Menge* anderer Zustände erreichen Die von der NTM *akzeptierte Sprache* ist

L(M) = { w \in \Sigma^* \mid q_{0}\textcent w \vdash_{M}^* yq_{accept}z \text{ für irgendwelche } y,z \in \Gamma^* }

es wird eine Startkonfiguration also akzeptiert, falls irgendein "Path" akzeptiert wird (wie bei den NEAs). **Example:** Die Sprache $L_{ungleich} = \{ x\# y \mid x,y \in \Sigma_{bool}^*, x \neq \lambda, x \neq y \}$ können wir mit einer NTM sehr einfach erkennen. - überprüfe ob genau ein $\#$ im Input ist - Beide Bänder auf $\textcent$ - Bewegt beide Köpfe nach rechts - Für jede Position ("entscheidet hier random ob sie weitergeht oder überprüft" -> branching) überprüft eine Branch ob es hier einen Unterschied gibt - Lesekopf auf $\#$, dann Lesekopf nach rechts, Arbeitskopf nach links - bis Arbeitskopf bei $\textcent$ ist -> dann ist Lesekopf genau dort wo Arbeitskopf in $x$ (also Position $x_i$) war, nun im Wort $y$ - Check ob $x_i \neq y_i$ -> wenn ja dann akzeptieren -> Die Maschine checkt quasi für jede Position einmal ob es einen Unterschied gibt (viele ODER) -> wenn es für einen Zutrifft = akzeptiert > [!DEFINITION] 4.4 Berechnungsbaum > > Berechnungsbaum $T_{M, x}$ von $M$ auf $x$ ist ein (potentiell *unendlicher*) gerichteter Baum mit Wurzel. > 1. Jeder Knoten ist mit einer Konfiguration beschriftet > 2. Die Wurzel ist der einzige Knoten mit Eingangsgrad $0$ und ist mit $q_0\textcent x$ beschriftet > 3. Jeder Knoten hat genau so viele Kinder, wie $C$ Nachfolgekonfigurationen hat *Note:* anders als bei NEA's sind Zustände selber depth hier nicht verwandt! Wir können ja jetzt links-rechts frei entscheiden -> bei NEAs wurde immer genau gleich viel vom Input gelesen > [!THEOREM] 4.2 > > Sei $M$ eine NTM. Dann existiert eine TM $A$, so dass > 1. $L(M) = L(A)$ und > 2. falls $M$ keine unendliche Berechnungen auf Wörtern aus $(L(M))^C$ hat, dann hält $A$ immer **Proof:** wir lassen $A$ BFS (nicht DFS weil könnte ja unendlich sein) im Berechnungsbaum machen - Kopiert config auf Arbeitsband 1 - Überprüft ob Band 1 akzeptierende Konfiguration enthäl - dann stop und $q_{accept}$ - Schreibt alle Nachfolgekonfigurationen auf Band 2 - wenn es keine gibt -> $q_{reject}$ - Löscht Band 1 -> schreibt Band 2 auf 1 und löscht Band 2 - Repeat... -> Geht in Wiederholung $i$ alle Zustände in Tiefe $i$ vom Baum durch. ## 4.6 Kodierung von Turingmaschinen Wir wollen ein einfaches Encoding von TMs in binär finden. Wir kodieren $M = (Q, \Sigma, \Gamma, \delta, q_0, q_{accept}, q_{reject})$ eine TM wobei $Q = \{q_{0}, q_{1}, \dots, q_{m}, q_{accept}, q_{reject}\}$ und $\Gamma = \{A_1, A_2, \dots, A_r\}$: - $\text{Code}(q_i) = 10^{i+1}1$ für $i = 0, 1, \dots, m$ - $\text{Code}(q_{accept}) = 10^{m+2}1$ - $\text{Code}(q_{reject}) = 10^{m+3}1$ - $\text{Code}(A_{j}) = 110^{j}11$ für $j = 1, \dots, r$ - $\text{Code}(N) = 1110111$ - $\text{Code}(R) = 11100111$ - $\text{Code}(L) = 111000111$ Wir nutzen diese Kodierung zur Darstellung einzelner Transitionen

\begin{align}
\text{Code}(\delta(p, A_{l})) &= (q, A_{m}, \alpha) \
&= # \text{Code}(p)\text{Code}(A_{l})\text{Code}(A_{m})\text{Code}(\alpha) #
\end{align}

Für die gesamte Turingmaschine $M$ gilt:

\text{Code}(M) = #0^{m+3}#0^r##\text{Code}(\text{Transition}{1})#\text{Code}(\text{Transition}{2})#\dots

-> am Anfang quasi die "Größen" von allem Um daraus eine Kodierung über $\Sigma_{bool}$ zu erhalten, nutzen wir den Homomorphismums $h$: - $h(\#) = 01$, $h(0) = 00$, $h(1) = 11$ > [!DEFINITION] Code > > Für jede Turingmaschine $M$ wird $\mathbf{Kod}(M) = h(\text{Code}(M))$ gennant. *Note:* $\mathbf{KodTM} = \{ \text{Kod}(M) \mid M \text{ ist eine TM} \}$ bezeichnet die Menge der Kodierungen aller Turingmaschinen -> $\text{Kod}$ ist injektiv, daher bestimmt es eindeutig eine Turingmaschine Wir können einen Verifier schreiben, welcher eindeutig entscheidet ob $x$ eine kodierte TM ist. > [!LEMMA] > > Es gilt $\mathbf{KodTM} \in \mathcal{L}_{R}$ This means we can check the "TM property" in finite time, with no infinite calculations! > [!DEFINITION] 4.6 Ordnung > > Sei $x \in \Sigma_{bool}^*$. Für jedes $i \in \N - \{0\}$ sagen wir, dass $x$ die *Kodierung der $i$-ten TM* ist, falls > 1. $x = \text{Kod}(M)$ für eine TM $M$ und > 2. die Menge $\{ y \in \Sigma_{bool}^* \mid y \text{ ist vor } y \text{ in kanonischer Ordnung} \}$ enthält genau $i - 1$ Wörter, die Kodierungen von Turingmaschinen sind Falls $x$ die Kodierung der $i$-ten M ist, dann ist $M$ die $i$-te TM $M_i$ (wo $i$ die "Ordnung" ist). > [!LEMMA] 4.3 > > Es gibt ein Programm, dass für $i$ die $i$-te Turingmaschine rekursiv berechnet. *Note:* dass heißt auch, dass das Problem "Entscheide ob $\Sigma^*$ eine TM kodiert, i.e. ob es $\mathbf{Kod}(M)$". Geht einfache alle durch, bis zur $i$-ten. ## Extra ### TM Simulating Another We literally "interpret" the coding of the simulated TM, like a python interpreter. We have the current "state" and pattern match it against the transitions of the encoded TM. Then we apply that transition, and iterate. ![[tm-sim-1.png]]![[tm-sim-2.png]]![[tm-sim-3.png]]