Standardparadigmen: Deklarative Sprachen

Teil 3
Standardparadigmen:
Deklarative Sprachen
● funktionales Programmieren: Lisp 1.5
● logisches Programmieren: Prolog
● relationales Programmieren: Datalog
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
1
Inhaltsübersicht HPS WS 2002/03
- Grundlagen (1,2,3)
- Konzepte imperativer Programmiersprachen (3,4)
- Deklarative Programmiersprachen (5,6)
- Objektorientierte Programmiersprachen (6,7)
- Wissenschaftliches Rechnen: Fortran (8)
- Formale Semantik
- Operationale Semantik mit ASMs (9)
- Operationale Semantik mit natürlicher Semantik und SOS (10)
- Denotationelle Semantik (11)
- Axiomatische Semantik (12)
- Skriptsprachen (13)
- Wirtschaftsanwendungen:
- Cobol (14)
- Abap/4 (15)
Lisp 1.5
Urform von Lisp (und aller funktionaler Sprachen)
● Datenstruktur: Listen (eigentlich Bäume), Atome
● keine Operationen auf Atomen außer Vergleich, Test
● Programme sind symbolische Ausdrücke S (S-Ausdrücke), repräsentiert als Listen
● Programme zur Laufzeit modifizierbar
·
Atom: Zeichenreihe z ∈ S, spezielle Zeichenreihe nil ∈ S,
Baum: x,y ∈ S: cons [x,y] = (x . y) ∈ S
x
·
x
Liste: [x1,x2,x3,...,xn] = (x1 x2 x3 ... xn ) = (x1 . (x2 . (x3 . (...(xn . nil)...) )))
·
y
1
leere Liste : [ ] = nil
x
·
Funktionen zur Manipulation von Listen und Atomen:
2
atom, eq, car, cdr, cons
x
···
Grundoperationen:
3
·
●
[[lambda ,x], y] = ((lambda x) y) entspricht λx .y
Currying als abkürzende Schreibweise: λx .(λy.z)=λxy.z
xn
●
(quote x) = 'x entspricht Zeichenreihe x (nicht der Term x!)
●
(label n x) entspricht n = x
■
( cond (x1,y1), (x2,y2),..., (xn,yn)) entspricht if x1≠nil then y1 else (cond (x2,y2),...,(xn,yn))
●
Interpretierer eval berechnet symbolische Ausdrücke durch α-, β-, η−Konversion
Literatur:
● John McCarthy: Comm. of the ACM 3(1960), Nr. 4, 184-195
● McCarthy et al.: Lisp 1.5 Programmer's Manual. MIT Press 1965
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
3
nil
Grundfunktionen
t bezeichnet beliebigen Wert ≠ nil (nil= falsch, t= wahr)
atom: S → BOOL
atom [(x . y)]= nil
● atom [X] = t
eq: Atom × Atom → BOOL
eq [X,Y] = nil
● eq [X,X] = t
car: S → S
● car [(x . y)] = x
cdr: S → S
● cdr [(x . y)] = y
cons: S × S → S
● cons[x,y] = (x . y)
Alle nicht angegebenen Fälle liefern nil, insbesondere eq angewandt auf Listen
Lisp 1 war die erste verbreitete Sprache mit automatischer Speicherbereinigung!
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
4
heutige LISP Dialekte
●
Common LISP: mächtige Sprache für größere Anwendungen
G. L. Steele (ed.): Common Lisp: The Language. Second Edition.
Digital Press, 1990
●
Scheme: Standard-Programmiersprache an vielen amerikanischen Universitäten
H. Abelson, G. J. Sussman, J. Sussman: Struktur und Interpretation
von Computerprogrammen. Springer-Verlag, 3. Aufl. 1998
●
Emacs-LISP: Sprache zur Programmierung des Emacs-Systems
●
Liste mit freien Lisp-Implementierungen:
http://www-2.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/lisp/impl/0.html
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
5
Emacs Lisp
LaTeX-Filter
(find-file (getenv "INFILE"))
(replace-string "
" "|NeueZeile|" nil)
(beginning-of-buffer)
(replace-string "|NeueZeile| |NeueZeile|" "|Absatz|" nil)
(beginning-of-buffer)
(replace-regexp "\\\\cite{[^#]*}" "" nil) (beginning-of-buffer)
...
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
6
Emacs Lisp
Türme von Hanoi
(defun hanoi (n von nach zwischen)
(cond
( (= n 1) (move von nach) )
( (> n 1)
(hanoi (n-1) von zwischen nach)
(move von nach)
(hanoi (n-1) zwischen nach von)
)
)
(defun show-move (von nach) ... )
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
7
Der Sündenfall: Zuweisungen in Lisp
Alle heutigen Versionen von Lisp (Emacs Lisp, Scheme, Common Lisp, ...)
erlauben Zuweisungen:
Variablenvereinbarung (in Emacs Lisp):
(defvar variable)
oder
(defvar variable anfangswert)
oder
(defvar variable anfangswert ''Dokumentation'')
Zuweisung:
(setq variable wert)
Bedeutung: variable zeigt auf wert (keine Kopie!)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
8
Grundprinzipien funktionaler
Sprachen
●
●
●
●
●
●
●
●
●
●
Berechnungsmodell: Reduktion von Ausdrücken wie in Lisp
Programm ist Folge von Funktionsdefinitionen und ein Ausdruck
Schreibweise angelehnt an übliche mathematische Schreibweisen
Programm und Daten getrennt
Grundtypen: Listen, Terme, übliche Grundtypen (Bool, Int, ...);
darauf aufbauend reichhaltiger Typverband
starke Typisierung, Verwendung von Typinferenz
mehrere Definitionen des gleichen Funktionsbezeichners möglich,
Auswahl der Funktionsdefinition bei Anwendung durch
Typinferenz und Durchmustern der Parameterlisten, um die erste
auf die Argumente zutreffende Definition zu finden: Durchmustern
in der Reihenfolge des Aufschreibens
zentraler Unterschied zwischen Sprachen: strikte (ML) und
faule (Haskell, Gofer) Auswertung von Argumenten
unterschiedlich gestaltete Modulkonzepte
parametrische Polymorphie
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
9
ML, Haskell und Gofer
Die meisten funktionalen Sprachen (außer Lisp) haben im Kern identische Syntax
Türme von
Hanoi
move 1 i j k = i ++
move n i j k =
(move (n-1) i
i ++ "-->" ++
(move (n-1) j
"-->" ++ k ++ "\n"
k j) ++
k ++ "\n"
i k)
++
hanoi 0 = "Ja Ja!"
hanoi n = move n "A" "B" "C"
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
10
Addition von Binärzahlen mit Listen
Integer
addr xs [] [] = xs
addr [] ys [] = ys
addr xs [] "1" = addr xs "1" []
addr [] ys "1" = addr ys "1" []
addr ('0':xs) ('0':ys) []=
concat ["0", (addr xs ys [])]
addr ('0':xs) ('1':ys) []=
concat ["1", (addr xs ys [])]
...
addr ('1':xs) ('1':ys) "1" =
concat ["1", (addr xs ys "1")]
add x y =
reverse (addr(reverse x)(reverse y)[])
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
11
Boolesche Funktionen
Boolean
wahr t f = t
falsch t f = f
if-then-else b t f = b t f
und a b = if-then-else a
(if-then-else b wahr falsch)
falsch
oder a b = if-then-else a
wahr
(if-then-else b wahr falsch)
nicht a = if-then-else a falsch wahr
xoder a b = if-then-else a
(if-then-else b falsch wahr)
(if-then-else b wahr falsch)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
12
Addition von Binärzahlen mit
Funktionen höherer Ordnung
Integer
bit '0' = falsch bit '1' = wahr
tib a = if-then-else a '1' '0'
plus x y z = xoder (xoder x y) z
ueber x y z = oder(und x z)(oder(und x y)(und y z))
addr xs [] '0' = xs
...
addr [] ys '1' = addr ys "1" '0'
addr (x:xs) (y:ys) z = concat [
[(tib(plus (bit x)(bit y)(bit z)))],
(addr xs ys (tib(ueber(bit x)(bit y)(bit z))))]
add x y=reverse(addr(reverse x)(reverse y)'0')
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
13
Anwendung Funktionen höherer
Ordnung
Faltung
Linksfaltung ( f , x , ( y1 , y2 , ... , yn-1 , yn,) ) =
f ( f ( ... f ( f ( x , y1 ) , y2 ) ... ) , yn-1) , yn)
foldl f x [] = x
foldl f x (y:ys) = foldl f (f x y) ys
sum = foldl (+) 0
product = foldl ( ) 1
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
14
Abstrakte Datentypen
Konstruktoren:
● data X = Konstr_1 | ... | Konstr_n
Operationen:
● op_1:: X-> Typ_1_1->...-> Typ_1_k
...
op_m:: X-> Typ_m_1->...-> Typ_m_l
Axiome:
● op_1 = ... op_m = ...
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
15
ADT Keller
data IntKeller =
EmptyStack |
Push (Int, IntKeller)
isEmpty :: IntKeller -> Bool
top :: IntKeller -> Int
pop :: IntKeller -> IntKeller
isEmpty EmptyStack = True
isEmpty Push (Int, s) = False
top Push (i s) = i
pop Push (i s) = s
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
16
Polymorphie
Parametrische Polymorphie
data Stack t = EmptyStack
Push (t, Stack t)
istLeer :: Stack t -> Bool
top :: Stack t -> t
pop :: Stack t -> Stack t
isEmpty EmptyStack = True
isEmpty Push (i, s) = False
top Push (i s) = i
pop Push (i s) = s
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
17
Typisierung
Einsetzen eines Typs in die Typvariable ergibt neuen Typ
Muß konsistent sein
Achtung: Konstruktorterme können nicht weiter ausgewertet werden!
Also sind sie keine Ausdrücke aus imperativen Sprachen, sondern Terme.
Typ Stack Int:
Push ( 1 Push ( 2 Push ( 3 Empty )))
Typ - Fehler:
Push ( 1 Push ( True Push ( 3 Empty )))
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
18
Prolog
Prolog
entworfen von Alain Colmerauer (Marseille) ~1970
Grundlage: Horn-Logik und Resolutionskalkül (J. Alan Robinson, Robert Kowalski)
W. F. Clocksin, C. S. Mellish: Programming in Prolog. Springer Verlag
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
19
Entscheidbarkeit
Unentscheidbar:
● Gültigkeit prädikatenlogischer Formeln
● Erfüllbarkeit prädikatenlogischer Formeln
Semi-entscheidbar (berechenbar):
● Unerfüllbarkeit prädikatenlogischer Formeln
● Algorithmus terminiert, wenn Formel nicht erfüllbar
● Resolution, Substitution und Unifikation
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
20
Grundbegriffe
Klausel: K = ∀x1, ... , xn K*
K* = P1 ∨ P2 ∨ ... ∨ Pm, Pi ist Literal ,
d.h. elementares Prädikat (Atom) Pi = Li(x1,..., xn) oder negiertes Atom
Schreibweise: Allquantor ∀x1, ... , xn weglassen, wird stillschweigend angenommen
Eine Klausel heißt eine Horn-Klausel,
wenn alle Atome negiert sind bis auf höchstens eines:
¬ L1 ∨ ¬ L2 ∨ ... ∨ ¬ Lm ∨ Q, Q kann fehlen, also
L1 ∧ L2 ∧ ... ∧ Lm → Q (Implikation)
Prolog-Schreibweise:
Implikation: Q(...) :- L1(...), L2(...), ... , Ln(...).
Faktum: Q(...).
Anfrage: ?- A(...).
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
21
Grundidee logischen Programmierens
Idee: Wenn ¬ A(x1,..., xn) nicht erfüllbar ist, gibt es ein Gegenbeispiel,
d.h. eine Belegung der Variablen xi mit Termen ti so,
daß A(t1,..., tn) = ¬ ¬ A(t1,..., tn) wahr ist
Ein Gegenbeispiel wird in endlich vielen Schritten gefunden,
wenn ¬ A(x1,..., xn) nicht erfüllbar. (Grund: Nichterfüllbarkeit ist berechenbar)
Aber: Im umgekehrten Fall (Nicht-Terminierung, ¬ A(x1,..., xn) erfüllbar) kann man
das Fehlschlagen des Beweisversuchs nicht von der Negation unterscheiden!
(negation by failure)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
22
Beispiel: symbolisches
Differenzieren
|:
|:
|:
|:
|:
diff(X,1,X).
diff(Y,0,_) :- atom(Y).
diff(Y+Z,Dy+Dz,X) :- diff(Y,Dy,X), diff(Z,Dz,X).
diff(Y*Z,Dy*Z+Y*Dz,X) :- diff(Y,Dy,X), diff(Z,Dz,X).
% user compiled 0.02 sec, 888 bytes
Yes
?- diff(a*X+b, D, x).
X = x
D = 0*x+a*1+0
Yes
?- diff(X*X, D, x).
X = x
D = 1*x+x*1
Yes
?- diff(a*X-b, D, x).
No
?Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
23
Grundresolution
Klauseln K: disjunktiv verknüpfte Literale
F = ∀x1, ... , xn F*
F* = K1 ∧ K2 ∧ ... ∧ Kn
Ki = P1 ∨ P2 ∨ ... ∨ Pm
F ist unerfüllbar gdw. K1 , K2 , ... , Kt mit
■
Kt ist leere Klausel
Ki< t Grundinstanz
K ∈ F*, Ki = K[x1/t1][x2/t2] ...[xn/tn] | t1, ... ,tn ∈ D(F)
●
Ki<t aussagenlogische Resolvente von Ka<i , Kb<i
●
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
24
Problem
Grundsubstitution nicht vorausschauend
Gierig und daher ineffizient
Minimale Substitution für Resolutionsschritt
● Allgemeiner Unifikator
● Prädikatenlogische Resolution
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
25
Allgemeinster Unifikator
Substitution s ist Unifikator einer Menge L von Literalen { L1, L2, ... ,Lk } wenn
L1s = L2s = ... = Lks
Allgemeinster Unifikator s falls sub = s sub´
s
sub'
sub
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
26
Unifikation
Eingabe L
s:=[]
while |Ls| > 1 do
Finde in Ls Literale L1, L2 die unterschiedlich in Zeichen x, y
if keine Variablen x, y then Ausgabe „Nicht unifizierbar“
else Sei x Variable und y beliebiger Term
if x kommt vor in y then Ausgabe „Nicht unifizierbar“
else s:=s[x/y]
od
Ausgabe s
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
27
Prolog
Hornklauselprogramme
● Tatsachen: T(...).
● Prozedur: P(...) :- Q1 (...), Q2 (...), ... , Qn(...).
● Ziel: ?- Q1 (...), Q2 (...), ... , Qn(...).
Ergebnis eindeutig?
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
28
Beispiel
(1)
(2)
(3)
Frage
Q(X,Z):-Q(Y,Z),R(X,Y).
Q(X,X).
R(b,c).
?-Q(X,c)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
29
Mögliche SLD Resolutionen
?-Q(x,c)
(2)
(1)
?-Q(y,c),R(x,y)
Q(c,c)
(2)
(1)
?-Q(y,c),R(v,x),R(x,y)
?-R(x,c)
●
(1)
(2)
(3)
?-R(v,x),R(x,c)
Q(b,c)
(3)
?-R(c,c)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
30
Auswertestrategie
Deterministisch
Tiefensuche
● Nicht vollständig
● Endlosschleifen möglich
● Breitensuche vollständig
„occur check“ ?
Prozedurale Auswertung
Ausgabe weiterer Lösungen
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
31
Cut
Beispiel Hilfs-not Operator
not(X) :- X, !, fail.
not(_).
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
32
Türme von Hanoi
:- use_module(library(lineio)).
hanoi(N):- N >=0, move(N,"A","B","C").
move(0,_,_,_) :- !.
move(1,A,B,_) :put_chars(A),put_chars(" -> "),
put_chars(B), nl, !.
move(N,A,B,C) :- NN is N-1,
move(NN,A,C,B),
move(1,A,B,C),
move(NN,C,B,A).
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
33
Arithmetik Operatoren
pow(1,_,1).
pow(_,0,1).
pow(B,E,X):-is(EE,E-1),
pow(B,EE,Y),mul(B,Y,X).
mul(_,0,0):- !.
mul(0,_,0).
mul(A,B,X):- A < 0,is(AA,-A),
mul(AA,B,Y), is(X,-Y).
mul(A,B,X):- A > 0,is(AA,A-1),
mul(AA,B,Y), is(X,B+Y).
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
34
Flieger
:- assert(fz(Fliege)).
flugzeug(F):- fz(F).
flugzeug(F):put_chars("Ist ein(e)"),write(F),put_chars("ein Flugzeug?"),
get_line(L), L=="j",assert(fz(F)).
flugzeuge(FS):- findall(F,fz(F),FS).
flugzeuge:-flugzeuge(FL),zeige_fz(FL).
zeige_fz([]):- put_line("gibt keine!"), !.
zeige_fz([F]):- put_chars("Ein(e) "),
write(F), put_line("ist ein Flugzeug"),!.
zeige_fz([F FS]):-zeige_fz([F]),zeige_fz(FS).
● ?- flugzeuge.
Ein(e) fliege ist ein Flugzeug
yes
● ?- flugzeug(Maus).
Ist ein(e) Maus ein Flugzeug? j
yes
● ?- flugzeuge.
Ein(e) Fliege ist ein Flugzeug!
Ein(e) Maus ist ein Flugzeug!
yes
● ?- flugzeuge(L).
LGerhard
= [Fliege,Maus
] Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
Prof. Dr.
Goos, Dr. Sabine Glesner
35
Datalog
Datalog: Brücke
logisches Programmieren - relationale Algebra
J. D. Ullman: Principles of Database and Knowledge-Base Systems.
Bd. I, Kap. 3 und Bd. II. Computer Science Press 1988
S. Ceri, G. Gotlob, L. Tanca: Logic Programming and Databases, Springer-Verlag, 1990
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
36
Datalog
Einsicht:
● Fakten p(t1,...,tn) definieren Relation p (im Sinne relationaler Algebra)
●
Voraussetzung: für ti nur Konstante oder Variable erlaubt, also nicht f(t'1,...,t'n)
Klauseln q(...) :- q1(...),...,qm(...) definieren Implikation zwischen Relationen
●
●
●
Fakten definieren extentionale Datenbasis (EDB)
Implikationen definieren Sichten (intentionale Datenbasis, IDB)
Datalog: die Sprache deduktiver Datenbanken: wie Prolog, aber mit Einschränkungen:
● EDB und IDB definieren disjunkte Relationen EDB ∩ IDB = ∅
● Keine Funktionssymbole, nur Variable und Konstante als Argumente in Prädikaten
● Hornklausel ist logische Beziehung, keine implizite Ablaufsteuerung wie in Prolog
● alle Klauseln sind sicher:
Sichere Klausel: All-Quantifizierung der Variablen begrenzt auf Konstante in Fakten:
● Variable X heißt begrenzt, wenn sie vorkommt in:
●
benutzerdefiniertem Faktum oder in Form X=a, a konstant,
●
Form X=Y und Y ist begrenzt.
Datalog kann wesentlich effizienter verarbeitet werden als Prolog
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
37
Beispiele unbegrenzter Variabler
größer als(X,Y) :- X>Y.
vater(A,B) :- mann(A) .
X,Y unbegrenzt, da ,,X>Y`` eingebaut, nicht benutzerdefiniert.
A begrenzt, B unbegrenzt.
Intuitive Idee: Aussagen können nur aus Fakten abgeleitet werden und
sich nur auf Terme (Variable/Konstante) beziehen,
die dort vorkommen; daher Beschränkung auf sichere Fakten.
● sichere Fakten ohne Funktionssymbole: relationale Algebra
● zusätzliche Implikationsklauseln: deduktive Datenbanken
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
38
Wiederholung relationale Algebra
gegeben: Relationen
R(A,B,C) = { (a,b,c), (d,a,f), (c,b,d) }
S(A,B,D) = { (d,a,g), (d,a,c), (c,b,g) }
● Projektion:
π A,B (R) = { (a,b), (d,a), (c,b) }
● Selektion:
σ B=b (R) = { (a,b,c), (c,b,d) }
● natürlicher Verbund (join):
>< (R , S) = R >< S = { (d,a,f,g), (d,a,f,c), (c,b,d,g) }
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
39
Reduktion Datalog → relationale Algebra
Nichtrekursive Klauseln
nicht-rekursiv: Implikation q(...) :- q1(...),...,qm(...) hängt weder direkt noch
indirekt von q(...) ab
●
Implikationen qj(...) :- ..., qi(...), ... können so angeordnet werden, daß i < j
●
Konjunktion des Rumpfs ..., qi(...), ... bildet eine Relation r(...),
nämlich den natürlichen Verbund q1(...) >< ... >< qm(...) des Rumpfs
●
Argumente: die im Rumpf vorkommenden Variablen
Wegen Anordnung ist r ohne Rückgriff auf Kopf qj(...) berechenbar
●
Wegen Begrenztheit kommen alle Variablen X in qj(...,X,...) auch in r vor
●
also: Kopf qj(...) ist Relation seiner Variablen und ergibt sich durch Projektion
●
des Rumpfs r auf diese Variablen
bei mehreren Rümpfen zum gleichen Kopf:
Vereinigung, d.h. Disjunktion der Rümpfe bilden
●
Einsicht: nicht-rekursive Implikation ist zusammengesetzte
Operation der Relationenalgebra
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
40
Elimination
Umbenennen von Variablen
zusätzliche Literale
● X=Y für gleiche Variablen oder
● X=c für Konstanten.
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
41
2 Relation der Rümpfe
●
gegeben: Klauseln q1, ... , qm
●
natürlichen Verbund der qi
●
Selektion besonderer Prädikate
●
Vergleichsoperationen für Selektion definiert
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
42
3 Relation der Köpfe
●
●
Projektion entsprechend der Variablen im Kopf
Vereinigung der Relationen der Rümpfe: Berechne die Relation für jeden Kopf
wie bei nichtrekursiven Klauseln
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
43
Beispiel
geschwister(X,Y):eltern(X,Z)& eltern(Y,Z)& X/=Y.
vetter(X,Y):eltern(X,Z)& eltern(Y,Z')&
geschwister(Z,Z').
G(X,Y) := πX,Y(σ X¹Y(E(X,Z) >< E(Y,Z)))
V(X,Y) := πX,Y(E(X,Z) >< E(Y,Z) >< G(Z,Z))
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
44
Rekursive Klauseln
Ersetze :- durch =, d.h. jede Implikation setzt sich selbst voraus
● bedenke:
●
rekursive Implikation q(...) :- q1(...),...,qm(...) nur sinnvoll,
wenn es wenigstens eine nicht-rekursive Implikation für das gleiche q(...) gibt
●
daher erfüllt die Lösung des nicht-rekursiven Falls die Gleichung
●
alle weitere Lösungen sind umfangreicher: Halbordnung durch Mengeninklusion
● Gesamtlösung ist minimaler Fixpunkt des Gleichungssystems
● Gesamtlösung durch Iteration berechenbar
(gleiche Methodik wie bei iterativer Lösung von Datenflußgleichungen)
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
45
Beispiel (fortgesetzt)
...
vetter(X,Y):eltern(X,Z)& eltern(Y,Z')& geschwister(Z,Z').
vetter(X,Y):eltern(X,Z)& eltern(Y,Z')& vettern(Z,Z').
V (X,Y) = πX,Y (E (X,Z) >< E (Y,Z) >< G (Z,Z)) ∪
πX,Y (E (X,Z) >< E (Y,Z) >< V (Z,Z))
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
46
Auswertung durch Induktion
Anfang:
●
Initialisiere linke Seiten
●
extensional gegebener Relationen wie definiert
●
intensional gegebener Relationen mit Ø.
● Schritt:
●
Brechne rechte Seiten wie bei nichtrekursiven Relationen
● Wiederhole bis intensionale Relationen fix
● Wohldefiniert weil:
●
Regeln sicher
●
Operationen ( >< , ∪ , ... ) monoton bzgl. ⊆
●
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
47
Negation
Negation, d.h. Übergang zum Mengenkomplement der Relationen
in Datalog nicht erlaubt, da dann minimaler Fixpunkt nicht
eindeutig:
(1) r(1).
(2) p(X) :- r(X) & q(X)
(3) q(X) :- r(X) & p(X)
P=R-Q Q=R-P
(S1)
(S2)
P = ØQ = {1}
P = {1}
Q= Ø
Minimaler Fixpunkt nicht eindeutig trotz geschlossener Welt.
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
48
Einschränkung des Verbots der
Negation
●
●
●
Geschichtete (stratified) Negationen in sicheren Regeln
Kopf P und negiertes Literal ¬S im Rumpf,
dann keine transitive Abhängigkeit von P und positivem Literal S.
Minimaler Fixpunkt dann eindeutig.
Prof. Dr. Gerhard Goos, Dr. Sabine Glesner
Höhere Programmiersprachen WS 2002/03 (3. Foliensatz: Deklaraktive Sprachen)
49