Primitive Rekursion. Basisfunktionen: Konstante Funktion: const 3 3 (1,1, pr 1,3(g,h) (1,1)) Projektion: proj 3 (1,1, pr. Komposition: comp 3,2

Transkript

1 Primitive Rekursion Basisfunktionen: Konstante Funktion: const Stelligkeit. Wert des Ergebnisses. Unabhängig von den Parametern. const (,, pr,(g,h) (,)) Stelligkeit. Projektion: proj Gibt die Komponente an, auf die abgebildet wird. proj (,, pr,(g,h) (,)) Komposition: comp, Gibt die Anzahl der Funktionen an, die miteinander verknüpft werden. Stelligkeit: ist immer gleich der Stelligkeit der verwendeten Funktionen. comp, (proj, proj, add) (,,) = add (proj (,,), proj (,,)) = add (,) =

2 Beispiel dafür, daß die Additionsfunktion primitiv rekursiv ist Die Additionsfunktion add: x, (n, m) n + m ist primitiv rekursiv, denn die folgende durch primitive Rekursion definierte Funktion ist aus der Klasse der primitiv rekursiven Funktionen, und berechnet add: add(0,m) = m+0 = m = g(m) g(m) = proj add(n+,m) = m+n+ = h(n, m, add(n,m)) h(n, m, add(n,m)) = comp, (proj, proj ; succ) [n+m und davon den Nachfolger =: +] Klasse der primitiv rekursiven Funktionen Die Klasse der primitiv rekursiven Funktionen ist aufgebaut aus drei Grundfunktionen und zwei Erzeugungsstrategien. Definition: Uwe Schöning: Theoretische Informatik kurzgefasst,. Auflage, S.09. Die Klasse der primitiv rekursiven Funktionen auf den natürlichen Zahlen ist induktiv wie folgt definiert: ) Alle konstanten Funktionen sind primitiv rekursiv. ) Alle identischen Abbildungen (Projektionen) sind primitiv rekursiv. ) Die Nachfolgerfunktion succ(n) = n+ auf den natürlichen Zahlen ist primitiv rekursiv. 4) Jede Funktion, die durch Einsetzung (Komposition) von primitiv rekursiven Funktionen entsteht, ist selber auch primitiv rekursiv. 5) Jede Funktion, die durch primitive Rekursion aus primitiv rekursiven Funktionen entsteht, ist primitiv rekursiv. Für eine primitiv rekursive Funktion f gilt: Primitive Rekursion Primitive Rekursion bedeutet, daß die Definition von f(n+,...) zurückgeführt wird auf f(n,...). Formal: f muss das Gleichungssystem der folgenden Form erfüllen: f (0,... ) = g (... ) f (n+,... ) = h (f(n,... ),...) wobei g und h bereits primitiv rekursive Funktionen sind. Dabei gilt: ist f n-stellig, so ist g n--stellig und h n+-stellig. Falls f durch eine primitive Rekursion definiert ist, hat sie die folgende allgemeine Form bzw. entspricht sie dem folgenden Schema: f(0, x,..., x r ) = g(x,..., x r ) f(n+, x,..., x r ) = h(f(n, x,..., x r ), n, x,..., x r ) Rekursive Funktion Eine rekursive Funktion ist eine Funktion, die durch eine endliche Menge von Regeln definiert und für verschiedenen Argumente mit Hilfe folgender Komponenten spezifiziert ist: Variablen, nichtnegativen ganzzahligen Konstanten, der Nachfolger-Funktion, der Funktion selbst sowie einem durch Komposition von Funktionen aus diesen erzeugtem Ausdruck. Die Klasse der rekursiven Funktionen ist identisch zur Klasse der partiell rekursiven Funktionen.

