Datenstruktur zum Speichern einer endlichen Menge M von Zahlen. Genauer:

Transkript

1 Binäre Suchbäume (binary search trees, kurz: bst) Datenstruktur zum Speichern einer endlichen Menge M von Zahlen. Genauer: Binärbaum T mit n := M Knoten Jeder Knoten v von T ist mit einer Zahl m v M markiert. Und zwar so, dass es für jedes m M einen Knoten v von T gibt mit m v = m. Für jeden Knoten v von T, alle Knoten u im linken Teilbaum unter v und alle Knoten w im rechten Teilbaum unter v gilt: m u < m v < m w. Implementation als Logik-Programm: Programm 3.14: searchtree.pl % Binaere Suchbaeume mit Integer-Eintraegen in den Knoten bst(x) :- bst(x, minus_infinity, infinity). bst(nil, _, _). % leerer Suchbaum bst(node(n,tl,tr), Nmin, Nmax) :- integer(n), leq(nmin,n), leq(n,nmax), NminusOne is N-1, NplusOne is N+1, bst(tl, Nmin, NminusOne), bst(tr, NplusOne, Nmax). % leq steht fuer "less than or equal to" leq(minus_infinity, _). leq(_, infinity). leq(n,m) :- integer(n), integer(m), N =< M. % Zahl einfuegen in einen bst bst_insert(n, nil, node(n,nil,nil)). bst_insert(n, node(n,tl,tr), node(n,tl,tr)). bst_insert(n, node(m,tl,tr), node(m,ul,tr)) :- N < M, bst_insert(n, Tl, Ul). bst_insert(n, node(m,tl,tr), node(m,tl,ur)) :- N > M, bst_insert(n, Tr, Ur). % Liste von Zahlen einfuegen in einen bst bst_list_insert([], T, T). 26. November 2014 Seite 123

2 bst_list_insert([n Ns], T, U) :- bst_insert(n, T, T1), bst_list_insert(ns, T1, U). % Testen, ob Zahl in bst enthalten ist bst_member(n, node(n,_,_)). bst_member(n, node(m,tl,_)) :- N < M, bst_member(n, Tl). bst_member(n, node(m,_,tr)) :- N > M, bst_member(n, Tr). % Maximales Element finden und loeschen bst_delmax(node(m,tl,nil), M, Tl). bst_delmax(node(m,tl,tr), N, node(m,tl,u)) :- bst_delmax(tr, N, U). % Zahl loeschen bst_delete(_, nil, nil). bst_delete(n, node(n,tl,nil), Tl). bst_delete(n, node(n,nil,tr), Tr). bst_delete(n, node(n,tl,tr), node(m,u,tr)) :- bst_delmax(tl, M, U). bst_delete(n, node(m,tl,tr), node(m,u,tr)) :- N < M, bst_delete(n, Tl, U). bst_delete(n, node(m,tl,tr), node(m,tl,u)) :- N > M, bst_delete(n, Tr, U). Folie 191 Repräsentation aussagenlogischer Formeln und Interpretationen 1. Ziel: al(term) soll besagen, dass Term eine aussagenlogische Formel repräsentiert. Ansatz: Die booleschen Konstanten 0 und 1 repräsentieren wir durch die booleschen Werte 0 und 1. Aussagensymbole (d.h. Aussagenvariablen) repräsentieren wir durch Atome (d.h. Zeichenketten, die mit einem Kleinbuchstaben beginnen oder in einfachen Anführungszeichen stehen). Die Junktoren,,, repräsentieren wir durch die Operatoren ~, /\, \/, =>. Wir wollen diese auf die übliche Art schreiben, d.h. wir wollen z.b. schreiben: Seite November 2014

