Menu

F-Limette User Manual [de]

F-Limette (German)

F-Limette[(flimette>F-Limette: Homepage von F-Limette)] ist im Prinzip eine Erweiterung für Prolog[(prolog>Prolog: Einführung in Prolog auf Wikipedia)], die in die Prädikatenlogik zusätzlich einen temporalen Aspekt sowie Fuzzyness hinzufügt. Letzteres erlaubt hierbei die Belegung von Prädikaten nicht nur mit Werten aus {0,1} sondern aus allen reellen Zahlen in [0,1]. Dadurch können Konzepte wie zum Beispiel “wenig” oder “mäßig” umgesetzt werden.

Syntax

  • und: »,«
  • oder: »;«
  • Befehlszeilenende: ».«
  • Implikation: »:-« (←), »-:« (→)

Weiteres ist dem F-Limette-Handbuch[(flimetteman>F-Limette Manual: F-Limette Dokumentation (pdf) )] zu entnehmen.

Beispiele

# Tipps/Tricks

# Alle Ausgaben ohne Interaktion ausgeben
set(stop, +i).
# Immer 1 weitere Ausgabe ausgeben
set(stop, 1).
# Das nächste Ergebnis ausgeben lassen
;
# Faktum (Zusicherung) definieren. Folgendes Statement bedeutet soviel wie: 
#    zum Zeitpunkt 0 gilt: has_status(seby, 32)
asserta(0 ! has_status(seby, 32)).
# analog: z.Zpunkt 0 gilt: has_status(andy, 33)
asserta(0 ! has_status(andy, 33)).
asserta(0 ! has_status(davy, 13)).
# Mal andere Zeitpunkte verwenden
asserta(1 ! has_status(andy, 34)).
asserta(2 ! has_status(andy, 35)).
asserta(3 ! has_status(andy, +i)).
# Und auch mal zusaetzlich Fuzzyness reinbringen. Falls nicht angegeben, ist diese implizit 1.
asserta(0.5 | 1 ! has_status(davy, 14)).
asserta(0.6 | 1 ! has_status(davy, 13)).
asserta(0.9 | 2 ! has_status(davy, 14)).
asserta(0.1 | 2 ! has_status(davy, 13)).

# Abfragen an limette stellen funktioniert folgendermaßen: "mit welcher Fuzzyness" | gilt zum Zeitpunkt ? Welches Statement. 
# Hier: Fuzzyness: eps (ε, also egal)| Zeitpunkt 0 ? Wer ist 33?
eps | 0 ? has_status(_,33).
# Erwartete Antwort: andy

# Alle, die zum Zeitpunkt 0 ein Alter > 14 haben, ausgeben lassen
eps | 0 ? has_status(Name,Age), Age > 14.

# Zeitpunkt finden, zu welchem es ein Name gibt, der gerade 35 ist.
eps | event findall[L] Name -: has_status(Name,35).

# weitere Beispiele
eps | event findall[L] Name -: has_status(Name,13).
0.5 | event findall[L] Name -: has_status(Name,13).

Beispiele 2

Die folgenden Beispiele sind aus dem Buch [(ref:Schaefer1997)]

Seite 153ff:

/* "Wann ist es absolut wahr, dass ein beliebiger Pkw an einem beliebigen Ort parkt?" */
?- event parken_an_ort(Pkw,Ort).

F-LIMETTE unter Linux

Unter Linux liess sich der C++ Sourcecode von der Homepage [(ref:Schaefer1997)] mit gcc-4.4 nach folgenden Änderungen kompilieren:

limette/Makefile
- 	cd $(RLHOME) && configure
+	cd $(RLHOME) && ./configure

limette/scanner.l
+ %option noyywrap

limString.cc
- #include <strstream.h>
+ #include <strstream>
+ using namespace std;

limString.hh
- #include <stream.h>
+ #include <iostream>
+ using namespace std;

cppmod.cc
- #include <stream.h>
+ #include <iostream>
+ using namespace std;

limTerm.hh
- #include <stream.h>
+ #include <iostream>
+ using namespace std;
+ class limSubst;

limCommand.hh
- #include <strstream.h>
+ #include <strstream>
+ using namespace std;

Beispiele 3: Erste Schritte in F-LIMETTE

Starten und Verlassen:

user@computer:Limette/limette > ll limette2
-rwxrwxr-x 1 user user 1674968 2011-06-29 19:03 limette2
user@computer:Limette/limette > ./limette2
<0> 🙂 author.
	Karl H. Schaefer
<0> 🙂 version.
	LIMETTE-2 Jun 29 2011 19:03:48
<0> 🙂 quit.
😐 good bye.
user@computer:Limette/limette >

Fakten und Anfragen Eine Wissensbasis (knowledge base) ist eine Sammlung von Fakten (facts) In F-Limette sieht das etwa so aus: always(bird(chicken)). always(animal(lion)). always(animal(zebra)).

Wobei always() für zeitlich von minus Unendlich bis plus Unendlich steht und nur eine andere Schreibweise ist für: -i : +i !