3 Primitiv rekursive Funktion Eine Funktion heißt primitiv rekursiv, wenn sie aus einer endlichen Anzahl von Anwendungen der Komposition und der primitiven Rekursion, angewandt auf die Konstante 0, die Nachfolger-Funktion oder eine Projektion P i (x,...,x n ) = x i, besteht. Jede primitiv rekursive Funktion ist eine total rekursive Funktion. Klasse der μ -rekursiven Funktionen: Uwe Schöning: Theoretische Informatik kurzgefasst,. Auflage, S.5: Definition: Die Klasse der μ -rekursiven Funktionen ist die kleinste Klasse von (eventuell partiellen) Funktionen, die die Basisfunktionen (konstante Funktionen, identische Abbildung, Nachfolgerfunktion) enthält und abgeschlossen ist unter Einsetzung, primitiver Rekursion und Anwendung des μ -Operators. k μ - Operator: μ f: Funktionen, die Funktionen in Funktionen abbilden, heißen Funktionale oder auch Operatoren. Durch den μ -Operator wird eine (durch das erste Argument einer Funktion f) beschränkten Suche nach einer Nullstelle der Funktion f realisiert. Eine echte Erweiterung der Klasse der primitiv rekursiven Funktionen wird durch Hinzunahme des μ -Operators erreicht. Sei f eine gegebene k+-stellige Funktion. Die durch Anwendung des μ -Operators auf f entstehende Funktion ist g: k mit g(x,...,x k ) = min n f(n, x,...,x k ) = 0 f(m, x,...,x k ) falls m n falls m < n Hierbei wird min = undefiniert gesetzt. Das heißt, durch Anwendung des μ -Operators können wirklich partielle Funktionen entstehen. Beispielsweise entsteht durch Anwendung des μ -Operators auf die zweistellige, konstante Funktion f(x,y) = die vollständig undefinierte Funktion Ω. k Mit μ f: bezeichnen wir die solcherart über die (k+)-stellige Funktion f definierte Funktion. Der μ -Operator minimalisiert das Rekursionsargument und prüft, ob das Rekursionsargument schon den Wert Null angenommen hat. Der μ -Operator ist ein Minimierungsoperator min(f(x)), der als das kleinste x definiert ist, für das f(x) = 0 gilt. Durch den μ -Operator können auch partielle Funktionen erzeugt werden. Die Anwendung des μ -Operator auf eine berechenbare Funktion führt wieder zu einer berechenbaren Funktion.

4 Primitiv rekursive Funktionen entsprechen den loop-algorithmen. Zur Definition rekursiver Funktionen, die den while-algorithmen entsprechen, vergegenwärtigen wir uns noch mal, daß bei Verwendung des Rekursionsschemas zur Berechnung von f(m,...) der Wert m die Rolle des Zählers für die Anzahl der Rekursionsschritte spielt. m entspricht bei der Umsetzung in einen loop-algorithmus dem Schleifenzähler. Die Verallgemeinerung zu while- Algorithmen erreichen wir, wenn wir m solange hochzählen, bis eine bestimmte Bedingung, z.b. f(m,...) = 0, erfüllt ist. Genau dazu wird der μ -Operator definiert. μ m: f(m, n,..., n k ) = min f(m, n,..., n k ) = 0 und m alle f(j, n,..., n k ) mit 0 j < m sind definiert μ m: f(m, n,..., n k ) ist undefiniert, wenn es kein solches m gibt, oder wenn beim Hochzählen m = 0,,,... zuerst ein Argument-Tupel (m, n,..., n k ) erreicht wird, für das f nicht definiert ist. Der μ-operator μ m: f(m, n,..., n k ) definiert im allgemeinen eine partielle Funktion. h(n,..., n k ). h ist zum Beispiel dann total, wenn f eine totale Funktion ist und es für jedes k- Tupel (n,..., n k ) mindestens einen Wert m mit f(m, n,..., n k ) = 0 gibt. Satz von Kleene Uwe Schöning: Theoretische Informatik kurzgefasst,. Auflage, S.6. Für jede n-stellige μ -rekursive Funktion f gibt es zwei (n+)-stellige, primitiv rekursive Funktionen p und q, so daß sich f darstellen lässt als f(x,...,x n ) = p(x,...,x n, μ q( x,...,x n )) Hierbei ist μ q die durch Anwendung des μ -Operators auf q entstehende (n-stellige) Funktion. P: Klasse der primitiv rekursiven Funktionen Erweiterung durch den μ - Operator R: Klasse der μ - rekursiven Funktionen P R R: Klasse der μ -rekursiven Funktionen P: Klasse der primitiv rekursiven Funktionen 4

