Grundlagen der Theoretischen Informatik: Übung 10

Grundlagen der Theoretischen Informatik: Übung
10
Joachim Selke
Fachgebiet Theoretische Informatik
Universität Hannover
20. Januar 2005
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Turing-Maschinen als „Rechenmaschinen“
gegeben sei eine Funktion f : Nk0 → N0 , also eine Funktion mit
k natürlichen Zahlen als Eingabe und einer natürlichen Zahl
als Ausgabe
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Turing-Maschinen als „Rechenmaschinen“
gegeben sei eine Funktion f : Nk0 → N0 , also eine Funktion mit
k natürlichen Zahlen als Eingabe und einer natürlichen Zahl
als Ausgabe
derartige Funktionen sind mit speziellen (deterministischen)
Turing-Maschinen berechenbar
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Turing-Maschinen als „Rechenmaschinen“
gegeben sei eine Funktion f : Nk0 → N0 , also eine Funktion mit
k natürlichen Zahlen als Eingabe und einer natürlichen Zahl
als Ausgabe
derartige Funktionen sind mit speziellen (deterministischen)
Turing-Maschinen berechenbar
zu Beginn der Rechnung stehen die Eingabezahlen binär
kodiert (bei mehreren Eingabezahlen durch ein spezielles
Trennzeichen getrennt) auf dem Arbeitsband, nach der
Rechnung steht dort die Ausgabe
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Turing-Maschinen als „Rechenmaschinen“
gegeben sei eine Funktion f : Nk0 → N0 , also eine Funktion mit
k natürlichen Zahlen als Eingabe und einer natürlichen Zahl
als Ausgabe
derartige Funktionen sind mit speziellen (deterministischen)
Turing-Maschinen berechenbar
zu Beginn der Rechnung stehen die Eingabezahlen binär
kodiert (bei mehreren Eingabezahlen durch ein spezielles
Trennzeichen getrennt) auf dem Arbeitsband, nach der
Rechnung steht dort die Ausgabe
f muß nicht für alle möglichen Eingaben definiert sein – bei
allen undefinierten Eingabewerten gerät die Turing-Maschine
in eine Endlosschleife
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Turing-Maschinen als „Rechenmaschinen“
gegeben sei eine Funktion f : Nk0 → N0 , also eine Funktion mit
k natürlichen Zahlen als Eingabe und einer natürlichen Zahl
als Ausgabe
derartige Funktionen sind mit speziellen (deterministischen)
Turing-Maschinen berechenbar
zu Beginn der Rechnung stehen die Eingabezahlen binär
kodiert (bei mehreren Eingabezahlen durch ein spezielles
Trennzeichen getrennt) auf dem Arbeitsband, nach der
Rechnung steht dort die Ausgabe
f muß nicht für alle möglichen Eingaben definiert sein – bei
allen undefinierten Eingabewerten gerät die Turing-Maschine
in eine Endlosschleife
Anmerkung: Mit Turing-Maschinen lassen sich natürlich auch
Funktionen g : Σ? → Γ? berechnen, wobei Σ und Γ Alphabete
sind
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Beispiel: Division
f (a, b) :=
a
b
Berechnung von f (12, 3):
Arbeitsband: · · · 1100#11 · · ·
|
Berechnung
↓
Arbeitsband:
Joachim Selke
· · · 100 · · ·
Grundlagen der Theoretischen Informatik: Übung 10
Beispiel: Division
f (a, b) :=
a
b
Berechnung von f (12, 0):
Arbeitsband: · · · 1100#0 · · ·
|
Berechnung
↓
Endlosschleife
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Programmiersprachen: LOOP, WHILE, GOTO
möchte man das Berechnungsverfahren für eine bestimmte
Funktion f exakt beschreiben, so kann man natürlich eine
konkrete Turing-Maschinen angeben, die f berechnet
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Programmiersprachen: LOOP, WHILE, GOTO
möchte man das Berechnungsverfahren für eine bestimmte
Funktion f exakt beschreiben, so kann man natürlich eine
konkrete Turing-Maschinen angeben, die f berechnet
dies ist aber in der Regel sehr umständlich und nur schwer
lesbar (viele Zustände und Zustandsübergänge)
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Programmiersprachen: LOOP, WHILE, GOTO
möchte man das Berechnungsverfahren für eine bestimmte
Funktion f exakt beschreiben, so kann man natürlich eine
konkrete Turing-Maschinen angeben, die f berechnet
dies ist aber in der Regel sehr umständlich und nur schwer
lesbar (viele Zustände und Zustandsübergänge)
eine alternative Möglichkeit sind Programmiersprachen
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Programmiersprachen: LOOP, WHILE, GOTO
möchte man das Berechnungsverfahren für eine bestimmte
Funktion f exakt beschreiben, so kann man natürlich eine
konkrete Turing-Maschinen angeben, die f berechnet
dies ist aber in der Regel sehr umständlich und nur schwer
lesbar (viele Zustände und Zustandsübergänge)
eine alternative Möglichkeit sind Programmiersprachen
diese sind darauf ausgelegt, daß Menschen damit leicht
Programme schreiben können – die Verständlichkeit der
Anweisungen steht im Vordergrund
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Programmiersprachen: LOOP, WHILE, GOTO
möchte man das Berechnungsverfahren für eine bestimmte
Funktion f exakt beschreiben, so kann man natürlich eine
konkrete Turing-Maschinen angeben, die f berechnet
dies ist aber in der Regel sehr umständlich und nur schwer
lesbar (viele Zustände und Zustandsübergänge)
eine alternative Möglichkeit sind Programmiersprachen
diese sind darauf ausgelegt, daß Menschen damit leicht
Programme schreiben können – die Verständlichkeit der
Anweisungen steht im Vordergrund
wir betrachten im folgenden drei sehr einfache
Programmiersprachen zur Berechung von Funktionen ähnlich
wie Turing-Maschinen: LOOP, WHILE und GOTO
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
es gibt in LOOP-Programmen unendlich viele Variablen: x0 ,
x1 , x2 , . . .
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
es gibt in LOOP-Programmen unendlich viele Variablen: x0 ,
x1 , x2 , . . .
jede dieser Variablen kann einen Wert aus N0 speichern
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
es gibt in LOOP-Programmen unendlich viele Variablen: x0 ,
x1 , x2 , . . .
jede dieser Variablen kann einen Wert aus N0 speichern
die k Eingabewerte sind zu Beginn jedes LOOP-Programms in
den Variablen x1 , x2 , . . ., xk gespeichert
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
es gibt in LOOP-Programmen unendlich viele Variablen: x0 ,
x1 , x2 , . . .
jede dieser Variablen kann einen Wert aus N0 speichern
die k Eingabewerte sind zu Beginn jedes LOOP-Programms in
den Variablen x1 , x2 , . . ., xk gespeichert
alle anderen Variablen haben zu Beginn den Wert 0
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
wie bei Turing-Maschinen soll eine Funktion f : Nk0 → N0
berechnet werden
es gibt in LOOP-Programmen unendlich viele Variablen: x0 ,
x1 , x2 , . . .
jede dieser Variablen kann einen Wert aus N0 speichern
die k Eingabewerte sind zu Beginn jedes LOOP-Programms in
den Variablen x1 , x2 , . . ., xk gespeichert
alle anderen Variablen haben zu Beginn den Wert 0
am Ende des Programms muß der Ausgabewert in der
Variablen x0 gespeichert sein – dafür ist das LOOP-Programm
zuständig
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
Beginn:
x0 x1 x2 · · · xk−1 xk
0
Eingabe
xk+1 xk+2 · · ·
0
0
···
|
Berechnung durch das LOOP-Programm
↓
Ende:
x0
x1 x 2 · · ·
Ausgabe ? ?
?
Joachim Selke
xk−1 xk
?
?
xk+1 xk+2 · · ·
?
?
···
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
mit dem Befehl „x2 := x6 + 75“ wird beispielsweise in der
Variablen x2 der um 75 erhöhte Wert der Variablen x6
gespeichert – enthält x6 etwa den Wert 25, so bekommt x2
den Wert 100 zugewiesen
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
mit dem Befehl „x2 := x6 + 75“ wird beispielsweise in der
Variablen x2 der um 75 erhöhte Wert der Variablen x6
gespeichert – enthält x6 etwa den Wert 25, so bekommt x2
den Wert 100 zugewiesen
genauso ist auch „x167 := x1 − 12“ möglich, hier wird dann
subtrahiert – negative Werte werden dabei zu 0
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
mit dem Befehl „x2 := x6 + 75“ wird beispielsweise in der
Variablen x2 der um 75 erhöhte Wert der Variablen x6
gespeichert – enthält x6 etwa den Wert 25, so bekommt x2
den Wert 100 zugewiesen
genauso ist auch „x167 := x1 − 12“ möglich, hier wird dann
subtrahiert – negative Werte werden dabei zu 0
derartige Befehle lassen sich natürlich für beliebige Variablen
und Zahlen (aus N0 ) formulieren
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
mit dem Befehl „x2 := x6 + 75“ wird beispielsweise in der
Variablen x2 der um 75 erhöhte Wert der Variablen x6
gespeichert – enthält x6 etwa den Wert 25, so bekommt x2
den Wert 100 zugewiesen
genauso ist auch „x167 := x1 − 12“ möglich, hier wird dann
subtrahiert – negative Werte werden dabei zu 0
derartige Befehle lassen sich natürlich für beliebige Variablen
und Zahlen (aus N0 ) formulieren
LOOP-Programme entstehen durch die Ausführung mehrerer
Befehle hintereinander
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
während der Berechnung kann der Inhalt der Variablen
verändert werden
mit dem Befehl „x2 := x6 + 75“ wird beispielsweise in der
Variablen x2 der um 75 erhöhte Wert der Variablen x6
gespeichert – enthält x6 etwa den Wert 25, so bekommt x2
den Wert 100 zugewiesen
genauso ist auch „x167 := x1 − 12“ möglich, hier wird dann
subtrahiert – negative Werte werden dabei zu 0
derartige Befehle lassen sich natürlich für beliebige Variablen
und Zahlen (aus N0 ) formulieren
LOOP-Programme entstehen durch die Ausführung mehrerer
Befehle hintereinander
dies ist mit dem Zeichen „;“ möglich – Beispiel:
„x2 := x6 + 75; x167 := x1 − 12“
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
seinen Namen verdankt LOOP einem Schleifen-Befehl
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
seinen Namen verdankt LOOP einem Schleifen-Befehl
Beispiel: „LOOP x7 DO . . . END“ (. . . ist dabei eine beliebige
Folge von LOOP-Befehlen)
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
seinen Namen verdankt LOOP einem Schleifen-Befehl
Beispiel: „LOOP x7 DO . . . END“ (. . . ist dabei eine beliebige
Folge von LOOP-Befehlen)
hat x7 vor der Ausführung dieses Befehls beispielsweise den
Wert 11, so werden die durch . . . angedeuteten Befehle genau
11-mal wiederholt ausgeführt – egal, ob x7 dadurch seinen
Wert ändert!
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache LOOP
seinen Namen verdankt LOOP einem Schleifen-Befehl
Beispiel: „LOOP x7 DO . . . END“ (. . . ist dabei eine beliebige
Folge von LOOP-Befehlen)
hat x7 vor der Ausführung dieses Befehls beispielsweise den
Wert 11, so werden die durch . . . angedeuteten Befehle genau
11-mal wiederholt ausgeführt – egal, ob x7 dadurch seinen
Wert ändert!
durch die Ausführung des LOOP-Befehls ändert x7 seinen
Wert nicht – dies ist nur durch die wiederholten Befehle
möglich
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes LOOP-Programm?
Eingabe: x1 , x2
LOOP x1 DO
x1 := x1 + 4
END;
LOOP x2 DO
x1 := x1 + 1
END;
x0 := x1 + 0
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes LOOP-Programm?
Eingabe: x1 , x2
LOOP x1 DO
x1 := x1 + 4
END;
LOOP x2 DO
x1 := x1 + 1
END;
x0 := x1 + 0
Antwort: 5 · x1 + x2
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Aufgabe
Eingabe: x1 , x2 , x3 , x4
Ausgabe: 100 · x1 + x2 + x3 + x4
Schreiben Sie ein passendes LOOP-Programm!
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Spezielle LOOP-Programme
Zur Vereinfachung definieren wir uns Kurzschreibweisen für
bestimmte LOOP-Programme:
xi := xj
xi := c
(c ist eine beliebige Zahl)
(xp ist eine beliebige unbenutzte Variable)
IF xi = 0 THEN P END
(P ist ein beliebiges LOOP-Programm)
(xp ist eine beliebige unbenutzte Variable)
Joachim Selke
xi := xj + 0
xi := xp + c
xp := 1;
LOOP xi DO
xp := 0
END;
LOOP xp DO
P
END
Grundlagen der Theoretischen Informatik: Übung 10
Übungsblatt 10, Aufgabe 2
Wie formuliert man
IF xi = 0 THEN P ELSE Q END
in LOOP?
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Weitere spezielle LOOP-Programme
xi := xj + xk
xi := xj · xk
···
Joachim Selke
xi := xj ;
LOOP xk DO
xi := xi + 1
END
xi := 0;
LOOP xk DO
xi := xi + xj
END
(siehe Vorlesung)
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache WHILE
wir erweitern LOOP um einen weiteren Befehl
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache WHILE
wir erweitern LOOP um einen weiteren Befehl
„WHILE xi 6= 0 DO P END“ führt das Programm P solange
wiederholt aus, bis xi den Wert 0 hat
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache WHILE
wir erweitern LOOP um einen weiteren Befehl
„WHILE xi 6= 0 DO P END“ führt das Programm P solange
wiederholt aus, bis xi den Wert 0 hat
die Überprüfung, ob xi = 0 gilt, findet vor jeder Wiederholung
statt
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache WHILE
wir erweitern LOOP um einen weiteren Befehl
„WHILE xi 6= 0 DO P END“ führt das Programm P solange
wiederholt aus, bis xi den Wert 0 hat
die Überprüfung, ob xi = 0 gilt, findet vor jeder Wiederholung
statt
nun lassen sich Endlosschleifen erzeugen – das ist in der
Programmiersprache LOOP nicht möglich!
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes WHILE-Programm?
Eingabe: x1 , x2 , x3
x0 := 1;
WHILE x1 6= 0 DO
x0 := x0 · x2 ;
x1 := x1 − 1
END;
LOOP x3 DO
x0 := x0 + 2
END
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes WHILE-Programm?
Eingabe: x1 , x2 , x3
x0 := 1;
WHILE x1 6= 0 DO
x0 := x0 · x2 ;
x1 := x1 − 1
END;
LOOP x3 DO
x0 := x0 + 2
END
Antwort: x2x1 + 2 · x3
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
die Befehle der Programmiersprache GOTO sehen wir gleich,
ein wichtiger Unterschied zu LOOP und WHILE ist jedoch,
daß jeder Befehl in einem GOTO-Programm mit einer
Markierung versehen ist – der erste Befehl im Programmtext
hat die Marke M1 , der zweite M2 und so weiter ...
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
die Befehle der Programmiersprache GOTO sehen wir gleich,
ein wichtiger Unterschied zu LOOP und WHILE ist jedoch,
daß jeder Befehl in einem GOTO-Programm mit einer
Markierung versehen ist – der erste Befehl im Programmtext
hat die Marke M1 , der zweite M2 und so weiter ...
die Befehle „xi := xj + c“ und „xi := xj − c“ sind wie in
LOOP und WHILE definiert
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
die Befehle der Programmiersprache GOTO sehen wir gleich,
ein wichtiger Unterschied zu LOOP und WHILE ist jedoch,
daß jeder Befehl in einem GOTO-Programm mit einer
Markierung versehen ist – der erste Befehl im Programmtext
hat die Marke M1 , der zweite M2 und so weiter ...
die Befehle „xi := xj + c“ und „xi := xj − c“ sind wie in
LOOP und WHILE definiert
der Befehl „GOTO Mj “ sorgt dafür, daß das Programm bei
dem Befehl mit der Markierung Mj fortgesetzt wird
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
die Befehle der Programmiersprache GOTO sehen wir gleich,
ein wichtiger Unterschied zu LOOP und WHILE ist jedoch,
daß jeder Befehl in einem GOTO-Programm mit einer
Markierung versehen ist – der erste Befehl im Programmtext
hat die Marke M1 , der zweite M2 und so weiter ...
die Befehle „xi := xj + c“ und „xi := xj − c“ sind wie in
LOOP und WHILE definiert
der Befehl „GOTO Mj “ sorgt dafür, daß das Programm bei
dem Befehl mit der Markierung Mj fortgesetzt wird
der Befehl „IF xi = c THEN GOTO Mj “ überprüft, ob die
Variable xi den Wert c hat – ist dies der Fall, so wird das
Programm bei dem Befehl mit der Markierung Mj fortgesetzt;
ansonsten passiert nichts
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Programmiersprache GOTO
Variablen und Schreibweisen sind in GOTO wie in LOOP und
WHILE, nur die Befehle unterscheiden sich
die Befehle der Programmiersprache GOTO sehen wir gleich,
ein wichtiger Unterschied zu LOOP und WHILE ist jedoch,
daß jeder Befehl in einem GOTO-Programm mit einer
Markierung versehen ist – der erste Befehl im Programmtext
hat die Marke M1 , der zweite M2 und so weiter ...
die Befehle „xi := xj + c“ und „xi := xj − c“ sind wie in
LOOP und WHILE definiert
der Befehl „GOTO Mj “ sorgt dafür, daß das Programm bei
dem Befehl mit der Markierung Mj fortgesetzt wird
der Befehl „IF xi = c THEN GOTO Mj “ überprüft, ob die
Variable xi den Wert c hat – ist dies der Fall, so wird das
Programm bei dem Befehl mit der Markierung Mj fortgesetzt;
ansonsten passiert nichts
der Befehl „HALT“ beendet das Programm
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes GOTO-Programm?
Eingabe: x1 , x2
M1 :
IF x1 = 0 THEN GOTO M5 ;
M2 :
x2 := x2 + 1;
M3 :
x1 := x1 − x2 ;
M4 :
GOTO M1 ;
M5 :
x0 := x2 ;
M6 :
HALT
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Was berechnet folgendes GOTO-Programm?
Eingabe: x1 , x2
M1 :
IF x1 = 0 THEN GOTO M5 ;
M2 :
x2 := x2 + 1;
M3 :
x1 := x1 − x2 ;
M4 :
GOTO M1 ;
M5 :
x0 := x2 ;
M6 :
HALT
Antwort: Sind a und b die Eingabewerte
P und k ∈ N0 die kleinste
Zahl, die die Bedingung a − k · b − ki=1 i ≤ 0 erfüllt, so ist die
Ausgabe b + k.
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Äquivalenzbetrachtungen
in der Vorlesung wurde gezeigt, daß WHILE-Programme,
GOTO-Programme und Turing-Maschinen äquivalent sind
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Äquivalenzbetrachtungen
in der Vorlesung wurde gezeigt, daß WHILE-Programme,
GOTO-Programme und Turing-Maschinen äquivalent sind
kann man also in einem dieser drei Modelle ein
Berechnungsverfahren für eine bestimmte Funktion angeben,
so ist dies auch in den anderen beiden möglich
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Äquivalenzbetrachtungen
in der Vorlesung wurde gezeigt, daß WHILE-Programme,
GOTO-Programme und Turing-Maschinen äquivalent sind
kann man also in einem dieser drei Modelle ein
Berechnungsverfahren für eine bestimmte Funktion angeben,
so ist dies auch in den anderen beiden möglich
LOOP-Programme hingegen „können“ weniger als diese drei
Berechnungsmodelle
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Äquivalenzbetrachtungen
in der Vorlesung wurde gezeigt, daß WHILE-Programme,
GOTO-Programme und Turing-Maschinen äquivalent sind
kann man also in einem dieser drei Modelle ein
Berechnungsverfahren für eine bestimmte Funktion angeben,
so ist dies auch in den anderen beiden möglich
LOOP-Programme hingegen „können“ weniger als diese drei
Berechnungsmodelle
zum einen müssen LOOP-Programme immer anhalten, zum
anderen gibt es totale Funktionen, die mit
LOOP-Programmen nicht berechenbar ist
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Äquivalenzbetrachtungen
in der Vorlesung wurde gezeigt, daß WHILE-Programme,
GOTO-Programme und Turing-Maschinen äquivalent sind
kann man also in einem dieser drei Modelle ein
Berechnungsverfahren für eine bestimmte Funktion angeben,
so ist dies auch in den anderen beiden möglich
LOOP-Programme hingegen „können“ weniger als diese drei
Berechnungsmodelle
zum einen müssen LOOP-Programme immer anhalten, zum
anderen gibt es totale Funktionen, die mit
LOOP-Programmen nicht berechenbar ist
ein Beispiel dafür ist die sogenannte Ackermann-Funktion:


