Theoretische Informatik II

Theoretische Informatik II
Einheit 4.2
Rekursive Funktionen
1. Primitiv- und µ-rekursive Funktionen
2. Analyse und Programmierung
3. Äquivalenz zu Turingmaschinen

Berechenbarkeit auf N ohne Maschinenmodelle
Welche Arten von Funktionen sind berechenbar?
• Primitive Funktionen müssen berechenbar sein
– Nachfolger: von einer Zahl zur nächsten weiterzählen
– Projektion: aus einer Gruppe von Werten einen herauswählen
– Konstante: unabhängig von der Eingabe eine feste Zahl ausgeben
• Berechenbare Funktionen sind zusammensetzbar
– Einfache Operationen erzeugen neue berechenbare Funktionen
– Komposition: Hintereinanderausführen mehrerer Berechnungen
– Rekursion: Bei der Ausführung ruft eine Funktion sich selbst wieder auf
– Suche: Bestimmung der ersten Nullstelle einer Funktion
• Beschreibung benötigt keine Funktionsargumente
– Es reicht, primitive Grundfunktionen und Operationen zu benennen
– ‘Abstrakte Programmiersprache’: wende Operationen auf Funktionen an
– Mathematischer Kalkül für das informatiktypische ‘Baukastensystem’
Theoretische Informatik II §4.2: 1 Rekursive Funktionen

Bausteine µ-rekursiver Funktionen
• Grundfunktionen
– Nachfolgerfunktion s :N→N mit s(x) = x+1 für x ∈N
– Projektionsfunktionen prk n :Nn →N mit prk n(x 1, .., x n ) = x k (1≤k≤n)
– Konstantenfunktion c n k :Nn →N mit c n k (x 1, .., x n ) = k (0≤n)
• Operationen auf Funktionen
– Komposition f ◦ (g 1 , .., g n ) :N k →N (g 1 , .., g n :N k →N, f:N n →N)
Für h = f ◦ (g 1 , .., g n ) gilt h(⃗x) = f( g 1 (⃗x), .., g n (⃗x) )
– Primitive Rekursion P r[f, g] :N k →N (f:N k−1 →N, g:N k+1 →N)
Für h = P r[f, g] gilt h(⃗x, 0) = f(⃗x), und h(⃗x, y+1) = g(⃗x, y, h(⃗x, y))
– µ-Operator (Minimierung)
⎧
µf :N k →N (f:N k+1 →N)
⎨ min{y | f(⃗x, y)=0} falls dies existiert und
Für h = µf gilt h(⃗x) =
alle f(⃗x, i), i

Operationen entsprechen Programmstrukturen
• Komposition ˆ= Folge von Anweisungen
y 1
:= g 1
(x 1
,..,x m
);
.
y n
:= g n
(x 1
,..,x m
);
h := f(y 1
,..,y n
) (h ˆ= h(x 1 , .., x m ) für h = f◦(g 1 , .., g n ))
• Primitive Rekursion ˆ= umgekehrte Zählschleife
h := f(x 1
,..,x n
);
for i:=1 to y do
od
h := g(x 1
,..,x n
,i-1,h)
(h ˆ= h(x 1 , .., x n , y) für h = P r[f, g])
• Minimierung ˆ= Suche mit While-schleife
y := 0;
while f(x 1
,..,x n
,y)≠0 do
(unbegrenzte Suche)
y:=y+1
od;
h := y (h ˆ= h(x 1 , .., x n ) für h = µf
Theoretische Informatik II §4.2: 3 Rekursive Funktionen

Primitiv- und µ-rekursive Funktionen
• f:N k →N primitiv-rekursiv
– f ist Nachfolger-, Projektions- oder Konstantenfunktion
– f entsteht aus primitiv-rekursiven Funktionen
durch Komposition oder primitive Rekursion
Primitiv-rekursive Funktionen sind total (terminieren immer)
• f:N k →N µ-rekursiv (kurz rekursiv)
– f ist Nachfolger-, Projektions- oder Konstantenfunktion
– f entsteht aus µ-rekursiven Funktionen
durch Komposition, primitive Rekursion oder Minimierung
µ-rekursive Funktionen können partiell sein
• Kurzbezeichnungen
– PR: Menge der primitiv-rekursiven Funktionen
– T R: Menge der totalen µ-rekursiven Funktionen
– R: Menge der µ-rekursiven Funktionen
Theoretische Informatik II §4.2: 4 Rekursive Funktionen

Beispiel einer primitiv-rekursiven Funktion
• f 1
= P r[pr 1 1 , s ◦ pr3 3 ] Was macht f 1 ?
• Stelligkeitsanalyse:
pr 1 1:N→N, pr 3 3:N 3 →N, s ◦ pr 3 3:N 3 →N
↦→ f 1
: N 2 →N
• Auswertung durch schrittweises Einsetzen
Beispiel: f 1 (2, 2) = 4
– Einsetzen des Definitionsschemas bei Operationen
– Direkte Auswertung von Argumenten bei Grundfunktionen
• Analyse des rekursiven Verhaltens:
– f 1 (x, 0) = pr 1 1(x) = x
– f 1 (x, y+1) = (s ◦ pr 3 3)(x, y, f 1 (x, y)) = s(f 1 (x, y)) = f 1 (x, y)+1
Das ist die Rekursionsgleichung }
der Addition
x+0 = x
↦→ f 1 = add mit add(n, m) = n+m
x+(y+1) = (x+y)+1
Theoretische Informatik II §4.2: 5 Rekursive Funktionen