5 Korollar Eine totale Funktion f:, für die nur an endlich vielen Stellen f(n) 0 gilt, ist primitiv rekursiv. Alle Funktionen aus der Klasse der primitiv rekursiven Funktionen sind total, weil die drei Grundfunktionen total sind, und die Erzeugungsstrategien Einsetzung und primitive Rekursion von totalen Funktionen wieder zu totalen Funktionen führen. Die Klasse der primitiv rekursiven Funktionen ist für die Charakterisierung der im intuitiven Sinn (Churche These) berechenbaren Funktionen nicht geeignet, weil die partiellen Funktionen ausgeschlossen sind Tatsächlich gibt es sogar totale Funktionen, die im intuitiven Sinn berechenbar, aber nicht primitiv rekursiv sind. Bekanntestes Beispiel dafür ist die Ackermann Funktion. Ackermann Funktion Die Ackermann Funktion ist nicht primitiv rekursiv, aber μ-rekursiv! Definition a(0,y) = y+ a(x,0) = a(x-,), x > 0 a(x,y) = a(x-, a(x,y-)), x, y > 0 Die Ackermann Funktion ist nicht primitiv rekursiv, aber μ -rekursiv. Für den Beweis braucht man mehrere Lemmata:. Lemma: y < a(x,y). Lemma: a(x,y) < a(x,y+). Lemma: a(x,y+) a(x+,y 4. Lemma: a(x,y) < a(x+,y) 5. Lemma: Für jedes LOOP-Programm gibt es eine Konstante k, so daß für alle n gilt : f P (n) < a(k,n). Die Ackermann Funktion ist nicht LOOP-berechenbar, sonder WHILE-berechenbar. Die Ackermann Funktion ist ein Beispiel dafür, daß es totale, berechenbare Funktionen gibt, die nicht primitiv rekursiv sind, denn es läßt sich zeigen, daß die Ackermann Funktion schneller wächst als jede primitiv rekursive Funktion. In einem loop-algorithmus ist die Anzahl der ineinander geschachtelten Schleifen konstant und aus dem Programmtext ersichtlich. Mit while-algorithmen und allgemein mit jeder Turing-mächtigen Sprache lassen sich jedoch auch Schleifen formulieren, die eine variable Anzahl geschachtelter for-schleifen simulieren. a(, n) = n+ a(, n) = n+ eine for-schleife a(, n) = n+ zwei geschachtelte for-schleifen a(4, n) =.. drei geschachtelte for-schleifen 5

6 Das erste Argument charakterisiert die Schachtelungstiefe, denn es gilt für m : a(m,n) = a(m-, a(m-,... a(m-,)...)) Die Schachtelungstiefe von for-schleifen liefert zusammen mit der maximalen Eingabe eine Schranke für die größte von einem loop-algorithmus berechenbare Zahl. Es läßt sich zeigen, daß die Ackermann Funktion schneller wächst als alle Ergebnisse von loop-algorithmen bei gleicher Eingabe. Die Ackermann Funktion stellt also selbst eine solche Schranke dar. Die Ackermann Funktion ist nicht primitiv rekursiv. Beweis durch Widerspruch: Wir nehmen an, daß die Ackermann Funktion primitiv rekursiv ist. Dann ist auch die Funktion f(n) = ack(n,n) primitiv rekursiv, denn f entsteht aus ack durch Einsetzung (f(n) = ack(proj (n), proj (n))). Es gibt eine Konstante c mit f(n) < ack(c,n) für alle n. Betrachtet man nun speziell n = c, so folgt ack(c,c) = f(c) < ack(c,c), was ein Widerspruch ist. Ein einfaches Programm in Java. zur Berechnung der Ackermann Funktion. Die Parameter können über die Konsole eingegeben werden. import java.io.*; public class Ackermann { static int a, b; static int Ack(int m, int n) { if ((m==0) && (n>0)) return (n+); else if((n==0) && (m>0)) return (Ack(m-,)); else return (Ack(m-, Ack(m, n-))); public static void main (String args[]) { InputStreamReader in = new InputStreamReader(System.in); BufferedReader puffer = new BufferedReader (in); System.out.println("\nBitte geben Sie zwei natuerliche Zahlen ein."); try { int x, y; System.out.println("\nDer erste Parameter ist:"); a = new Integer(puffer.readLine()).intValue(); System.out.println("\nDer zweite Parameter ist:"); b = new Integer(puffer.readLine()).intValue(); System.out.println("\nDas Ergebnis von Ack("+a+","+b+") ist:"); System.out.println(Ack(a,b)); catch (IOException e) { e.printstacktrace(); 6

7 Minimalisierung Bei der Minimalisierung ist das Rekursionsargument gesucht, für das die Funktion Null ergibt. Eine Minimalisierung durchführen heißt, zu prüfen, ob die Funktion den Wert Null hat. Bekannte primitiv rekursive Funktionen add(n,m) sub(n,m) mult(n,m) succ(n) hoch(n,m) turm(n,m) minus(n,m) m(n) Imperative Programmierung in Modula von primitiv rekursiven Funktionen PROC const 0 (n : CARD) : CARD; RETURN 0 PROC proj (n, n, n : CARD) : CARD; RETURN n PROC proj (n, n, n : CARD) : CARD; RETURN n PROC P (n, n, n : CARD) : CARD; RETURN n add (proj (n, n, n ), proj (n, n, n ) n n P: add (n, n ) PROC P (n, n : CARD) : CARD; VAR x, i : CARD; x : = const (n 0 ); FOR i := TO n DO x := P ( I-, n, x) 7

8 PROC proj (n : CARD) : CARD; RETURN n PROC suc (n : CARD) : CARD; RETURN n + PROC P (n, n, n : CARD) : CARD; RETURN suc (proj (n, n, n )) PROC P4 (n, n : CARD) : CARD; VAR x, i : CARD; x : = proj (n ); FOR i := TO n DO x := P ( i -, n, x) PROC P (n, n, n : CARD) : CARD; RETURN n + PROC P4 (n, n : CARD) : CARD; VAR x, i : CARD; x : = n ; FOR i := TO n DO x := x + PROC P (n, n : CARD) : CARD; VAR x, i : CARD; x : = 0; FOR i := TO n DO x := P4 ( n, x) PROC P (n, n : CARD) : CARD; VAR x, i, i, x, n, n : CARD; x : = 0; 8

9 FOR i := TO n DO n := n ; n := x; x := n `; FOR i` := TO n` DO x` := x` + x := x` Beispiel Gegeben ist die primitiv rekursive Funktion in Termdarstellung: f = pr, (const, comp,(comp, (proj, const ;add),proj ;mult)) mult ist hierbei definiert als mult(n,m) = n m und add sei add(n,m) = n+m; beide Funktionen können als bekannte primitiv rekursive Funktionen genutzt werden. a) Geben Sie eine Abwicklung des Schemas für das Argumentpaar (,) an. f(,) = pr, (g,h) (,) = pr, (const, comp,(comp, (proj, const ;add),proj ;mult)) (,) = comp, (comp, (proj, const ;add), proj ;mult) (,, pr,(g,h) (,)) = mult (comp, (comp, (proj, const ;add)) (,, pr,(g,h) (,), proj (,, pr,(g,h) (,)) = mult (add (proj (,, pr,(g,h) (,)), const (,, pr,(g,h) (,)), proj (,, pr,(g,h) (,)) = mult (add (,), pr, (g,h)(,)) = mult (4, pr, (g,h)(,)) = 4 pr, (g,h)(,) pr, (g,h)(,) = pr, (const, comp,(comp, (proj, const ;add),proj ;mult)) (,) = comp, (comp, (proj, const ;add),proj ;mult)) (0,, pr,(g,h) (0,)) = mult (comp, (proj, const ;add) (0,, pr,(g,h) (0,), proj (0,, pr,(g,h) (0,))) = mult ( add (proj (0,, pr,(g,h) (0,)), const ), proj (0,, pr,(g,h) (0,))) = mult (add(,), pr, (g,h) (0,))) = mult (4, pr, (g,h) (0,)) = 4 pr, (g,h)(0,)) pr, (g,h)(0,) = pr, (const, comp,(comp, (proj, const = const (0,) = ;add),proj ;mult)) (0,) 4 pr, (g,h)(,) = 4 4 pr, (g,h)(0,) = 4 4 = 4 = (+) 9