Funktionale Programmierung ALP I. µ-rekursive Funktionen WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda

Transkript

1 ALP I µ-rekursive Funktionen WS 2012/2013

2 Primitiv-rekursive Funktionen Jede primitiv-rekursive Funktion ist Loop-berechenbar. Das bedeutet, dass jede PR-Funktion in der Loop-Programmiersprache formuliert werden kann. Jede Loop-berechenbare Funktion ist auch eine PR-Funktion. Loop-Sprache: - stark beschränkte Programmiersprache nur Addition, Zuweisungen und loop-schleifen sind erlaubt - Loop-Programme terminieren immer. - Die Laufzeit kann genau berechnet werden.

3 Loop-Sprache Syntaktische Komponenten: 3 Schlüsselwörter: Loop, Do, End 4 Sondersymbole: +, -, ;, := Beliebige Variablennamen: x 1, x 2, x 3,... Beliebige Konstanten: 0, 1, 2,... Syntax in BNF: P := x i := x j + c x i := x j c P;P LOOP x i DO P END Wertzuweisungen sequentielle Komposition endliche Schleife

4 Zusammengefast: Primitiv-rekursive Funktionen Jede primitiv-rekursive Funktion kann mit Hilfe einer Loop-Schleife berechnet werden und umgekehrt. Addition x 1 + x 2 x 3 x3 := x1 + 0 LOOP x2 DO x3 := x3 + 1 END Berechnet die n-te Fibonacci-Zahl (Eingabe in x n und Ausgabe in x fib ) x 2 := 0; x 1 := x 2 +1; x fib := 0; x n := n; LOOP x n DO END x 2 := x fib + 0 LOOP x 1 x fib := x fib + 1 END x 1 := x 2 + 0

5 Ackermann-Funktion Bis 1926 vermutete Hilbert, dass jede totale berechenbare Funktion primitiv rekursiv ist, bis zwei von seinen Schülern, Ackermann (1928) und Sudan (1927), Funktionen entdeckten, die nicht primitiv rekursiv aber total berechenbar sind. Ackerman-Péter-Funktion ack :: Integer -> Integer -> Integer ack 0 n = n + 1 ack (m+1) 0 = ack m 1 ack (m+1) (n+1) = ack m (ack (m+1) n)

6 Ackerman-Péter-Funktion ack 0 n = n + 1 ack (m+1) 0 = ack m 1 Reduktionsverlauf: ack (m+1) (n+1) = ack m (ack (m+1) n) ack 2 3 => ack 1 (ack 2 2) => ack 1 (ack 1 (ack 2 1)) m+1 n+1 (m+1) rekursive Aufrufe von (n-1) => ack 1 (ack 1 (ack 1 (ack 2 0))) 4 rekursive Aufrufe von 1 => ack 1 (ack 1 (ack 1 (ack 1 1))) => ack 1 (ack 1 (ack 1 (ack 0 (ack 1 0)))) => ack 1 (ack 1 (ack 1 (ack 0 (ack 0 1)))) => ack 1 (ack 1 (ack 1 (ack 0 2))) => ack 1 (ack 1 (ack 1 3)) => ack 1 (ack 1 (ack 0 (ack 1 2))) => ack 1 (ack 1 (ack 0 (ack 0 (ack 1 1)))) => ack 1 (ack 1 (ack 0 (ack 0 (ack 0 (ack 1 0))))) => ack 1 (ack 1 (ack 0 (ack 0 (ack 0 (ack 0 1))))) => ack 1 (ack 1 (ack 0 (ack 0 (ack 0 2)))) => ack 1 (ack 1 (ack 0 (ack 0 3))) => ack 1 (ack 1 (ack 0 4)) => ack 1 (ack 1 5) => ack 1 (ack 0 (ack 1 4)) => ack 1 (ack 0 (ack 0 (ack 1 3))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 1 2)))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 1))))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 0)))))) =>...

7 ... => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 0)))))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 1)))))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 2))))) => ack 1 (ack 0 (ack 0 (ack 0 (ack 0 3)))) => ack 1 (ack 0 (ack 0 (ack 0 4))) => ack 1 (ack 0 (ack 0 5)) => ack 1 (ack 0 6) ack 0 n = n + 1 => ack 1 7 ack (m+1) 0 = ack m 1 => ack 0 (ack 1 6) ack (m+1) (n+1) = ack m (ack (m+1) n) => ack 0 (ack 0 (ack 1 5)) => ack 0 (ack 0 (ack 0 (ack 1 4))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 1 3)))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 2))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 1)))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 1 0))))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 1))))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 2)))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 (ack 0 3))))) => ack 0 (ack 0 (ack 0 (ack 0 (ack 0 4)))) => ack 0 (ack 0 (ack 0 (ack 0 5))) => ack 0 (ack 0 (ack 0 6)) => ack 0 (ack 0 7)) => ack 0 8 => 9 Die Argumente bewegen sich nicht immer in Richtung der Abbruchbedingung.