Analyse µ-rekursiver Funktionen
• f 2
= µc 2 1
f 2 (x) =
=
⎧
⎨
⎩
{
min{y | c 2 1(x, y)=0} falls y existiert und alle
c 2 1(x, i), i0 und y

‘Programmierung’ µ-rekursiver Funktionen
• Vorgängerfunktion p : N→N p(n) = n ˙−1
Finde ‘Programm’ im Kalkül der µ-rekursiven Funktionen
• Analysiere rekursives Verhalten:
– p(0) = 0 ˙−1 = 0
– p(y+1) = (y+1) ˙−1 = y
• Beschreibe Verhalten als Primitive Rekursion:
– Benötigt: f:N 0 →N mit p(0) = f() = 0 ↦→ f = c 0 0
und g:N 2 →N mit p(y+1) = g(y, p(y)) = y ↦→ g = pr1
2
↦→ p = P r[c 0 0 , pr2 1 ]
Theoretische Informatik II §4.2: 7 Rekursive Funktionen

Beispiele primitiv-rekursiver Funktionen
• Subtraktion sub : N 2 →N
sub(n, m) = n ˙−m
– sub(x, 0) = x = pr1(x)
1
– sub(x, y+1) = x ˙−(y+1) = (x ˙−y) ˙−1 = p(x ˙−y) = (p ◦ pr3)(x, 3 y, sub(x, y))
↦→ sub = P r[pr1, 1 p ◦ pr3]
3
• Multiplikation mul : N 2 →N
mul(n, m) = n∗m
– mul(x, 0) = 0 = c 1 0(x)
– mul(x, y+1) = mul(x, y)+x = (add ◦ (pr1, 3 pr3))(x, 3 y, mul(x, y))
↦→ mul = P r[c 1 0, (add ◦ (pr1, 3 pr3))]
3
• Exponentiierung exp : N 2 →N
exp = P r[c 1 1, (mul ◦ (pr1, 3 pr3))]
3
exp(n, m) = n m
• Fakultät fak : N→N
fak = P r[c 0 1, (mul ◦ (s ◦ pr1, 2 pr2))]
2
• Signum-Funktion sign : N→N sign(n) =
sign = P r[c 0 0, c 2 1]
fak(n) = n! = 1*2*...*n
{
0 falls n = 0
1 sonst
Theoretische Informatik II §4.2: 8 Rekursive Funktionen

Primitiv-rekursive Programmiertechniken
• Definition durch Fallunterscheidung
h(⃗x) =
{
f(⃗x) falls test(⃗x) = 0
g(⃗x) sonst
(f, g, test:N k →N primitiv-rekursiv)
Wende Signum-Funktion auf Testergebnis an und multipliziere auf
– h(⃗x) = (1 ˙−sign(test(⃗x))) ∗ f(⃗x) + sign(test(⃗x)) ∗ g(⃗x)
↦→ h = add ◦ (mul ◦ (sub ◦ (c 1 1, sign ◦ test), f), mul ◦ (sign ◦ test, g))
• Generelle Summe Σ r i=0f(⃗x, i)
Generelles Produkt Π r i=0 f(⃗x, i) (f:Nk+1 →N p.r.)
– ∑ 0
i=0
f(⃗x, i) = f(⃗x, 0)
– ∑ y+1
i=0 f(⃗x, i) = (∑ y
i=0
f(⃗x, i)) + f(⃗x, y + 1)
↦→ Σf = P r[f ◦ (pr 1 1, c 1 0), add ◦ (pr 3 3, f ◦ (pr 3 1, s ◦ pr 3 2))]
↦→ Πf = P r[f ◦ (pr 1 1, c 1 0), mul ◦ (pr 3 3, f ◦ (pr 3 1, s ◦ pr 3 2))]
Theoretische Informatik II §4.2: 9 Rekursive Funktionen
(für k=1)
Lösungen für k>1 analog

Primitiv-rekursive Programmiertechniken
• Beschränkte Minimierung
h(⃗x, t) =
{
min{y≤t | f(⃗x, y) = 0} falls dies existiert
t+1 sonst
Schreibweise: h(⃗x, t) = Mn t [f](⃗x)
Rekursives Verhalten:
{
0 fallsf(⃗x, 0) = 0
– h(⃗x, 0) =
= sign(f(⃗x, 0))
1 sonst
⎧
⎪⎨ h(⃗x, t) falls h(⃗x, t)≤t
– h(⃗x, t+1) = t+1 falls h(⃗x, t) = t+1 und f(⃗x, t+1) = 0
⎪⎩ t+2 sonst
Programmierbar mit Fallunterscheidung und
primitiver Rekursion (aufwendiger Ausdruck)
h ist primitiv rekursiv, wenn f primitiv rekursiv ist
Theoretische Informatik II §4.2: 10 Rekursive Funktionen

Weitere primitiv-rekursive Funktionen
• Absolute Differenz absdiff : N 2 →N absdiff (n, m) = |n − m|
{
• Maximum max : N 2 n falls n ≥ m
→N max(n, m) =
m sonst
{
• Minimum min : N 2 m falls n ≥ m
→N min(n, m) =
n sonst
• Division div : N 2 →N
div(n, m) = n÷m
• Divisionsrest mod : N 2 →N
• Quadratwurzel sqrt : N→N
• Logarithmus ld : N→N
mod(n, m) = n mod m
sqrt(n) = ⌊ √ n⌋
ld(n) = ⌊log 2 n⌋
• Größter gemeinsamer Teiler ggT : N 2 →N
• Kleinstes gemeinsames Vielfaches kgV : N 2 →N
Beweise in Übungen
Theoretische Informatik II §4.2: 11 Rekursive Funktionen

Berechenbare Numerierung von Zahlenpaaren
0 1 2 3 4 5 ...
0 0 1 3 6 10 15 ...
1 2 4 7 11 16 ...
2 5 8 12 17 ...
3 9 13 18 ...
4 14 19 ...
5
.
20
. . . . .
...
. ...
〈x, y〉
:=
(x+y)(x+y+1)÷2 + y
“Standard-Tupelfunktion”
• 〈〉:N 2 →N ist primitiv-rekursiv und bijektiv
• Die Umkehrfunktionen π 2 i := pr2 i ◦ 〈〉−1 sind primitiv-rekursiv
• 〈〉 kann iterativ auf N k →N und auf N ∗ →N fortgesetzt werden
– 〈x, y, z〉 3 = 〈x, 〈y, z〉〉, . . . , 〈x 1 ...x k 〉 ∗ = 〈k, 〈x 1 , .., x k 〉 k 〉
– Alle Funktionen sind bijektiv und primitiv-rekursiv
– Alle Umkehrfunktionen π k i und π ∗ i sind primitiv-rekursiv
• Jede rekursive Funktion kann einstellig simuliert werden
– Für f:N 2 →N und g:=f◦(π 2 1, π 2 2) gilt g : N→N und g〈x, y〉 = f(x, y)
Theoretische Informatik II §4.2: 12 Rekursive Funktionen

Die Ackermann-Funktion (1928)
• Definiere Funktionen A n iterativ:
A 0 (x) :=
⎧
⎪⎨
⎪⎩
1 falls x = 0
2 falls x = 1
x+2 sonst
A n+1 (0) := 1
Jede der Funktionen A n ist primitiv-rekursiv
• Wachstumsverhalten
A 1 (x) = 2x (x≥1)
A 2 (x) = 2 x
A 3 (x) = 2 (2(2...2) )
} {{ }
x−mal
A 4 (0) = 1
A 4 (1) = 2
• Definiere A(x) := A x (x)
A 4 (2) = 2 2 = 4
A n+1 (x+1) := A n (A n+1 (x))
A 4 (3) = 2 222 = 65536
A 4 (4) = 2 (2(2...2) )
} {{ }
65536−mal
A 4 (5) = 2 (2(2...2) )
} {{ }
A 4 (4)−mal
(Große Ackermann-Funktion)
– A nicht primitiv-rekursiv: A wächst schneller als jede p.r. Funktion
– A µ-rekursiv: Abarbeitung des Berechnungsstacks ‘programmierbar’
Theoretische Informatik II §4.2: 13 Rekursive Funktionen

Min-rekursive Funktionen
Funktionsdefinition ohne primitive Rekursion
• f:N k →N
min-rekursiv
– f ist Addition, Nachfolger-, Projektions- oder Konstantenfunktion
– f entsteht aus min-rekursiven Funktionen durch Komposition
oder Minimierung
Wichtiger Sonderfall für Vergleiche mit anderen Modellen
R min : Menge der min-rekursiven Funktionen
• R min ⊆ R: min-rekursive Funktionen sind µ-rekursiv
– Offensichtlich, da Additition µ-rekursiv ist
• R ⊆ R min : µ-rekursive Funktionen sind min-rekursiv
– Beschreibe Abarbeitung des Stacks einer primitiven Rekursion
– Suche nach erstem erzeugten Stack der Länge 1 (Details aufwendig)
Theoretische Informatik II §4.2: 14 Rekursive Funktionen

Ausdruckskraft rekursiver Funktionen
• Es gilt PR ⊂ T R ⊂ R
– Teilmengenbeziehung gilt offensichtlich
– T R ≠ R: nicht alle rekursiven Funktionen sind total (z.B. f 3
= µ add)
– PR ≠ T R: die Ackermannfunktion ist total, aber nicht primitiv rekursiv
• R⊆T : rekursive Funktionen sind Turing-berechenbar
– Alle Grundfunktionen sind konventionell berechenbar
– Komposition, Primitive Rekursion und µ-Operator sind berechenbar
– Konventionell berechenbare Funktionen sind Turing-berechenbar
• T ⊆R: Turing-berechenbare Funktionen sind rekursiv
– Codiere Konfigurationen (Worttupel) als Zahlentupel
– Simuliere Konfigurationsübergänge ⊢ als primitiv-rekursive Funktionen
– Beschreibe Terminierung von ⊢ ∗ als Suche nach Endkonfiguration
– Semantik der Turingmaschine ist Iteration von ⊢ bis Terminierung
Theoretische Informatik II §4.2: 15 Rekursive Funktionen

Konsequenzen der Äquivalenzbeweise
• Für formale Argumente zur Berechenbarkeit
können wahlweise Turingmaschinen oder
µ-rekursive Funktionen eingesetzt werden
• Kleene Normalform Theorem:
Für jede berechenbare Funktion h kann man primitivrekursive
Funktionen f und g konstruieren, so daß
h(x) = g(x, µf(x))
– Simuliere Turingmaschine für h als µ-rekursive Funktion
– f ist die Funktion, die Terminierung charakterisiert
– µf berechnet die Anzahl der Schritte bis zur Terminierung
– g berechnet die Iteration der Konfigurationsübergänge
• Berechenbare Funktionen kommen mit einer
einzigen Minimierung (While-Schleife) aus
Theoretische Informatik II §4.2: 16 Rekursive Funktionen