Prolog Language Zelfstudie
Aan de slag met Prolog Language
Zoeken…
Opmerkingen
implementaties
- SWI-Prolog (gratis) swi-proloog
- Geïmplementeerd in c
- SICStus (commercieel) sicstus-proloog
- YAP (gratis) yap
- GNU Prolog (gratis) gnu-prolog
- XSB (gratis) xsb
- B (commercieel) b-proloog
- ALS (commercieel)
- Ciao (gratis)
- Minerva (commercieel)
- ECLiPSe-CLP (gratis) eclipse-clp
- Jekejeke Prolog (commercieel)
- Prolog IV
- Opbrengst Prolog (gratis)
- Geïmplementeerd in c # , javascript en phyton
- Visual Prolog (commercieel) visual-prolog
Installatie of instellingen
SWI-Prolog
Windows en Mac:
- Download SWI-Prolog op de officiële website
- Installeer eenvoudig door de installatie-instructies te volgen.
Linux (PPA):
Voeg de PPA
ppa:swi-prolog/stable
aan de softwarebronnen van uw systeem (ontwikkelaars kunnen kiezen voorppa:swi-prolog/devel
):Open een terminal (Ctrl + Alt + T) en typ:
sudo add-apt-repository ppa:swi-prolog/stable
Werk daarna de pakketinformatie bij:
sudo apt-get update
Installeer nu SWI-Prolog via de pakketbeheerder:
sudo apt-get install swi-prolog
U kunt SWI-Prolog nu starten via de opdrachtregel met opdracht
swipl
append / 3
append([], Bs, Bs).
append([A|As], Bs, [A|Cs]) :-
append(As, Bs, Cs).
append/3
is een van de meest bekende Prolog-relaties. Het definieert een relatie tussen drie argumenten en is waar als het derde argument een lijst is die de samenvoeging van de lijsten aangeeft die zijn gespecificeerd in de eerste en tweede argumenten.
In het bijzonder, en zoals typisch is voor goede Prolog-code, kan append/3
in verschillende richtingen worden gebruikt: Het kan worden gebruikt om:
voeg twee volledig of gedeeltelijk geïnstantieerde lijsten toe:
?- A = [1, 2, 3], B=[4, 5, 6], append(A, B, Y) Output: A = [1, 2, 3], B = [4, 5, 6], Y = [1, 2, 3, 4, 5, 6].
controleer of de relatie waar is voor drie volledig geïnstantieerde lijsten:
?- A = [1, 2, 3], B = [4, 5], C = [1, 2, 3, 4, 5, 6], append(A, B, C) Output: false
genereer alle mogelijke manieren om twee lijsten aan een bepaalde lijst toe te voegen:
?- append(A, B, [1, 2, 3, 4]). Output: A = [], B = [1, 2, 3, 4] ; A = [1], B = [2, 3, 4] ; A = [1, 2], B = [3, 4] ; A = [1, 2, 3], B = [4] ; A = [1, 2, 3, 4], B = [] ; false.
CLP (FD) Beperkingen
CLP (FD) -beperkingen worden geleverd door alle serieuze Prolog-implementaties. Ze stellen ons in staat om op een zuivere manier over gehele getallen te redeneren.
?- X #= 1 + 2.
X = 3.
?- 5 #= Y + 2.
Y = 3.
Database programmeren
Prolog categoriseert alles in:
- Atomen - Elke reeks tekens die niet met een hoofdletter begint. Eg -
a
,b
,okay
- Nummers - Er is geen speciale syntaxis voor nummers, er is geen aangifte vereist. Bijv.
1
,22
,35.8
- Variabelen - Een tekenreeks die begint met een hoofdletter of een onderstrepingsteken (
_
). BijvoorbeeldX
,Y
,Abc
,AA
- Complexe termen - Ze zijn gemaakt van een functor en een reeks argumenten . De naam van een complexe term is altijd een atoom, terwijl argumenten atomen of variabelen kunnen zijn. Bijvoorbeeld
father(john,doe)
,relative(a)
,mother(X,Y)
.
Een logische database bevat een reeks feiten en regels .
Een complexe term met alleen atomen als argumenten wordt een feit genoemd, terwijl een complexe term met variabelen als argumenten een regel wordt genoemd.
Voorbeeld van feiten in Prolog:
father_child(fred, susan).
mother_child(hillary, joe).
Voorbeeld van een regel in Prolog:
child_of(X,Y):-
father_child(Y,X)
;
mother_child(Y,X).
Merk op dat de ;
hier is de operator or
in andere talen.
Prolog is een declaratieve taal en u kunt deze database als volgt lezen:
Fred is de vader van Susan
Hillary is de moeder van Joe.
Voor alle
X
enY
isX
een kind vanY
alsY
een vader is vanX
ofY
een moeder vanX
.
In feite is een eindige reeks feiten en of regels een logisch programma .
Het gebruik van een dergelijk programma wordt aangetoond door vragen te stellen . Met Query's kunt u informatie ophalen uit een logisch programma.
Om de database in de interpreter te laden (ervan uitgaande dat u de database hebt opgeslagen in de map waarin u de interpreter gebruikt), voert u eenvoudig het volgende in:
?- [nameofdatabase].
de nameofdatabase
vervangen door de werkelijke bestandsnaam (merk op dat we hier de extensie .pl
van de bestandsnaam uitsluiten).
Voorbeeld van vragen in de tolk voor het bovenstaande programma en de resultaten:
?- child_of(susan,fred).
true
?- child_of(joe,hillary).
true
?- child_of(fred,susan).
false
?- child_of(susan,hillary).
false
?- child_of(susan,X).
X = fred
?- child_of(X,Y).
X = susan,
Y = fred ;
X = joe,
Y = hillary.
De bovenstaande vragen en hun antwoorden kunnen als volgt worden gelezen:
is susan een kind van fred? - waar
is Joe een kind van Hillary? - waar
is fred een kind van susan? - fout
is susan een kind van hillary? - fout
van wie is Susan een kind? - Fred
Dit is hoe we logica programmeren in Prolog. Een logisch programma is formeler: een verzameling axioma's, of regels, die relaties (aka predikaten) tussen objecten definiëren. Een alternatieve manier om de bovenstaande database op een meer formele logische manier te interpreteren is:
De relatie
father_child
bestaat tussen Fred en Susan
De relatie tussen
mother_child
enmother_child
bestaat tussen hillary en joe
Voor alle
X
enY
de relatiechild_of
tussenX
enY
als de relatiefather_child
tussenY
enX
, of de relatiemother_child
tussenY
enX
Hallo Wereld
Hallo wereld in de interactieve tolk
Om "Hallo wereld!" Af te drukken in de Prolog-interpreter (hier gebruiken we swipl
, de shell voor SWI Prolog):
$ swipl
<...banner...>
?- write('Hello, World!'), nl.
?-
wordt het systeem gevraagd: het geeft aan dat het systeem gereed is voor de gebruiker om een reeks doelen (dat wil zeggen een zoekopdracht ) in te voeren die moet worden beëindigd met een .
(punt).
Hier heeft de zoekopdracht write('Hello World!'), nl
twee doelen:
-
write('Hello World!')
:'Hello World!'
moet worden weergegeven en (,
) - er moet een nieuwe regel (
nl
) volgen.
write/1
(de /1
wordt gebruikt om aan te geven dat het predicaat één argument heeft) en nl/0
zijn ingebouwde predicaten (de definitie wordt vooraf door het Prolog-systeem gegeven). Ingebouwde predicaten bieden faciliteiten die niet kunnen worden verkregen door pure Prolog-definitie of om te voorkomen dat de programmeur ze hoeft te definiëren.
Het resultaat:
Hallo Wereld!
Ja
eindigt met yes
wat betekent dat de zoekopdracht is geslaagd. In sommige systemen wordt true
afgedrukt in plaats van yes
.
Hallo wereld vanuit een bestand
Open een nieuw bestand met de naam hello_world.pl
en voeg de volgende tekst in:
:- initialization hello_world, halt.
hello_world :-
write('Hello, World!'), nl.
De initialization
instructie geeft aan dat het doel hello_world, halt
moet worden aangeroepen wanneer het bestand wordt geladen. halt
verlaat het programma.
Dit bestand kan vervolgens worden uitgevoerd door uw Prolog-uitvoerbare bestand. De exacte vlaggen zijn afhankelijk van het Prolog-systeem. Als u SWI Prolog gebruikt:
$ swipl -q -l hello_world.pl
Dit levert uitvoer op Hello, World!
. De vlag -q
onderdrukt de banner die meestal wordt weergegeven wanneer u run swipl
. De -l
geeft een bestand aan dat moet worden geladen.