Theoretische Informatik SS 03 Übung 5

Transkript

1 Theoretische Informatik SS 03 Übung 5 Aufgabe 1 Im Buch von Schöning ist auf S beschrieben, wie eine Turing-Maschine durch ein GOTO-Programm simuliert werden kann. Zeigen Sie, wie dabei die Anweisungen δ(z i, a j ) = (z i, a j, R) und δ(z i, a j ) = (z i, a j, N) mit DIV und MOD - Operationen simuliert werden können. Wie dem Beweis bei Schöning zu entnehmen ist, wird für eine Turingmaschine mit Zustandsmenge und Bandaphabet Z = {z 1,..., z k } Γ = {a 1,..., a m } eine Turingmaschinenkonfiguration in der Form a i1... a ip z l a j1... a jq durch drei Programmvariablen x, y, z repräsentiert, die entsprechende Werte x = (i 1... i p ) b y = (j q... j 1 ) b z = l annehmen. Es handelt sich dabei um Zahlen in b-närer Darstellung, wobei b > Γ : x = p i µ b p µ µ=1 x repräsentiert die Bandinschriften links des Schreib-/Lesekopfes, y die rechts des Schreib- /Lesekopfes, wobei hier die Ziffern in umgekehrter Reihenfolge stehen. δ(z i, a j ) = (z i, a j, R): Es muss ein Zustandswechsel in den Zustand i erfolgen, an x j angehängt und von y die erste Stelle entfernt werden: z = i x = b x + j y = y DIV b 1

2 δ(z i, a j ) = (z i, a j, N): Es muss ein Zustandswechsel in den Zustand i erfolgen und von y die erste Stelle durch j ersetzt werden: Aufgabe z = i y = y DIV b y = b y + j Erinnert sei an die Definition der Ackermann-Funktion a a(0, y) = y + 1 Weisen Sie folgende Eigenschaften nach: a) a(1, y) = y + a(x, 0) = a(x 1, 1), x > 0 a(x, y) = a(x 1, a(x, y 1)), x, y > 0 Beweis: Wir führen Induktion über y: Induktionsanfang: Induktionsvoraussetzung: Induktionsbehauptung: Induktionsschluss: a(1, 0)! = y + = 0 + = a(1, 0) = a(0, 1) = a(1, y) = y + a(1, y + 1) = (y + 1) + a(1, y + 1) = a(0, a(1, y)) IV = a(0, y + ) = (y + 1) +

3 b) a(, y) = y + 3 Beweis: Induktionsanfang: a(, 0)! = y + 3 = = 3 a(, 0) = a(1, 1) a) = 1 + = 3 Induktionsvoraussetzung: a(, y) = y + 3 Induktionsbehauptung: a(, y + 1) = (y + 1) + 3 Induktionsschluss: a(, y + 1) = a(1, a(, y)) IV = a(1, y + 3) a) = y = (y + 1) + 3 c) a(3, y) = y+3 3 Beweis: Induktionsanfang: a(3, 0)! = y+3 3 = = 8 3 = 5 a(3, 0) = a(, 1) b) = = 5 3

4 Induktionsvoraussetzung: a(3, y) = y+3 3 Induktionsbehauptung: a(3, y + 1) = (y+1)+3 3 Induktionsschluss: a(3, y + 1) = a(, a(3, y)) IV = a(, y+3 3) b) = ( y+3 3) + 3 = (y+1)+3 3 d) Wie lautet die Formel für a(4, y)?.. a(4, y) = }. {{} 3 Dieser Sachverhalt ist auch sehr gut an der Wertetafel der Ackermannfunktion a (Aufgabe 3) zu erkennen. Beweis: Induktionsanfang: a(4, 0)!.. = }. {{} 3 = 3 = 16 3 = 13 a(4, 0) = a(3, 1) c) = = 13 4

5 Induktionsvoraussetzung:.. a(4, y) = }. {{} 3 Induktionsbehauptung: a(4, y + 1) =.. }. {{} 3 ((y+1)+3) oft Induktionsschluss: a(4, y + 1) = a(3, a(4, y)) IV = a(3,... }{{} c) = =... 3 }{{}... }{{} 3) =.. }. {{} 3 ((y+1)+3) oft Aufgabe 3 Welche Funktionen können mit WHILE-Programmen aber nicht mit LOOP-Programmen berechnet werden: a) totale oder partielle Funktionen? Partielle Funktionen sind nicht LOOP-berechenbar. Da LOOP-Programme nach endlicher Zeit stoppen, liefern sie immer ein Ergebnis, was falsch sein muss, wenn die zu berechnende Funktion an eben dieser Stelle nicht definiert ist. b) sehr schnell oder sehr langsam wachsende Funktionen? 5

