(ft (child john mary) ann)

Harold Boley
RELFUN-Einführung, 1997
Die
hochintegrierte
relational/funktionale
KI-Sprache
RELFUN
Harold Boley
FB Informatik
Univ. Kaiserslautern
Oktober 1988
(Überarbeitet: Sept. 1997)
1
Harold Boley
RELFUN-Einführung, 1997
Motivation
◊
Wissensdarstellung und -verarbeitung
auf einer gleichzeitig
relationalen (logischen)
und
funktionalen (applikativen)
Grundlage fundieren
◊
Konzepte und Entwicklungen zu einem
gemeinsamen Nachfolger von
PROLOG und LISP als
Programmiersprache mit
eingebauter Repräsentationssprache
(bewerteten Hornklauseln):
KI-Anwendungen sowie
Grundlage für weitere Sprachen und Tools
2
Harold Boley
◊
RELFUN-Einführung, 1997
Querbeziehungen zwischen
relational/funktionalen Sprachen
niedriger (LISPLOG)
mittlerer (SASLOG)
hoher (FIT, RELFUN)
Integrationsdichte herstellen:
Know-how übertragen
(Implementation bis Anwendung)
Günstigste herausfinden
(lokal oder global)
◊
Exploration von
bewerteten Horn-Klauseln
als Integrationskonzept:
Aus PROLOG-Sicht:
Neben der
Bindung von (Relations-) Variablen:
Rückgabe von (Funktions-) Werten
Aus LISP-Sicht:
Neben der
Rückgabe von (Funktions-) Werten:
Bindung von (Relations-) Variablen
3
Harold Boley
RELFUN-Einführung, 1997
4
Verbindung der Vorteile relationaler und
funktionaler
Programmierung
Vorteile relationaler Programmierung (PROLOG):
R1 Da Relations-Aufrufe Anfragevariablen
binden, lassen sich Ein- und Ausgabe
oft invertieren
R2 "Non-ground"-Operationen sind erlaubt
(Patterns als Ein- und/oder Ausgabe von Operationen)
Vorteile funktionaler Programmierung (LISP):
F1 Da Funktions-Aufrufe Werte zurückgeben,
lassen sich geschachtelte Aufrufe
schreiben
F2 Operationen höherer Ordnung sind erlaubt
(Operatoren als Ein- und/oder Ausgabe von
Operationen)
Kombination der Vorteile (RELFUN):
R2, F1 voll;
R1 (bei Funktionen mit is), F2 (keine lambda-Ausdrücke) weitgehend
Harold Boley
RELFUN-Einführung, 1997
REL∫FUN-Integration von
Definitionen sowie Aufrufen
funktional
funktional
funktional
∫ KI-Sprache = ∫ Op-Definitionen + ∫ Op-Aufrufe
relational
relational
relational
Definitionen und Aufrufe von Operatoren
(Relationen und Funktionen) integrieren
Definitionen:
Bewertete Horn-Klauseln für Relations-Definitionen:
Nur Wahrheitswert-Definitionen (spezieller Fall)
Bewertete Horn-Klauseln für Funktions-Definitionen:
Beliebige Werte-Definitionen (allgemeiner Fall)
Aufrufe:
Bewertete Goals [Ziele] für Relations-Aufrufe:
Beliebige Argumente vorgebbar (allgemeiner Fall)
Bewertete Goals [Ziele] für Funktions-Aufrufe:
Eingabeargumente vorgebbar (spezieller Fall)
5
Harold Boley
RELFUN-Einführung, 1997
6
Bewertete Konjunktionen
berechnen einen Rückgabewert
Ausgangsentscheidung:
Wenn einzelner Operator-Aufruf neben Bindungseffekt
auch Rückgabewert liefert, dann soll
ganze
Aufruf-Konjunktion neben konsistent erweiterten
Bindungen (vgl. PROLOG) den Wert des letzten Konjunkts
(vgl. LISP) liefern
Allg.: call1 ... callN-1 callN
N=3: (is _x (gen duck)) (likes _y _x) `(marry _x _y)
Falls (likes aswan aduckling) u. (gen duck) = aduckling bekannt
ist, wird die Beispiel-Konjunktion so ausgewertet
(links-rechts):
(is _x (gen duck)) (likes _y _x) `(marry _x _y)
(is _x aduckling) (likes _y _x) `(marry _x _y)
(likes _y _x) `(marry _x _y) mit _x = aduckling
`(marry _x _y) mit _x = aduckling und _y = aswan
(marry aduckling aswan)
_x = aduckling, _y = aswan
Harold Boley
RELFUN-Einführung, 1997
7
Nachteil dieser Festlegung:
◊ Werte von call1 bis callN-1 werden (anders
als ihre Bindungs-Effekte) nicht weiterbenutzt,
d.h.
nur
als
Wahrheitswerte
interpretiert
Vorteile dieser Festlegung:
◊ Einfache
Ermittlung
Konjunktionswerts
◊ Verwandtschaft
mit
PROGN bzw. AND
◊ Eine spezielle Konjunktion
eines
solchen
LISPs
implizitem
(is _x1 expr1) ... (is _xN-1 exprN-1) (op _x1 ... _xN-1)
entspricht einem impliziten LET
(let ((_x1 expr1) ... (_xN-1 exprN-1))
(op _x1 ... _xN-1))
◊
mit
dem
Wert-Konjunkt
(op
als
Rumpf
und
den
als lokalen Bindungslieferanten
Verwendbar
für
bewertete
(s.u.)
_x1
...
_xN-1)
is-Konjunkten
Horn-Regeln
Harold Boley
RELFUN-Einführung, 1997
8
Bewertete Horn-Klauseln
berechnen einen Rückgabewert
Bewertete Horn-Klauseln ::= ft-Regeln | hn-Fakten
ft-Regeln haben die Form
Allg.: (ft pattern call1 ... callN-1 callN)
N=3: (ft (duckmarry _y)
(is _x (gen duck))
(likes _y _x)
`(marry _x _y))
wobei N>0 und
Allg.: call1 ... callN-1 callN
N=3: (is _x (gen duck)) (likes _y _x) `(marry _x _y)
eine bewertete Konjunktion von Prämissen ist (s.o.)
Falls
aduckling-Fakt u. -Gleichung bekannt
(duckmarry _r)
(is _x (gen duck)) (likes _y _x) `(marry _x _y) mit _r = _y
... s.o. ...
(marry aduckling aswan)
_r = (_y =) aswan
(_x-Bindung ist lokal zu Prämissen)
(s.o.):
Harold Boley
RELFUN-Einführung, 1997
9
ft-Regeln
verallgemeinern
sowohl
PROLOGs
unbewertete Horn-Regeln
pattern :- call1, ..., callN-1, callN.
als auch bedingte Termersetzungs-Regeln
pattern -> callN if call1 and ... and callN-1
da "Effekt-Konjunkte" call1 bis callN-1 nicht nur
beliebige (sogar non-deterministische) Bedingungen,
sondern gleichzeitig auch Bindungslieferanten sein
können, die partielle Resultate zur Verwendung im
"Effekt&Wert-Konjunkt" callN akkumulieren
ft-Regeln mit einer Prämisse (d.h. N=1) haben die Form
Allg.: (ft pattern call1)
Z.B.:
(ft (gen duck) aduckling)
d.h. entsprechen unbedingten TermersetzungsRegeln
pattern -> call1
Harold Boley
RELFUN-Einführung, 1997
10
hn-Fakten haben die Form
Allg.: (hn pattern)
Z.B.:
(hn (likes aswan aduckling))
entsprechend PROLOGs Horn-Klauseln mit leerer
Konjunktion von Prämissen, d.h. mit N=0. Sie liefern
aber ebenfalls einen Wert, true, d.h. sind äquivalent zu
ft-Regeln mit einer true-Prämisse
Allg.: (ft pattern true)
Z.B.:
(ft (likes aswan aduckling) true)
Harold Boley
RELFUN-Einführung, 1997
Der Instantiierungs-Operator "`"
LISP:
Backquote als Benutzer-Konstrukt
"`" extern verwendet, aber nicht
rekursiv in den generierten
Variablen-Werten fortgesetzt
PROLOG: Instantiierung nur als SystemKonstrukt zum Bindungsausdruck
intern verwendet, aber dafür
rekursiv in den generierten
Variablen-Werten fortgesetzt
RELFUN: Backquote als Benutzer-Konstrukt
"`" extern verwendet, zusätzlich
Instantiierung auch als SystemKonstrukt (Wert- und Bindungsausdruck)
intern verwendet, und beides
rekursiv in den generierten
Variablen-Werten fortgesetzt
11
Harold Boley
RELFUN-Einführung, 1997
RELFUN-Instantiierungs-Beispiele:
Ohne rekursive Fortsetzung (in _x = (a b) keine Variable):
(is _x `(a b)) `(1 _x 2 _x)
(1 (a b) 2 (a b))
_x = (a b)
Mit rekursiver Fortsetzung in _y = (1 _x 2 _x):
(is _x `(a b)) (is _y `(1 _x 2 _x)) `(_y (m _x _y n) _y)
((1 (a b) 2 (a b)) (m (a b) (1 (a b) 2 (a b)) n) (1 (a b) 2 (a b)))
_x = (a b)
_y = (1 (a b) 2 (a b))
Analogie von ungeschachteltem
"aktivem" (tup ...) und "passivem" `(...):
"Aktives" mittels "passivem" tup definierbar (RELFUN-Prelude):
(ft (tup | _r) `(tup | _r)) ; LISP-S-Expr. (a b . v) in RELFUN (tup a b | _v)
Geschachtelt: (tup (+ 2 3) (tup 7 (1- 9)) 1) liefert (tup 5 (tup 7 8) 1)
Ungeschachtelt: (is _x aduckling) (is _y aswan) (tup marry _x _y)
(tup marry aduckling aswan)
_x = aduckling
_y = aswan
(is _x aduckling) (is _y aswan) `(marry _x _y)
(marry aduckling aswan)
_x = aduckling
_y = aswan
12
Harold Boley
RELFUN-Einführung, 1997
13
Bewertete Resolution
Die Resolution eines RELFUN-Ziels
goal
mit einer ft-Regel (N>0)
(ft pattern call1 ... callN-1 callN)
liefert
außer
etwaigen
Bindungen
der
goal/pattern-Unifikation zunächst einmal die bewertete
Konjunktion
call1 ... callN-1 callN
und damit dann den Wert von
callN (letztlich Konstante, Variable, oder "`"-Aufruf)
in der durch call1 ... callN-1 geschaffenen Umgebung
Die
Resolution
des Ziels goal
hn-Fakt (N=0)
(hn pattern)
liefert leere Konjunktion, d.h. konst. Wert
true
mit
einem
Harold Boley
RELFUN-Einführung, 1997
Datenbank bewerteter Horn-Klauseln:
(hn (likes john mary))
(ft (older john mary) `(years 3))
(ft (child john mary) ann)
(ft (child john mary) bob)
; QUOTE-artige "`"-Verwendung
Relations-Aufruf (PROLOG-artiges Goal):
(likes john _x)
wert-resolviert mit Fakt (hn (likes john mary))
mit Wert true und Bindung _x = mary
Funktions-Aufruf (Goal mit allgem. Wert):
(older john _x)
wert-resolviert mit Regel (ft (older john mary) `(years 3))
mit Wert (years 3) und Bindung _x = mary
Non-deterministischer Funktions-Aufruf:
(child john _x)
wert-resolviert mit Regel (ft (child john mary) ann)
mit Wert ann und Bindung _x = mary
und bei Backtracking
wert-resolviert mit Regel (ft (child john mary) bob)
mit Wert bob und Bindung _x = mary
14
Harold Boley
RELFUN-Einführung, 1997
15
RELFUNs is-Terme
Verallgemeinerung
und
PROLOGs is-Primitiv:
Vereinheitlichung
von
◊
Wie
in
vielen
LISP/PROLOGKombinationen
kann
in
RELFUN
die
rechte
is-Seite
eine
beliebige
OperatorAnwendung
sein,
nicht
nur
wie
in
PROLOG eine arithmetische
◊
Aber
werden
Evaluator
sondern
selbst
diese
nicht
(z.B.
durch
Operator-Anwendungen
durch
einen
anderen
LISPs
EVAL)
berechnet,
den
RELFUN-Evaluator
Mit (ft (older john mary) `(years 3)) evaluiert z.B. (is _x
(older john mary))
zu (is _x `(years 3))
und bindet _x an older-Wert (years 3)
Harold Boley
Bewertete
is-Terme
RELFUN-Einführung, 1997
Resolution
16
erweitert
auf
Bewertete Resolution des RELFUN-Ziels
goal
auf der rechten Seite eines is-Terms
(is ispattern goal)
mit einer bewerteten Horn-Klausel
(ft pattern call1 ... callN-1 callN)
bzw.
(hn pattern)
und nach deren Erfolg Unifikation (oft nur einfache
Bindung) der linken Seite
ispattern
des is-Terms mit dem Wert des Ziels, d.h. dem Wert
von
callN
bzw.
true
Harold Boley
RELFUN-Einführung, 1997
Datenbank bewerteter Horn-Klauseln:
s.o.
Relations-Aufruf:
(is _boolean (likes john _x))
wert-resolviert mit (hn (likes john mary))
mit Wert true und Bindung _x = mary
und bindet _boolean an Wahrheitswert true
Funktions-Aufruf:
(is _general (older john _x))
wert-resolviert mit (ft (older john mary) `(years 3))
mit Wert (years 3) und Bindung _x = mary
und bindet _general an allgemeinen Wert (years 3)
Non-deterministischer Funktions-Aufruf:
(is _several (child john _x))
wert-resolviert mit (ft (child john mary) ann)
mit Wert ann und Bindung _x = mary
und bindet _several an ersten Wert ann
und bei Backtracking
wert-resolviert mit (ft (child john mary) bob)
mit Wert bob und Bindung _x = mary
und bindet _several an zweiten Wert bob
17
Harold Boley
RELFUN-Einführung, 1997
18
Verfeinerung von Relationen
zu Funktionen
Da
RELFUN-Relationen
in
der
Art
von
charakteristischen Funktionen die Argumente ihres
Definitionsbereichs (die allerdings auch Anfrage-Variablen sein
können) in den Wertebereich {true,unknown} abbilden,
lassen sie sich durch Verfeinerung des Erfolgs-Werts
true zu allgemeinen Funktionen erweitern
A: Definitionsbereich (z.B. von Konstanten)
apprel: PROLOG-artige append-Relation
pali(ndrom)Relation
Funktion
pali: An -> {true,unknown}
pali: An -> {even,odd,unknown}
(hn (pali))
; true-Wert
(ft (pali) even)
; even-Wert
(hn (pali _x)) ; true-Wert
(ft (pali _x) odd) ; odd-Wert
(ft (pali _x | _y)
(apprel _z (tup _x) _y) ; Bindung von _z
(pali | _z))
; Wert von pali
Harold Boley
RELFUN-Einführung, 1997
19
Faktenwissen dargestellt
mit Relationen und Funktionen
englisch
relational
funktional
John likes Mary
(hn (likes john mary))
(ft (likes john mary) true)
John is 3 years
(hn (older john mary
(years 3)))
(ft (older john mary)
`(years 3))
older than Mary
John and Mary
(hn (child john mary ann))
have children
(hn (child john mary bob))
Ann, Bob, ...
... ...
(ft (child john mary) ann)
(ft (child john mary) bob)
Harold Boley
RELFUN-Einführung, 1997
20
Vorteil der relationalen Darstellung:
Sogar
über
funktional
abhängiges
Argument
invertierbar ("Funktionswert als Input") mittels
variabler Argumente
Who is 3 years older than who?
Whose child is Ann?
(older _x _y `(years 3))
(child _x _y ann)
Solche Invertierungen sind in RELFUN auch prinzipiell
in funktionaler Darstellung mittels variabler Argumente
und is-Primitiv simulierbar
Who is 3 years older than who?
Whose child is Ann?
(is (years 3) (older _x _y))
(is ann (child _x _y))
Harold Boley
RELFUN-Einführung, 1997
21
Vorteil der funktionalen Darstellung:
Auszeichnung eines funktional abhängigen Arguments
("Funktionswert als Output") ermöglicht geschachtelte
Aufrufe
What is the sum of 5 years and the (dimsum `(years 5)
number of years John is older than Mary?
(older john mary))
wobei dimsum eine dimensionsbehaftete Additions-Funktion ist:
(ft (dimsum (_dimension _num1) (_dimension _num2)) ;gleiche Dim.
(is _amount (+ _num1 _num2))
;Betrags -Erg.
`(_dimension _amount))
;Dim.-Erg.
Who is a child of a child of John and Mary (child (child john mary) and Sue?
sue)
wobei zusätzlich verwendete Definition (ft (child bob sue) li) ist
Solche Schachtelungen sind in PROLOG und RELFUN
auch zu relationaler Darstellung mittels Konjunktionen
und Hilfsvariablen abflachbar
What is the sum of 5 years and the
(older john mary _h)
number of years John is older than Mary? (dimsum `(years 5) _h _r)
wobei dimsum eine dimensionsbehaftete Additions-Relation ist:
(hn (dimsum (_dimension _num1) (_dimension _num2)
(_dimension
_amount))
(is _amount (+ _num1 _num2))) ;Wert unwichtig, daher hn-Regel
Who is a child of a child of John and Mary
(child john mary _h)
and Sue?
(child _h sue _r)
wobei zusätzlich verwendete Definition (hn (child bob sue li)) ist
Harold Boley
RELFUN-Einführung, 1997
22
Regelwissen dargestellt
mit Relationen und Funktionen
Relational:
(hn (older _pers1 _pers2 _diff)
(age _pers1 _year1)
(age _pers2 _year2)
(dimdifference _year1 _year2 _diff))
(hn (age john (years 48)))
(hn (age mary (years 45)))
(hn (dimdifference (_dimension _num1) (_dimension _num2)
(_dimension
_amount))
(is _amount (- _num1 _num2))) ;Wert unwichtig, daher hn-Regel
Vorteil der relationalen Darstellung:
Analog zu relationalen Fakten (s.o.)
Harold Boley
RELFUN-Einführung, 1997
Funktional:
(ft (older _pers1 _pers2)
(dimdifference (age _pers1) (age _pers2)))
(ft (age john) `(years 48))
(ft (age mary) `(years 45))
(ft (dimdifference (_dimension _num1) (_dimension _num2))
(is _amount (- _num1 _num2))
`(_dimension _amount))
Vorteil der funktionalen Darstellung:
Analog zu funktionalen Fakten (s.o.)
23
Harold Boley
RELFUN-Einführung, 1997
24
Operator-Schachtelungen, v.a.
Funktions-Aufruf als Argument
Relations-Aufruf
Datenbank enthalte:
(hn (rich tom))
(ft (fatherof yin) tom)
(ft (auntof tom) ann)
Mögliche Operator-Schachtelungen:
Unter-Aufruf
HauptAufruf
Relation
Funktion
(atom (rich tom))
(rich (fatherof yin))
(atom true)
(rich tom)
Relation
true
true
Funktion
(tup (rich tom))
(tup true)
(tup true)
(auntof (fatherof yin))
(auntof tom)
ann
von
Harold Boley
RELFUN-Einführung, 1997
25
Erlaubte Schachtelungs-Möglichkeiten:
LISP:
Funktions-Aufrufe als aktuelle
Argumente von Funktions-Aufrufen
PROLOG: Nur passive Konstruktor-Terme
("Strukturen") als aktuelle
Argumente von Relations-Aufrufen
RELFUN: Relations-/Funktions-Aufrufe als
aktuelle Argumente von anderen
Relations-/Funktions-Aufrufen (s.o.)
RELFUNs Spezialfall von Funktions-Aufrufen als
aktuelle Argumente von Relations-Aufrufen (Tabelle oben
rechts)
systematisiert "Reduktionen" in LOGLISP,
LISLOG etc.
Anders als bei semantischer Unifikation (FUNLOG, SASLOG) werden
bereits vor dem Zeitpunkt des Haupt-Aufrufs die Unter-Aufrufe
ausgewertet (call-by-value), nicht bei - dann "lazy" genannter - Unifikation
(call-by-need)
Strukturen als aktuelle Argumente werden in RELFUNs LISP-artiger
Syntax durch "`" gekennzeichnet: Falls in der Datenbank (hn (rich
(fatherof yin))) - als Fakt - steht, liefert (rich `(fatherof yin)) direkt
true
Harold Boley
RELFUN-Einführung, 1997
26
Abflachen von Schachtelungen
Für geschachtelte Terme soll die klassische
Auswertungsstrategie benutzt werden, für die mehrere
synonyme Bezeichnungen existieren:
◊ Call-by-value
evaluation
◊ Innermost-leftmost
reduction
◊ Applicative-order
computation
Diese Strategie wird aber anders als gewöhnlich
realisiert:
◊ Während
sich
z.B.
der
LISP-Interpreter,
EVAL,
rekursiv
in
eingeschachtelte
Subterme hineinarbeitet,
◊ zieht
nämlich
der
RELFUN-Interpreter,
AND-PROCESS,
solche
Subterme
zunächst
rekursiv aus dem Hauptterm heraus (mittels
GENSYM-artiger
Variablen
und
is-Primitiv),
bis
eine
abgeflachte
Konjunktion
übrig
bleibt, die dann wie in PROLOG links-rechts
abgearbeitet wird
Harold Boley
RELFUN-Einführung, 1997
27
Vorteil des Abflachprinzips:
Das Problem des
eingebetteten Non-Determinismus
in funktionalen Schachtelungen
wird damit zurückgeführt auf das in PROLOG gelöste
Problem von
flachem Non-Determinismus
in relationalen Konjunktionen
Beispiel für eingebetteten Non-Determinismus:
Mit der Datenbank
(ft (child john mary) ann)
(ft (child john mary) bob)
(hn (likes bob sue))
könnte bei der Berechnung der Schachtelung
(likes (child john mary) sue)
der eingebettete Term (child john mary) non-deterministisch
auf ann oder bob reduzieren (nur zweite Möglichkeit führt
dabei
zu
Erfolg),
so
daß
die
übliche
Evaluations-Strategie
sich
beim
rekursiven
Hineinlaufen in diesen Subterm weitere für ihn
passende Definitionen irgendwie "merken" müßte
Harold Boley
RELFUN-Einführung, 1997
28
Abflachverfahren:
In einer Schachtelung
(. . . term1 . . . termM . . .)
ersetze nicht mit "`" passivierte Subterme
term1, ..., termM
durch neue (eindeutige) Variablen, bestehend aus den
Zahlen 1, ..., M, "*"-erweitert um den (z.B. aus Kahns
PROLOG-in-LISP bekannten) aktuellen level-Wert, l, so
daß ein flaches Ziel
(. . . _1*l . . . _M*l . . .)
entsteht, vor welchem dann M is-Ausdrücke
(is _1*l term1), ..., (is _M*l termM)
als Konjunktion erzeugt werden:
(is _1*l term1) ... (is _M*l termM)
(. . . _1*l . . . _M*l . . .)
Falls ein termi selbst noch eine Schachtelung ist, geht
das Abflachverfahren - innerhalb des is rekursiv
mit
diesem
weiter,
sobald
die
links-rechts-Berechnung dort ankommt
Harold Boley
RELFUN-Einführung, 1997
29
Lösung für das frühere (einfache) Beispiel:
Die Schachtelung
(likes (child john mary) sue)
wird abgeflacht zu der Konjunktion
(is _1*1 (child john mary)) (likes _1*1 sue)
die dann mit der Datenbank
(ft (child john mary) ann)
(ft (child john mary) bob)
(hn (likes bob sue))
zunächst über
(is _1*1 ann) (likes _1*1 sue)
(likes _1*1 sue) mit _1*1 = ann
unknown
scheitert und beim Backtracking
(einfach auf der flachen Konjunktion realisiert) über
(is _1*1 bob) (likes _1*1 sue)
(likes _1*1 sue) mit _1*1 = bob
true
(_1*1-Bindung ist lokal zur Konjunktion)
zum Erfolg führt
Harold Boley
RELFUN-Einführung, 1997
30
Zusammenfassung:
Informelle
Hornklausel/Gleichungs-Wissenseinheiten
symbolisches
numerisches
relationales
Faktenwissen
(ancestor mary fred)
(ancestor john fred)
(ancestor fred rosa)
(fibonacci 0 1)
(fibonacci 1 1)
(fibonacci 2 2)
;vgl.Regel
Regelwissen
(ancestor _x _y)
:- (ancestor _x _h)
(ancestor _h _y)
(fibonacci _x _y)
:- (is _h1 (1- _x))
(is _h2 (1- _h1))
(fibonacci _h1 _f1)
(fibonacci _h2 _f2)
(is _y (+ _f1 _f2))
Deterministischer Aufruf:
(ancestor fred _wer) bindet _wer an rosa
Non-deterministische Aufrufe:
(ancestor mary _wer) bindet _wer an fred oder rosa
(ancestor _wes fred) bindet _wes an mary oder john
funktionales
Faktenwissen
(ancestor mary) = fred
(ancestor john) = fred
(ancestor fred) = rosa
(fibonacci 0) = 1
(fibonacci 1) = 1
(fibonacci 2) = 2;vgl.Regel
Regelwissen
(ancestor _x) =
(ancestor
(ancestor _x)
(fibonacci _x) =
(+
(fibonacci (1- _x))
(fibonacci
(1- (1- _x))))
Deterministischer Aufruf:
(ancestor fred) liefert rosa
Non-deterministische Aufrufe:
(ancestor mary) liefert fred oder rosa
(is fred (ancestor _wes)) bindet _wes an mary oder john
Harold Boley
RELFUN-Einführung, 1997
Zusammenfassung:
31
Formale
RELFUN-Wissensitems
symbolisches
numerisches
relationales
Faktenwissen
(hn (ancestor mary fred))
(hn (ancestor john fred))
(hn (ancestor fred rosa))
(hn (fibonacci 0 1))
(hn (fibonacci 1 1))
(hn (fibonacci 2 2));vgl.Regel
Regelwissen
(hn (ancestor _x _y)
(ancestor _x _h)
(ancestor _h _y))
(hn (fibonacci _x _y)
(is _h1 (1- _x))
(is _h2 (1- _h1))
(fibonacci _h1 _f1)
(fibonacci _h2 _f2)
(is _y (+ _f1 _f2)))
Deterministischer Aufruf:
(ancestor fred _wer) bindet _wer an rosa
Non-deterministische Aufrufe:
(ancestor mary _wer) bindet _wer an fred oder rosa
(ancestor _wes fred) bindet _wes an mary oder john
funktionales
Faktenwissen
(ft (ancestor mary) fred)
(ft (ancestor john) fred)
(ft (ancestor fred) rosa)
(ft (fibonacci 0) 1)
(ft (fibonacci 1) 1)
(ft (fibonacci 2) 2);vgl.Regel
Regelwissen
(ft (ancestor _x)
(ancestor
(ancestor _x))
(ft (fibonacci _x)
(+
(fibonacci (1- _x))
(fibonacci
(1- (1- _x)))))
Deterministischer Aufruf:
(ancestor fred) liefert rosa
Non-deterministische Aufrufe:
(ancestor mary) liefert fred oder rosa