3 statt (a /\ b) => ~c => ( /\ (a, b), ~(c) ) (wobei Letzteres die natürliche Term-Darstellung des Syntaxbaums der Formel ist). Dies erreichen wir in Prolog durch die folgende Definition von Operatoren: Folie 192 :- op(100, fy, ~). % Negation :- op(200, xfx, /\). % Konjunktion :- op(200, xfx, \/). % Disjunktion :- op(300, xfx, =>). % Implikation Generelles Schema von Operatordefinitionen in Prolog: :- op(x,y,z). mit X : Priorität des Operators (ganze Zahl zwischen 1 und 1200; je näher bei 1 desto höher die Priorität), Y : Spezifikation des Operators, Z : Name des Operators. Die Spezifikation fy gibt an, dass der Operator 1-stellig ist, von links an sein Argument geschrieben wird und assoziativ ist. Beispiel: ~ ~ ~ a steht für ~(~(~(a))) Die Spezifikation xfx gibt an, dass der Operator 2-stellig ist, zwischen seine beiden Argumente geschrieben wird und nicht assoziativ ist. Beispiel: ( (a /\ b) /\ c ) steht für /\ ( /\ (a,b), c ). ( a /\ b /\ c ) ist nicht erlaubt. Das 1. Ziel, eine Beschreibung al(term), die besagt, dass Term eine aussagenlogische Formel repräsentiert, wird durch die Zeilen 1 20 des unten stehenden Programms al.pl erreicht. Folie Ziel: Repräsentiere aussagenlogische Interpretationen durch eine geeignete Datenstruktur, die Zugriff auf die den einzelnen Aussagensymbolen zugeordneten Wahrheitswerte liefert. Dies wird durch die Zeilen des Programms al.pl erreicht. 26. November 2014 Seite 125

4 3. Ziel: al eval(i,f,wert) soll besagen, dass die Formel F unter Interpretation I den Wahrheitswert Wert hat. Dies wird durch die Zeilen des Programms al.pl erreicht. Programm 3.15: al.pl % aussagenlogische Junktoren :- op(100, fy, ~). % Negation :- op(200, xfx, /\). % Konjunktion :- op(200, xfx, \/). % Disjunktion :- op(300, xfx, =>). % Implikation % boolesche Konstanten 0 und 1 bool(0). bool(1). % Aussagensymbole werden durch Atome repraesentiert as(x) :- atom(x). % al(term) besagt: Term repraesentiert eine aussagenlogische Formel al(b) :- bool(b). al(x) :- as(x). al(~ F) :- al(f). al(f1 /\ F2) :- al(f1), al(f2). al(f1 \/ F2) :- al(f1), al(f2). al(f1 => F2) :- al(f1), al(f2). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Interpretationen % % repraesentiere z.b. Interpret. I mit I(a)=0, I(b)=1, I(c)=0 % durch Liste [ maps(a,0), maps(b,1), maps(c,0) ] % die Interpretation mit leerem Definitionsbereich al_interpret_init([]). % al_interpret_get(i,x,b) bedeutet: % B ist der Wahrheitswert von X gemaess Interpretation I al_interpret_get([maps(x,b) _], X, B). al_interpret_get([maps(x1,_) J], X, B) :- X1 \== X, al_interpret_get(j, X, B). % al_interpret_put(i,x,b,j) bedeutet: J entsteht aus I, indem das Seite November 2014