6 Sehr schnell wachsende Funktionen sind u.u. nicht LOOP-berechenbar. Die Ackermann- Funktion ist ein Beispiel für eine solche Funktion. Jedem LOOP-Programm P kann eine Funktion f P : zugeordnet werden. Für die in P vorkommenden Variablen x 0, x 1,..., x k bezeichnet in der folgenden Definition n i den Startwert der Variablen x i und n i den zugehörigen Endwert nach Ablauf des Programms P : k f P (n) = max{ n i i=0 k n i n} i=1 f P (n) gibt also die größtmögliche Summe aller Variablenendwerte an, wenn P mit Anfangswerten gestartet wird, die in der Summe n nicht übersteigen. Man kann zeigen, dass für jedes LOOP-Programm P eine Konstante k existiert, so dass für alle n gilt: f P (n) < a(k, n) (vgl. Schöning S. 118). Damit folgt, dass die ACKERMANNFUNKTION a nicht LOOP-berechenbar ist. Beweis: Ann. a ist LOOP-berechenbar. = g(n) = a(n, n) ist LOOP-berechenbar. Sei P ein LOOP-Programm für g. = f P (n) < a(k, n) k sei eine Konstante, so dass f P (n) < a(k, n) gilt und wir wählen n := k. = g(k) f P (k) < a(k, k) = g(k), Widerspruch, a ist nicht LOOP-berechenbar. In Schöning auf S. 113 ist nachzulesen, dass die Klasse der LOOP-berechenbaren Funktionen genau mit der Klasse der primitiv rekursiven Funktionen übereinstimmt. Daher kann man obigen Sachverhalt auch beweisen, indem man zeigt, dass die ACKERMANNFUNK- TION a schneller wächst als alle primitiv rekursiven Funktionen. Aufgabe 4 a) Bekanntlich kann die Funktion c(x, y) = ( x+y+1) + x benutzt werden, um Paare von natürlichen Zahlen in eine einzelne Zahl zu codieren. Die Umkehrfunktionen e und f von c sind dann definiert durch e(c(x, y)) = x, f(c(x, y)) = y, c(e(n)), f(n)) = n. Geben Sie jeweils e(n) und f(n) an für n = 17, 5 und 31. n = 17: (x + y + 1)(x + y) + x = = e(c(x, y)) = e(17) =x = = f(c(x, y)) = f(17) =y = 3 ( ) ( + 3) + = = 17 6

7 n = 5: (x + y + 1)(x + y) + x = = e(c(x, y)) = e(5) =x = 4 = f(c(x, y)) = f(5) =y = ( ) (4 + ) + 4 = = 5 n = 31: (x + y + 1)(x + y) + = = e(c(x, y)) = e(31) =x = 3 = f(c(x, y)) = f(31) =y = 4 ( ) (3 + 4) + 3 = = 31 Allgemein gilt: e(n) = max{x n y n : c(x, y) = n} f(n) = max{y n x n : c(x, y) = n} b) Überzeugen Sie sich, dass das WHILE-Programm auf S im Buch von Schöning die Ackermann-Funktion für alle Eingaben (x, y) berechnet. INPUT(x, y); INIT(stack); PUSH(x, stack); PUSH(y, stack); WHILE size(stack) 1 DO y :=POP(stack); x :=POP(stack); IF x = 0 THEN PUSH(y + 1, stack); ELSIF y = 0 THEN PUSH(x 1, stack);push(1, stack); ELSE PUSH(x 1, stack);push(x, stack);push(y 1, stack); END{IF}; END{WHILE}; result :=POP(stack); OUTPUT(result); In den ersten vier Zeilen des Programms wird die Eingabeinstanz auf den Stack gelegt (zunächst x, dann y). Während der Schleifenabarbeitung gilt, dass immer die in der Rekursion zuletzt aufgerufene Instanz oben auf dem Stack liegt, so dass diese weiter bearbeitet wird - dies ist anfänglich die zu lösende Ursprungsinstanz. 7

8 Eine solche Verarbeitung erfolgt derart, dass entweder rekursiv (nach Definition von a) eine neue Instanz erzeugt und auf dem Stack abgelegt wird, oder bei x = 0 gerade y + 1. Dies entspricht ebenfalls genau der Definition der Ackermannfunktion a. Die Schleife kann erst stoppen, wenn der Stack nur noch ein Element enthält. Dabei muss es sich um das Resultat der ursprünglichen Instanz von a handeln. 8