Teil XI.3. Rekursive Regeln

Transkript

1 Teil XI.3 Rekursive Regeln 1

2 Beispiel Fakten: elternteil(heike, robert). elternteil(thomas, robert). elternteil(thomas, lisa). elternteil(robert, anna). elternteil(robert, petra). elternteil(petra, jakob).?- vorfahr(heike, Z). Regeln: Regel1: vorfahr(x, Z) :- elternteil(x, Z). Regel2: vorfahr(x, Z) :- elternteil(x, Y), vorfahr(y, Z). Lösungen: Z = robert, Z = anna, Z = petra, Z = jakob?- vorfahr (thomas, petra). Yes?- elternteil(thomas, petra). No 2

3 Begriffe Closed World Assumption: Jede Feststellung q über eine Beziehung ist genau dann wahr, wenn das Programm P q impliziert, ansonsten ist q unwahr. Prozedurale Bedeutung: Konkreter Ablauf eines Beweises. Kann sich durch Änderung der Reihenfolge von Regeln (und Fakten) ändern. Deklarative Bedeutung: Bestimmt nur ob ein Ziel ableitbar ist und nicht wie ein Ziel ableitbar ist. 3

4 Rekursive Inferenz (1)?- vorfahr(thomas, petra) 4

5 Rekursive Regeln: falsche Anordnung elternteil (heike, robert). elternteil (thomas, robert). elternteil (thomas, lisa). elternteil (robert, anna). elternteil (robert, petra). elternteil (petra, jakob). vorfahr (X, Z) :- vorfahr (Y, Z), elternteil (X, Y). vorfahr (X, Z) :- elternteil (X, Z).?- vorfahr (thomas,petra). 5

6 Rekursive Inferenz: Endlosschleife 6

7 Türme von Hanoi Aufgabe: Gegeben 3 Stäbe (links,mitte,rechts). Der linke Stab ist mit N Scheiben in absteigender Größe belegt. Bewege alle Scheiben von links nach rechts mit Hilfe des mittleren Stabs so, dass nie eine Scheibe auf eine kleinere Scheibe zu liegen kommt. hanoi(n):-bewege(n,links,mitte,rechts). bewege(0,_,_,_):-!. bewege(n,a,b,c):- M is N-1, bewege(m,a,c,b), inform(n,a,c), bewege(m,b,a,c). %% fertig %% bewege N Scheiben %% von A nach C ueber B %% Zuweisung %% bewege die obersten M Scheiben %% von A nach B ueber C %% bewege die unterste Scheibe von %% A nach C %% bewege die obersten M Scheiben %% von B nach C ueber A inform(n,a,b):- write( Scheibe ),write(n), write( von ),write(a), write( nach ),write(b), write(. ),nl. 7

8 Teil XI.4 Listen 8

9 Notationsmöglichkeiten Flach: [a,b,c,d] Kopf und Rest: [a [b [c [d []]]]] Punktnotation: a.b.c.d.nil Funktornotation: *(a,*(b,*(c,*(d,[])))) 9