5 % Aussagensymbol X auf den Wahrheitswert B agbebildet wird al_interpret_put(i, X, B, [maps(x,b) I]). % al_list2interpret(l,i) besagt, dass die Interpretation I % gemaess der Liste L definiert ist. Bsp: L von der Form % [ X1, B1, X2, B2,...] besagt, dass % das Aussagensymbol Xi den Wert Bi bekommt al_list2interpret([], I) :- al_interpret_init(i). al_list2interpret([x,b L], I) :- al_list2interpret(l, J), al_interpret_put(j, X, B, I). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Auswertung von Formeln % % Ist I eine Interpretation, F eine aussagenlogische Formel und gilt % al_eval(i, F, Wert), so gibt Wert den Wahrheitswert von F % bzgl. der Interpretation I an al_eval(_, 0, 0). al_eval(_, 1, 1). al_eval(i, X, W) :- al_interpret_get(i, X, W). al_eval(i, ~ F, 0) :- al_eval(i, F, 1). al_eval(i, ~ F, 1) :- al_eval(i, F, 0). al_eval(i, F1 /\ _, 0) :- al_eval(i, F1, 0). al_eval(i, _ /\ F2, 0) :- al_eval(i, F2, 0). al_eval(i, F1 /\ F2, 1) :- al_eval(i, F1, 1), al_eval(i, F2, 1). al_eval(i, F1 \/ _, 1) :- al_eval(i, F1, 1). al_eval(i, _ \/ F2, 1) :- al_eval(i, F2, 1). al_eval(i, F1 \/ F2, 0) :- al_eval(i, F1, 0), al_eval(i, F2, 0). al_eval(i, F1 => _, 1) :- al_eval(i, F1, 0). al_eval(i, _ => F2, 1) :- al_eval(i, F2, 1). al_eval(i, F1 => F2, 0) :- al_eval(i, F1, 1), al_eval(i, F2, 0). Folie 194 Normalformen aussagenlogischer Formeln Ziele: al lit(x) soll testen, ob X ein aussagenlogisches Literal repräsentiert. al nnf(f) soll testen, ob F eine aussagenlogische Formel in Negationsnormalform repräsentiert. al clause(d) soll testen, ob D eine disjunktive Klausel repräsentiert. 26. November 2014 Seite 127

6 al cclause(c) soll testen, ob C eine konjunktive Klausel repräsentiert. al cnf(f) soll testen, ob F eine aussagenlogische Formel in konjunktiver Normalform repräsentiert. al dnf(f) soll testen, ob F eine aussagenlogische Formel in disjunktiver Normalform repräsentiert. al2nnf(f,g) soll eine gegebene Formel F in eine dazu äquivalente Formel G in Negationsnormalform transformieren. Programm 3.16: alnormalformen.pl :- ensure_loaded([al]). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Teste, ob eine Formel eine bestimmte Gestalt hat % % Literal al_lit(x) :- as(x). al_lit(~ X) :- as(x). % Negationsnormalform al_nnf(f) :- al_lit(f). al_nnf(f /\ G) :- al_nnf(f), al_nnf(g). al_nnf(f \/ G) :- al_nnf(f), al_nnf(g). % disjunktive Klausel al_emptyclause(0). al_clause(l) :- al_lit(l). al_clause(l \/ D) :- al_lit(l), al_clause(d). % Konjunktive Normalform al_cnf(f) :- al_clause(f). al_cnf(c /\ F) :- al_clause(c), al_cnf(f). % konjunktive Klausel al_emptycclause(1). al_cclause(l) :- al_lit(l). al_cclause(l /\ C) :- al_lit(l), al_cclause(c). % disjunktive Normalform Seite November 2014