8 ... ack 4 2 => (19,729 Ziffern) Ackermann-Funktion

9 die Folge n+1, n+m, n*m, n m, ab hier reichen unsere bekannten arithmetischen Operationen nicht mehr Idee Up-Arrow-Notation von Knuth a b = a x a x x a b Wiederholungen von a a b = a a a b Wiederholungen von a = a ( a (a a) ) = a a b = a a a b Wiederholungen von a a a a... b Wiederholungen von a

10 Up-Arrow-Notation von Knuth m Wiederholungen von im allgemeinen: a m b = a b = a m-1 a m-1 m-1 a b Wiederholungen von a = a m-1 (a m-1 (a m-1 a) ) Beispiel: 2 3 = 2 x 2 x 2 = = = 2 4 = 2 x 2 x 2 x 2 = = = 2 4 = = 2 16 = 65536

11 ack(0,n) = n+1 Ack(m,n) ack(1,n) = n+2 = 2 + (n+3) -3 ack(2,n) = 2n+3 = 2 x (n+3) -3 ack(3,n) = 2 (n+3) -3 = 2 "" (n+3) -3 ack(4,n) = = 2 (n+3) -3 ack(5,n) = = 2 (n+3) -3 ack(m,n) = = 2 m-2 (n+3) -3

12 Ackermann-Funktion - verschachtelte Rekursion. Das bedeutet, ein Argument des rekursiven Aufrufs muss selbst erst rekursiv berechnet werden - nicht primitiv rekursiv, aber berechenbar - wächst schneller als jede primitiv-rekursive Funktion - eine Komplexitätsanalyse wird unmöglich - der Verwaltungsaufwand des Ausführungsstapels ist extrem groß

13 Sudan-Funktion Definition: in Haskell: sud :: Integer -> Integer -> Integer -> Integer sud 0 x y = x+y sud n x 0 = x sud n x y = sud (n-1) (sud n x (y-1)) ((sud n x (y-1)) + (y-1) + 1) prelude> sud it :: Integer ( secs, bytes)

14 µ-rekursive Funktionen 1. Alle primitiv-rekursive Funktionen sind auch µ-rekursive Funktionen. 2. mit dem µ-operator als weiterem Konstruktionsoperator wird die Klasse der primitiv-rekursiven Funktionen auf die Klasse der partiellen µ-rekursiven Funktionen erweitert 3. und damit die Klasse der intuitiv berechenbaren Funktionen konstruiert.

15 Der unbeschränkte µ-operator Sei f : N m+1 N eine partielle Funktion, dann ist die partielle Funktion µf : N m N definiert durch: µf (x 1,...,x m ) = min M (f, x 1,...,x m ) falls M(f, x 1,...,x m ) θ undefiniert sonst wobei die Menge M ( f, x 1,..., x m ) als { n 0 f (x 1,...,x m, n ) = 0 und f (x 1,...,x m, k ) für alle n k definiert ist }

16 Der unbeschränkte µ-operator Sei b eine Funktion, die angewendet auf x, y (natürliche Zahlen) testet, ob y eine Primzahl und gleichzeitig größer als x ist. b (x, y) = 1 falls y eine Primzahl größer als x ist 0 sonst Folgende Funktion liefert die kleinste Primzahl, die größer als x ist: f(x) = µ y [ 1 - b(x, y) ] liefert das kleinste y, sodass die Bedingung erfüllt wird. Sei g (n, y) = 1 - b(n, y) y := 0; while g(n,y) 0 do y := y+1; f := y;

17 Äquivalenz vieler Berechnungsmodelle Effektiv Berechenbare Funktionen Mathematische Modelle Maschinelle Modelle Register Maschinen ALP II Turing-Maschine Theoretische Informatik I λ-kalkül Kombinatorische Logik µ-rekursive Funktionen Allgemein rekursive Funktionen

18 µ-rekursive Funktionen Effektiv Berechenbare Funktionen Primitiv Rekursive Funktionen Allgemein rekursive Funktionen Mathematische Modelle µ-rekursive Funktionen Loop- Berechenbar While- Berechenbar Maschinelle Modelle