Prolog LanguageAan de slag met Prolog Language


Opmerkingen

implementaties

  1. SWI-Prolog (gratis)
    • Geïmplementeerd in
  2. SICStus (commercieel)
  3. YAP (gratis)
  4. GNU Prolog (gratis)
  5. XSB (gratis)
  6. B (commercieel)
  7. ALS (commercieel)
  8. Ciao (gratis)
  9. Minerva (commercieel)
  10. ECLiPSe-CLP (gratis)
  11. Jekejeke Prolog (commercieel)
  12. Prolog IV
  13. Opbrengst Prolog (gratis)
  14. Visual Prolog (commercieel)

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 ( _ ). Bijvoorbeeld X , 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 en Y is X een kind van Y als Y een vader is van X of Y een moeder van X .

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 en mother_child bestaat tussen hillary en joe

Voor alle X en Y de relatie child_of tussen X en Y als de relatie father_child tussen Y en X , of de relatie mother_child tussen Y en X

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.

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 voor ppa: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