7 al_dnf(f) :- al_cclause(f). al_dnf(c \/ F) :- al_cclause(c), al_dnf(f). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Transformation in NNF al2nnf(f,g) :- al2nnf(f,g,_). % al2nnf/3 gibt fuer eine Formel und ihr Negat aequivalente % Formeln in NNF. D.h.: al2nnf(f,g,h) bedeutet: % G ist NNF fuer F, und H ist NNF fuer ~F. % Konstruktion: analog zum Beweis von Satz 2.38 al2nnf(0,0,1). al2nnf(1,1,0). al2nnf(x, X, ~ X) :- as(x). al2nnf(~ X, ~ X, X) :- as(x). al2nnf(~ F, G, H) :- al2nnf(f, H, G). al2nnf(f1 /\ F2, G1 /\ G2, H1 \/ H2) :- al2nnf(f1,g1,h1), al2nnf(f2,g2,h2). al2nnf(f1 \/ F2, G1 \/ G2, H1 /\ H2) :- al2nnf(f1,g1,h1), al2nnf(f2,g2,h2). al2nnf(f1 => F2, H1 \/ G2, G1 /\ H2) :- al2nnf(f1,g1,h1), al2nnf(f2,g2,h2). 3.4 Operationelle Semantik Deklarative vs. Operationelle Semantik Folie 195 Die deklarative Semantik von Logikprogrammen beruht auf einer logischen Interpretation von Programmen (Regeln als Implikationen) und logischer Deduktion. Jetzt werden wir dieser deklarativen Semantik eine operationelle Semantik gegenüberstellen, indem wir einen Algorithmus angeben, der Programme ausführt (auf einem abstrakten, nichtdeterministischen Maschinenmodell). Dadurch legen wir ebenfalls die Antworten auf die Anfragen fest und weisen somit Programmen eine Bedeutung zu. Wir werden sehen, dass die deklarative Bedeutung von Programmen mit der operationellen übereinstimmt. 26. November 2014 Seite 129

8 Folie 196 Semantik von Programmiersprachen im Allgemeinen Generell unterscheidet man zwischen zwei Wegen, die Semantik von Programmiersprachen zu definieren: Die deklarative oder denotationelle Semantik ordnet Programmen Objekte in abstrakten mathematischen Räumen zu, in der Regel partielle Funktionen, oder im Fall von Logikprogrammen Mengen von Grundtermen. Zur Erinnerung: Die Bedeutung B(Π) eines Logik-Programms Π hatten wir definiert als die Menge aller Grundterme, die aus Π ableitbar sind. Die operationelle Semantik legt fest, wie Programme auf abstrakten Maschinenmodellen ausgeführt werden und bestimmt dadurch ihre Bedeutung. Folie 197 Notation PA := die Menge aller Atome PV := die Menge aller Variablen PK := die Menge aller Konstanten PT := die Menge aller Terme PF := die Menge aller Anfragen (d.h.: nicht-leere Listen von Termen) PR := die Menge aller Regeln PP := die Menge aller Logikprogramme Für jedes ξ aus PT PF PR PP bezeichnet Var(ξ) die Menge aller Variablen, die in ξ vorkommen. Ist S eine Substitution und α PF von der Form α 1,..., α m, so bezeichnet αs die Anfrage α 1 S,..., α m S. Entsprechend definieren wir für jede Regel ρ PR die Regel ρs. Seite November 2014

9 Beispiel. Ist ρ die Regel path(x,y) :- edge(x,z), path(z,y) dann ist Var(ρ) = {X, Y, Z}. Folie 198 Mehr über Substitutionen Zur Erinnerung: Eine Substitution ist eine partielle Abbildung S von PV nach PT. Den Definitionsbereich von S bezeichnen wir mit def(s), den Bildbereich mit bild(s). Die Verkettung zweier Substitutionen S und T ist die Substitution ST mit def(st ) = def(s) def(t ) und X(ST ) := (XS)T für alle X def(st ). Die Einschränkung einer Substitution S auf eine Menge V von Variablen ist die Substitution S V mit def(s V ) = def(s) V und XS V := XS für alle X def(s). Die leere Substitution bezeichnen wir mit I. Es gilt: θi = θ für alle θ PT, und IS = SI = S für alle Substitutionen S. Folie 199 Umbennungen Eine Umbenennung ist eine injektive partielle Abbildung von PV nach PV. Wegen PV PT, sind Umbenennungen spezielle Substitutionen. Eine Umbenennung für eine Menge V von Variablen ist eine Umbennung U mit def(u) = V. Ist U eine Umbennung, so bezeichnet U 1 ihre Umkehrung. Beispiel: U := {X Y, Y Z} ist eine Umbenennung für {X, Y}. U 1 = {Y X, Z Y} ist die Umkehrung von U. Folie November 2014 Seite 131