falls x = 0,
y + 1
f (x, y ) := f (x − 1, 1)
falls x > 0 und y = 0,


f x − 1, f (x, y − 1) sonst.
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Churchsche These
lange Zeit hat man versucht, sich Berechnungsmodelle
auszudenken, die „mehr können“ als Turing-Maschinen oder
WHILE-Programme
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Churchsche These
lange Zeit hat man versucht, sich Berechnungsmodelle
auszudenken, die „mehr können“ als Turing-Maschinen oder
WHILE-Programme
erstaunlicherweise hat man bisher jedoch kein „mächtigeres“
Modell als die obigen gefunden
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Churchsche These
lange Zeit hat man versucht, sich Berechnungsmodelle
auszudenken, die „mehr können“ als Turing-Maschinen oder
WHILE-Programme
erstaunlicherweise hat man bisher jedoch kein „mächtigeres“
Modell als die obigen gefunden
Alonzo Church (1903–1995), ein amerikanischer
Mathematiker hat daher bereits 1936 die These formuliert,
daß die Menge der „im intuitiven Sinne“ berechenbaren
Funktionen der Menge der von Turing-Maschinen
berechenbaren Funktionen entspricht
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Churchsche These
lange Zeit hat man versucht, sich Berechnungsmodelle
auszudenken, die „mehr können“ als Turing-Maschinen oder
WHILE-Programme
erstaunlicherweise hat man bisher jedoch kein „mächtigeres“
Modell als die obigen gefunden
Alonzo Church (1903–1995), ein amerikanischer
Mathematiker hat daher bereits 1936 die These formuliert,
daß die Menge der „im intuitiven Sinne“ berechenbaren
Funktionen der Menge der von Turing-Maschinen
berechenbaren Funktionen entspricht
diese These läßt sich nicht beweisen, man ist von ihrer
Gültigkeit jedoch überzeugt
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10
Die Churchsche These
lange Zeit hat man versucht, sich Berechnungsmodelle
auszudenken, die „mehr können“ als Turing-Maschinen oder
WHILE-Programme
erstaunlicherweise hat man bisher jedoch kein „mächtigeres“
Modell als die obigen gefunden
Alonzo Church (1903–1995), ein amerikanischer
Mathematiker hat daher bereits 1936 die These formuliert,
daß die Menge der „im intuitiven Sinne“ berechenbaren
Funktionen der Menge der von Turing-Maschinen
berechenbaren Funktionen entspricht
diese These läßt sich nicht beweisen, man ist von ihrer
Gültigkeit jedoch überzeugt
Ausblick: es gibt Funktionen, die man auch mit
Turing-Maschinen nicht berechnen kann!
Joachim Selke
Grundlagen der Theoretischen Informatik: Übung 10