10 Mitgliedschaft Regeln: mitglied(element,liste) mitglied(element, [Element _]). %% Fakt: Gefunden mitglied(element, [_ Rumpf]):- mitglied(element,rumpf). %% Regel: Suche im Rest. Anfragen:?- mitglied(kirsche,[apfel,birne,kirsche,ananas]). Yes?- mitglied(kirsche,[apfel,[kirsche,birne,ananas]). No?- mitglied(kirsche,x). X = [kirsche _G208]; X = [_G207, kirsche _G211] Yes 10

11 Kombination Regeln: myappend(liste1,liste2,gesamtliste) myappend([],liste,liste). myappend([kopf AlteListe], Liste, [Kopf NeueListe]):- myappend(alteliste,liste,neueliste). Anfragen:?- myappend([a, b], [c, d], [a, b, c, d]). Yes?- myappend([x, a, b, c], [d], Gesamtliste). Gesamtliste = [X, a, b, c, d].?- myappend([x [a, b, c]], [d], Gesamtliste). Gesamtliste = [X, a, b, c, d].?- myappend(x,y,[a,b,c]). X=[], Y=[a,b,c]; X=[a], Y=[b,c]; X=[a,b], Y=[c]; X=[a,b,c], Y=[]. Alternative Regel für Mitgliedschaft mitglied(x,liste):- append(liste1,[x Liste2], Liste). 11

12 Hinzufügen und Löschen hinzufuegen(x, Liste, [X Liste]). loesche(_, [], []). loesche(x, [X Rumpf], Rumpf) :-!. loesche(x, [Y Rumpf], [Y Rumpf1]):- loesche(x, Rumpf, Rumpf1). loeschealle(_, [], []). loeschealle(x, [X Rumpf], Rumpf1) :-!, loeschealle(x, Rumpf, Rumpf1). loeschealle(x, [Y Rumpf], [Y Rumpf1]):- loeschealle(x, Rumpf, Rumpf1). 12

13 Teillisten und Inverse sublist(s,l) :- myappend(_, Liste, L), %% instanziiere Liste %% mit allen "Resten" von L myappend(s,_,liste). %% instanziiere S mit allen %% "Koepfen" von Liste invert([],[]). invert([kopf Rest], Liste) :- invert(rest,rest1), myappend(rest1,[kopf],liste) %% invertiere den Rest %% haenge Kopf hinten an %% das Ergebnis. 13

14 Mengenoperationen (1) removedups([], []). removedups([x Menge1], Menge2) :- mitglied(x, Menge1),!, removedups(menge1,menge2). removedups([x Menge1], [X Menge2]) :- removedups(menge1,menge2). difference([],_,[]). difference([kopf Rest1], Menge, Rest2) :- mitglied(kopf,menge),!,difference(rest1,menge,rest2). difference([kopf Rest1], Menge, [Kopf Rest2]) :- difference(rest1,menge,rest2). myunion([],menge,menge). myunion([kopf Rest1], Menge, Rest2) :- mitglied(kopf,menge),!,myunion(rest1,menge,rest2). myunion([kopf Rest1], Menge, [Kopf Rest2]) :- myunion(rest1,menge,rest2). 14

15 Mengenoperationen (2) myintersect(a,b,resultat) :- difference(a,b,aminusb), difference(a,aminusb,resultat). myintersect1([],_,[]). myintersect1([kopf Rest1], Menge, [Kopf Rest2]) :- mitglied(kopf,menge),!,myintersect1(rest1,menge,rest2). myintersect1([kopf Rest1], Menge, Rest2) :- myintersect1(rest1,menge,rest2). myintersect2([],_,[]). myintersect2([kopf Rest1], Menge, [Kopf Rest2]) :- mitglied(kopf,menge), myintersect2(rest1,menge,rest2). myintersect2([kopf Rest1], Menge, Rest2) :- not(mitglied(kopf,menge)), myintersect2(rest1,menge,rest2). 15

16 Design Pattern für Umgang mit Listen Terminalbedingung für leere Liste intersect([],_,[]). Kopf/Rest-Rekursion: Dekonstruktion und Konstruktion: intersect([kopf Rest1], Menge, [Kopf Rest2]) :- mitglied(kopf,menge),!,intersect(rest1,menge,rest2). (Disjunkte) Fallunterscheidung: intersect([kopf Rest1], Menge, Rest2) :- intersect(rest1,menge,rest2). 16

17 Sortieren: Generiere und Teste sortiere(l1,l2):- permutation(l1,l2), sortiert(l2),!. %% Generiere %% Teste permutation([],[]). permutation(l,[k R]):- %% fuege K an erstes Element von %% permutiertem Rest append(l1,[k L2],L), %% instanziiere K mit jedem Element %% aus L append(l1,l2,r1), %% instanziiere R1 mit der Teilliste %% von L ohne K permutation(r1,r). %% instanziiere R mit Permutation von R1 sortiert([]). sortiert([x]). sortiert([x,y L]):- X =< Y, sortiert([y L]). 17

18 Sortieren durch Einfuegen insort([],[]). insort([k R],L) :- insort(r,r1), %% sortiere Rest sortinto(k,r1,l). %% fuege K in R1 sortiert ein sortinto(x,[k R],[K R1]):- K =< X, %% X gehoert nach K!, sortinto(x,r,r1). sortinto(x,l,[x L]). 18

19 Bubblesort bubblesort(l,s):- myappend(x,[a,b Y],L), B < A,!, myappend(x,[b,a Y],M), bubblesort(m,s). bubblesort(l,l). %% instanziiere A,B mit allen %% aufeinanderfolgenden Elementen aus L %% wenn B kleiner als A %% vertausche B und A %% sortiere Resultat. 19

20 Quicksort %% split(x,l,l1,l2) %% Teile Liste L in L1 und L2, sodass alle Elemente in %% in L1 =< X und alle Elemente in L2 > X sind. split(x,[k R],[K R1],L2):- K =< X, %% K kommt in L1 = [K R1] split(x,r,r1,l2). %% Teile restliche Liste split(x,[k R],L1,[K R2]):- K > X, %% K kommt in L2 = [K R2] split(x,r,l1,r2). %% Teile restliche Liste split(_,[],[],[]). %% Leere Liste wird nicht geteilt. quicksort([],[]). quicksort([k R],L):- split(k,r,l1,l2), %% Teile Rest R nach Kopf K %% in Listen L1 und L2 quicksort(l1,s1), %% Sortiere L1, ergibt S1 quicksort(l2,s2), %% Sortiere L2, ergibt S2 append(s1,[k S2],L). %% Fuege Kopf K zwischen S1 und S2. 20

21 Teil XI.5 Umgang mit Baumstrukturen 21

22 Symbolisches Differenzieren dc/dx 0 dx/dx 1 d( U)/dx du/dx d(u + V )/dx du/dx + dv/dx d(u V )/dx du/dx dv/dx d(cu)/dx c(du/dx) d(uv )/dx U(dV/dx) + V (du/dx) d(u/v )/dx d(uv 1 )/dx d(u c )/dx cu c 1 (du/dx) d(log e U)/dx U 1 (du/dx) 22

23 Symbolisches Differenzieren in Prolog?- op(300,yfx,^). d(x,x,1):-!. d(c,x,0):-atomic(c). d(-u,x,-a):-d(u,x,a). d(u+v,x,a+b):-d(u,x,a),d(v,x,b). d(u-v,x,a-b):-d(u,x,a),d(v,x,b). d(c*u,x,c*a):-atomic(c),c\=x,d(u,x,a),!. d(u*v,x,b*u+a*v):-d(u,x,a),d(v,x,b). d(u/v,x,a):-d(u*v^(-1),x,a). d(u^c,x,c*u^(c-1)*w):-atomic(c), C\=X,d(U,X,W). d(log(u),x,a*u^(-1)):-d(u,x,a).?- d(x^n+3*x^2,x,r). R = n*x^ (n-1)*1+3* (2*x^ (2-1)*1) Yes?- d(log(x^3),x,r). R = 3*x^ (3-1)*1*x^3^ -1 Yes 23

24 Vereinfachung Arithmetischer Ausdrücke (1) simp(e,e):-atomic(e),!. simp(e,f):- E=..[Op,L,R], simp(l,x), simp(r,y), s(op,x,y,f). 24

25 Vereinfachung Arithmetischer Ausdrücke (2) s(+,x,y,z):-integer(x),integer(y),!,z is X + Y. s(+,x,0,x):-!. s(+,0,x,x):-!. s(+,x+y,w,x+z):-integer(y),integer(w),!,z is Y+W. s(+,x,y,x+y):-!. s(-,x,y,z):-integer(x),integer(y),!,z is X - Y. s(-,x,0,x):-!. s(-,0,x,-x):-!. s(-,x,y,x-y):-!. s(*,x,y,z):-integer(x),integer(y),!,z is X * Y. s(*,_,0,0):-!. s(*,0,_,0):-!. s(*,1,x,x):-!. s(*,x,1,x):-!. s(*,x*y,w,x*z):-integer(y),integer(w),!,z is Y*W. s(*,x,y,x*y):-!. s(/,_,0,error):-!. s(/,0,_,0):-!. s(/,x,1,x):-!. s(/,x,y,x/y):-!. s(^,x,1,x):-!. s(^,_,0,1):-!. s(^,x,y,x^y):-!. 25

26 Symbolisches Differenzieren mit Vereinfachung sd(x,y,z):- d(x,y,z1),simp(z1,z).?- sd(x^n+3*x^2,x,r). R = n*x^ (n-1)+3* (2*x) Yes?- sd(log(x^3),x,r). R = 3*x^2*x^3^ -1 Yes?- sd(x^3*(x+a),x,r). R = x^3+3*x^2* (x+a) Yes 26