2. Imperative Programmierung und Berechenbarkeit ...

2. Imperative Programmierung und
Berechenbarkeit
- Registermaschinen -
2.1 Definition
2.2 Loop-Programme
2.3 While Programme
2.4 While Programme und
rekursive Funktionen
Im Wesentlichen:
Tafel!

Maschinenmodell
Registermaschine
- Register x1,…xn -- endlich viele Speicherregister
- Ein Befehlsregister b
Operationen werden durch die "Programmiersprache"
festgelegt.
Befehlssatz einer LOOP-RM:
xi = xj + c
xi = xj – c
LOOP xi {}
Konstanten c : natürliche Zahlen
Semantik:
- Addition wie üblich
- Subtraktion:
xi erhält den Wert
xj – c, wenn xj – c ≥ 0
sonst 0
hs / fub - alp2-2 2

Beispiel: einfache Programme
Multiplikation:
x i = x j *x k
LOOP x i {x i = x i -1}
LOOP x j {x i = x i +x k }
Und wie definiert man x i = x j + x k ??
Welche Funktionen lassen sich mit LOOP-Programmen
berechnen?
hs / fub - alp2-2 3

LOOP-Programme
Satz: Mit LOOP-Programmen kann man genau die
primitiv rekursiven Funktionen f k :: N k → N
berechnen.
… aber das sind bekanntlich nicht alle berechenbaren
Funktionen.
Loop Programme terminieren immer!
Warum?
hs / fub - alp2-2 4

Primitiv rekursive Grundfunktionen (I)
1. Konstante 0
Wiederholung
aus ALP1
2. Nachfolgerfunktion succ
succ (0), succ(succ(0)), ...
succ(x) = x+1 (*)
3. Projektionen
proj m,i : N m -> N, m ∈ N
proj m,i (x 1 ,…,x i ,…,x m ) = x i, i£m
(*) Funktionen in math. Schreibweise: f (x,y,z)
hs / fub - alp2-2 5

II. Einsetzungsschema (Komposition)
g : N r -> N,
h i : N k -> N , i=1..r, primitiv rekursiv, dann auch
Wiederholung
aus ALP1
f(x 1 ,…x k ) = g(h 1 (x 1 ,..,x k ),…,h r (x 1 ,..,x k ))
Beachte: typisches nichtrekursives Definitionsschema, z.B
quad (x ) = x*x = (*) (proj 1,1 (x), proj 1,1 (x))
Aber bisher nicht bewiesen, dass '*' primitiv rekursiv definierbar.
hs / fub - alp2-2 6

III Rekursionsschema
g : N k -> N, k ≥ 0
h i : N k+2 -> N primitiv rekursiv, dann auch
f : N k+1 -> N
f(0,x 1 ,…x k ) = g (x 1 ,..,x k )
f(m+1,x 1 ,…x k ) = h ( f(m,x 1 ,..,x k ), m, x 1 ,..,x k )
Wiederholung
aus ALP1
Bsp.: fak 0 = 1
fak (m+1) = h (fak (m), m)
mit h(x,y) = x * (y+1)
Schreibweise: oft x statt x 1 ,...,x k
Bemerkung: In der Literatur oft f(m+1,x 1 ,…x k ) = h (x 1 ,..,x k ,m,f(m,x 1
,..,x k )).
Es gibt viele äquivalente Rekursionsschemata.
hs / fub - alp2-2 7

Beschränkter μ-Operator
Gesucht Operator, der kleinstes i < m findet,
das eine Bedingung wahr macht.
μ i < m (g(i,x)) = ∧ ∀j < i 0
i 0
, wenn g(i 0 ,x) = 0
g(j,x) ≠ 0 ∧ 0 § i 0 < m
0 falls m=0 ∨ ∀ 0§j g erfüllt
Satz: Beschränkter μ-Operator kann durch ein
LOOP-Programm realisiert werden.
hs / fub - alp2-2 8

Loop-Algorithmus: beschränkter μ-Operator
x res = 0; i = 0: x m =m-1;
loop x m { wenn g(i,x) > 0 dann i=i+1;
sonst {wenn schon i 0 mit g(i 0 ,x) gefunden
dann ignoriere aktuelles i
sonst x res = i}
}
hs / fub - alp2-2 9

μ-Rekursion
Erst mit dem unbeschränkten μ-Operator erhält man
alle berechenbaren Funktionen.
Sei g: N k+1 -> N partielle Funktion.
i 0 , wenn g(i 0 ,x) = 0 ∧ ∀j < i 0 ( g(j,x) ≠ 0
f(x) = μ (g(i,x)) = ∧ g(j,x) definiert)
undefiniert sonst
hs / fub - alp2-2 10

While-Programme
Unbeschränkter μ-Operator lässt sich nicht durch ein
LOOP-Programm realisieren.
⇒ Echte Spracherweiterung der Registermaschine
erforderlich
While-Befehl:
WHILE (xi ≠ o) {P}
Semantik: führe P solange aus bis x i den Wert 0 hat.
hs / fub - alp2-2 11

Berechenbarkeit
LOOP-Programme sind WHILE-berechenbar.
Satz:
Die Klasse der μ-rekursiven Funktionen ist gleich der
durch WHILE-Programme berechenbaren Funktionen.
Mit Church'scher These heißt das:
Alle berechenbaren Funktionen können durch
imperative Programme mit WHILE-Befehl und
Zuweisung xi = xj+c, xi = xj -1 berechnet werden,
sofern sie terminieren.
hs / fub - alp2-2 12

GOTO-Registermaschine
Befehle haben Marken:
M i :B i
Zuweisungen:
xi = xj + c
xi = xj – c
Sprungbefehle:
if xi=c then GOTO Mj
GOTO Mj
bedingter Sprung: wenn Bedingung erfüllt
nächster Befehl der mit Marke Mj, sonst
der Folgebefehl.
unbedingter Sprung, nächster Befehl ist
der mit Marke Mj
beendet Programm
HALT
Marken, die nie Sprungziel sind, können weggelassen werden.
hs / fub - alp2-2 13

Satz: Die Klasse der GOTO-Programme ist gleich
der Klasse der WHILE-Programme (und damit gleich
der Klasse der μ-rekursiven Funktionen)
Beweis ("⇒")
Konstruktiv: Konstruiere für beliebiges GOTO-Programm P
WHILE-Programm P', das P emuliert.
P sei: M 1 :B 1 ,…,M n :B n
P':
zaehl=1;
while (zaehl ≠ 0) {
if (zaehl = 1) then A 1 ' ;
.
if (zaehl = n) then A n ';
}
wobei…
… Sie erst selbst
versuchen sollten, die
Ai' zu definieren und
dann mit der Lösung auf der
folgenden Folie vergleichen
sollten.
hs / fub - alp2-2 14

A i ' ≡ {x i =x j +/- c; count=count+1}
wenn A i = x i =x j +/- c
A i ' ≡ if x j =c then count=k else count=count+1
wenn A i ≡ if x j =c then GOTO M k
Ai' ≡ if x j =x j then GOTO k
wenn A i ≡ GOTO M k
Ai' ≡ count=0 wenn A i ≡ HALT
Beweis in Richtung "