Anfragen werden in Limette direkt eingegeben, zB: bird(chicken).

Beachte: :- bird(chicken) entspricht einem yes auch wenn nach Eingabe von ; dahinter ein no (für nicht nochmal auf andere Art als true auswertbar) kommt.

<0> 🙂 assertz(always(animal(lion))).
<0> 🙂 assertz(always(animal(zebra))).
<0> 🙂 asserta(always(bird(chicken))).
<0> 🙂 list.
       1: -i : +i ! bird(chicken).
       2: -i : +i ! animal(lion).
       3: -i : +i ! animal(zebra).
<1> 🙂 animal(Var).
:- animal(lion);
:- animal(zebra);
no
<2> 🙂 bird(chicken).
:- bird(chicken);
no
<3> 🙂 bird(car).
no
<3> 🙂 history.
    <0> animal(Var) [STOPPED]
    <1> bird(chicken) [STOPPED]
    <2> bird(car) [STOPPED]
<3> 🙂

Regeln Alle Vögel sind Tiere. Und das natürlich rund um die Uhr ;-) Das heisst aus bird(X) folgt animal(X):

always(animal(X) :- bird(X)).

Und damit wir das nicht jedes mal neu tippen müssen, kommt das in ein File.

user@computer:Limette/limette > more ../Daten/limette_files/test_file.lim 
always(bird(chicken)).
always(animal(lion)).
always(animal(zebra)).
always(animal(X) :- bird(X)).

Das angegebene Verzeichnis bei cd muss eine Konstante sein, d.h. mit kleinem Buchstaben anfangen und nur passende Zeichen oder in ‘ ‘ z.B. ‘..’, ‘Daten’, limette_files oder ‘limette_files’

Bei add braucht man den Filenamen ohne .lim

Der Inhalt des Files wird an das aktuelle Modul angehängt.

user@computer:Limette/limette > ./limette2
<0> 🙂 pwd.
	/home/user/Programme/Limette/limette
<0> 🙂 cd('..').
<0> 🙂 cd('Daten').
<0> 🙂 cd(limette_files).
<0> 🙂 add(test_file).
<0> 🙂 list.
       1: -i : +i ! bird(chicken).
       2: -i : +i ! animal(lion).
       3: -i : +i ! animal(zebra).
       4: -i : +i ! (animal(_0) :- bird(_0)).
<0> 🙂 animal(chicken).
:- animal(chicken);
no
<1> 🙂 modules.
	test_file
<1> 🙂 where.
	test_file

Ein paar Parameter lassen sich einstellen. Wir wollen nun den debug-mode:

Dann kann man schrittweise per creep die Auswertung durchgehen oder auf einmal alle Schritte per trace sich anzeigen lassen.

<2> 🙂 get.
	alpha    = [ 1, 1, 1, 1, 0 ]
	answer   = formula
	cycles   = off
	debug    = off
	defcheck = on
	gates    = delay
	limits   = +i
	narrow   = off
	print    = normal
	queue    = depth
	stop     = 1
	store    = proof
	trace    = off
	memo     = off
<2> 🙂 set(debug,on).
<2> 🙂 get(debug).
	debug    = on
<2> 🙂 animal(chicken).
(   8)    1 Call: animal(chicken) : ?
🙁 debugger command must be one of abort, creep, fail, leap, skip, trace.
(   8)    1 Call: animal(chicken) : trace
(  10)    2 Call: bird(chicken)
(  10)    2 Exit: bird(chicken)
(   8)    1 Exit: animal(chicken)
:- animal(chicken);
no
<3> 🙂 animal(chicken).
(  13)    1 Call: animal(chicken) : creep
(  15)    2 Call: bird(chicken) : creep
(  15)    2 Exit: bird(chicken)
(  13)    1 Exit: animal(chicken)
:- animal(chicken);
no

Änderungen kann man abspeichern: ‘test_file.lim’ braucht die ‘ ‘ weil . kein gülties Zeichen in einem Atom.

<4> 🙂 asserta(always(bird(eagle))).
<4> 🙂 animal(X).
:- animal(lion);
:- animal(zebra);
:- animal(eagle);
:- animal(chicken);
no
<5> 🙂 where.
	test_file
<5> 🙂 list(test_file).
       1: -i : +i ! bird(eagle).
       2: -i : +i ! bird(chicken).
       3: -i : +i ! animal(lion).
       4: -i : +i ! animal(zebra).
       5: -i : +i ! (animal(_0) :- bird(_0)).
<5> 🙂 save(test_file,'test_file.lim').
<5> 🙂 quit.
😐 good bye.
user@computer:Limette/limette > more ../Daten/limette_files/test_file.lim 
-i : +i ! bird(eagle).
-i : +i ! bird(chicken).
-i : +i ! animal(lion).
-i : +i ! animal(zebra).
-i : +i ! (animal(_0) :- bird(_0)).

Referenzen

<refnotes> notes-separator : none </refnotes>

Leave a Reply