Prolog

Prolog
Utvikler(e)
Alain Colmerauer og Philippe Roussel
Generell informasjon
Vanlige utvidelser pl, pro og P
Dukket opp i 1972
Designet av Alain Colmerauer , Robert Kowalski og Philippe Roussel
påvirket av planlegger

Prolog (eller PROLOG ), fra den franske PRO - grammasjonen i LOG ique , [ 1 ] er et logisk og tolket programmeringsspråk som vanligvis brukes innen kunstig intelligens .

Historikk

Det er et programmeringsspråk utviklet på begynnelsen av 1970-tallet ved Universitetet i Aix-Marseille I ( Marseille , Frankrike ) av Alain Colmerauer og Philippe Roussel . Det ble født fra et prosjekt som ikke hadde som mål å oversette et programmeringsspråk, men snarere algoritmisk behandling av naturlige språk. Alain Colmerauer og Robert Pasero jobbet med den naturlige språkbehandlingsdelen og Jean Trudel og Philippe Roussel med deduksjons- og inferensdelen av systemet. Philippe Roussel var interessert i SL-oppløsningsmetoden og overtalte forfatteren, Robert Kowalski, til å samarbeide med prosjektet, noe som ga opphav til en foreløpig versjon av Prolog-språket på slutten av 1971 [ 2 ] og den endelige versjonen som dukket opp i 1972. [ 3 ] Denne første versjonen av Prolog ble programmert i ALGOL W.

Opprinnelig var det et fullt tolket språk inntil David HD Warren i 1983 utviklet en kompilator som var i stand til å oversette Prolog til et abstrakt maskininstruksjonssett kalt Warren Abstract Machine , eller WAM for kort . Siden den gang er Prolog et semi-tolket språk.

Selv om det i utgangspunktet var et språk med begrenset bruk, oppstod tolker for 8-bits mikrodatamaskiner (f.eks . mikro-PROLOG ) og for 16-biters hjemmedatamaskiner (f.eks . Borlands Turbo Prolog , blant mange andre) ), gjennom hele 1980-tallet, bidro spesielt til populariseringen. [ 4 ] En annen viktig faktor i spredningen var at den ble tatt i bruk for utviklingen av prosjektet til den femte generasjonen datamaskiner på begynnelsen av 1980-tallet, [ 5 ] i hvilken sammenheng den parallelliserte implementeringen av språket kalt KL1 og fra hvilken del av det moderne utvikling av Prolog er avledet.

De første versjonene av språket skilte seg, i deres forskjellige implementeringer, i mange aspekter av deres syntaks , dialekten foreslått av University of Edinburgh ble brukt mest som en normalisert form, [ 6 ] inntil en ISO-standard ble etablert i 1995 (ISO/ IEC 13211-1), kalt ISO-Prolog.

Prolog faller inn under paradigmet med logiske og deklarative språk , som i stor grad skiller det fra andre mer populære språk som Fortran , Pascal , C eller Java .

Tilbakesporing _ _

I programmeringsspråkene nevnt ovenfor utføres instruksjonene normalt i sekvensiell rekkefølge, det vil si den ene etter den andre, i samme rekkefølge som de er skrevet, som bare varierer når en kontrollinstruksjon (en loop , en betinget instruksjon) eller en overføring).

Programmer i Prolog er bygd opp av Horn-klausuler som utgjør regler av typen " modus ponens ponens ", det vil si "Hvis antecedenten er sann, så er konsekvensen sann ". Måten Horn-setninger skrives på er imidlertid motsatt av det vanlige. Skriv den påfølgende først og deretter forleddet. Forløpet kan være en konjunksjon av forhold som kalles en målsekvens . Hvert mål er atskilt med et komma og kan tenkes å ligne på en kommando eller prosedyrekall på imperative språk. I Prolog er det ingen kontrollsetninger. Utførelsen er basert på to konsepter: forening og tilbakesporing .

Takket være foreningen bestemmer hvert mål et undersett av klausuler som kan utføres. Hver av disse kalles et plukkepunkt . Prolog velger førstevalgspunktet og fortsetter å kjøre programmet til det bestemmer om målet er sant eller usant.

Hvis det er usant , kommer tilbakesporing inn i bildet , som består i å angre alt som er utført, og plassere programmet i samme tilstand som det var i like før det nådde det valgte punktet. Deretter tas neste ventende valgpunkt og prosessen gjentas igjen. Alle mål fullfører utførelsen enten ved suksess ("sant") eller ved fiasko ("falsk").

Programmering i Prolog

Det er to typer klausuler: fakta og regler. En regel er av typen:

Hode : - Kropp .

og lyder som "Hodet er sant hvis kroppen er sant". Brødteksten i en regel består av kall til Predicate (logiske) predikater , som kalles reglenes mål . Predikatet ,/2(det vil si en operator av paritet 2 (tar 2 argumenter) og av navn ,) angir målkonjunksjon , og operatoren ;/2angir disjunksjon . Konjunksjoner og disjunksjoner kan bare vises i kroppen, ikke i hovedet på regelen. Egentlig er ikke disjunksjon en grunnleggende eller forhåndsdefinert operatør, men den er metaprogrammert slik:

';' ( A , _ ) : - A . ';' ( _ , B ) : - B .

Klausuler uten kropp (dvs. antecedent) kalles fakta fordi de alltid er sanne. Et eksempel på et faktum er:

katt ( tom ).

som tilsvarer regelen:

katt ( tom ) :- sant .

Det forhåndsdefinerte predikatet true/0er alltid sant.

Gitt ovenstående faktum, kan man spørre:

Er Tom en katt?

?- katt ( tom ). Og det er

Hvilke ting er katter?

?- katt ( X ). X = Tom

På grunn av den relasjonelle naturen til mange predikater, kan argumentene deres brukes omvendt. For eksempel length/2kan den brukes til å bestemme størrelsen (lengden) på en liste: lengde([a,b,c], L) , samt å generere et listeskjelett for en gitt lengde ( lengde(X, 5) ). På samme måte kan append/3den også brukes til å slå sammen eller legge til to lister: append([a,b], [c,d], X) , samt å dele en liste i to deler: append(X, Y, [a) ,b,c,d]) . Alt avhenger av hvilke argumenter som er frie variabler og hvilke som er instansiert. I analogi med imperativ programmering er frie variabler utgangsargumenter og resten er inputargumenter. Men i Prolog, i motsetning til imperative språk, er den rollen utskiftbar i de fleste predikater. Denne funksjonen kalles reversibilitet , og de gyldige kombinasjonene av utdata- eller inngangsargumenter kalles bruksmoduser . For eksempel er predikatlengden /2 reversibel og har tre bruksmoduser: begge argumentene instansiert, det første argumentet instansiert, men det andre ikke, og omvendt. Bruksmodusen med de to argumentene som ikke er instansiert gir ikke mye mening, men den kan støttes i henhold til noen implementeringer, i så fall vil den generere alle listeskjeletter av alle mulige lengder...

Av denne grunn er et relativt lite bibliotek med predikater tilstrekkelig for mange Prolog-programmer. Alle predikater kan også brukes til enhetstesting : spørringer kan bygges inn i programmer og tillate automatisk kompileringstidsregresjonstesting.

Som et generellt språk har Prolog også flere forhåndsdefinerte predikater for interaksjon med operativsystemet, for eksempel input/output , grafikk og datakommunikasjon. Disse predikatene har ingen relasjonell betydning og er kun nyttige for bivirkningene de viser på systemet. For eksempel viser predikatet write/1 et begrep på skjermen, men dens sanne eller falske verdi er irrelevant.

Uttrykk

Prolog har operatører for forening og sammenligning, enten med evaluering eller symbolsk, for eksempel følgende:

  • X is Y %unificación con evaluación.
  • X = Y %unificación simbólica
  • X=:=Y %comparación con evaluación
  • X == Y %comparación simbólica.
?- X er 3 + 5. X = 8 ?- X = 3 + 5. X = 3 + 5 ?- 3 + 5 =:= 2 + 6. ja ?- 3 + 5 == 2 + 6. ikke ?- 3 + 5 == 3 + 5. ja

Lister

Representasjon av enkle fakta er ikke vanlig i klassifiseringen av elementer, men elementer av samme type er gruppert i en liste.

Lister er samlinger av elementer i Prolog. En liste er delt inn i to deler: Hode. Det er det første elementet på listen. Hale. Det er en liste med resten av elementene i listen. Hodet og halen på en liste er atskilt med "|"-symbolet.

Eksempler på prologkode

Enkelt eksempel

%% %% utsagn %% far til ( 'John' , 'Mary' ). % Juan er faren til María padrede ( 'Pablo' , 'Juan' ). % Pablo er faren til Juan padrede ( 'Pablo' , 'Marcela' ). % Pablo er faren til Marcela padrede ( 'Carlos' , 'Débora' ). % Carlos er faren til Debora % A er et barn av B hvis B er en forelder til A barn til ( A , B ) :- foreldre til ( B , A ). % A er besteforeldre til B hvis A er foreldre til C og C er foreldre til B besteforeldre til ( A , B ) :- foreldre til ( A , C ), foreldre til ( C , B ). % A og B er søsken hvis forelderen til A også er forelderen til B og hvis A og B ikke er samme søsken til ( A , B ) :- forelder til ( C , A ) , forelder til ( C , B ) , A \ == B . % A og B er slektninger hvis A er far til B eller A er sønn av B eller A er bror til B slektning til ( A , B ) :- far til ( A , B ). slektning av ( A , B ) :- sønn av ( A , B ). slektning til ( A , B ) :- bror til ( A , B ). %% %% spørringer %% % Er Juan Marcelas bror? ?- bror til ( 'Juan' , 'Marcela' ). Og det er % Er Carlos Juans bror? ?- bror til ( 'Carlos' , 'Juan' ). Nei % Er Pablo bestefaren til María? ?- bestefar ( 'Pablo' , 'Maria' ). Og det er % Er María Pablos bestemor? ?- bestefar ( 'Maria' , 'Pablo' ). Nei

Faktor for et tall

% Syntaksen er faktoriell(N, F) -> Faktoriell av N er F (resultatet er lagret i F) faktoriell ( 0 , 1 ). faktoriell ( 1 , 1 ). faktoriell ( N , F ) :- N > 0 , N1 er N - 1 , faktoriell ( N1 , F1 ), F er N * F1 . %faktoriell kalles rekursivt å forlate resultatet i F

Fibonacci-term for et tall

% Syntaksen er fibonacci(N, F) -> Term N i sekvensen (resultatet er lagret i F). fibonacci ( 0 , 0 ) :-!. fibonacci ( 1 , 1 ) :-!. fibonacci ( N , F ) :- N1 er N - 1 , fibonacci ( N1 , F1 ), N2 er N - 2 , fibonacci ( N2 , F2 ), F er F1 + F2 . %fibonacci kalles rekursivt å forlate resultatet i F.

Bruk av lister i Prolog

Opprette og spørre etter lister planter ([ eple , appelsin , sitron , spinat , gardenia , alfalfa , furu ]). liste ([ 1 , 2 , 3 ]). ?- liste ([ H | T ]). H = 1 T = [ 2 , 3 ] a- liste ([ H , J | T ]). H = 1 J = 2 T = [ 3 ] Lengden på en liste % Hvis vi ønsker å finne lengden på en liste. % Lengden på en tom liste er 0. % Lengden på en liste er lengden på køen + 1. lengde ([], 0 ). lengde ([ _ | T ], N ):- lengde ( T , N0 ), N er N0 + 1. ?- lengde ([ a , b , c ], L ). L = 3 a- lengde ([ a , b , c ], 4 ). Nei Søk etter et element % Hvis vi ønsker å finne ut om et element tilhører en liste. % Elementet tilhører listen hvis det samsvarer med toppen av listen. % Elementet tilhører listen hvis det er i køen til listen. tilhører ( X ,[ X | _ ]) . tilhører ( X ,[ _ | R ]):- tilhører ( X , R ). ?- tilhører ( b ,[ a , b , c ]). Ja ?- tilhører ( b ,[ a ,[ b , c ]]). Tilhører ikke ?- ([ b , c ],[ a ,[ b , c ]]). Ja ?- tilhører ( X ,[ a , b ]). X = a ; X = b Fjern element fra en liste % Hvis vi ønsker å fjerne et element fra listen. % Hvis X er toppen av listen, er hale T listen uten X % Hvis X ikke er listens hode, beholder vi listens hode % som en del av svaret og fortsetter å fjerne X fra hale T. fjerner ( X ,[ X | T ], T ). fjern ( X ,[ H | T ],[ H | T1 ]): - fjern ( X , T , T1 ). a- fjerner ( 1 , [ 1,2,3,4 ] , R ) . _ _ _ R = [ 2 , 3 , 4 ] p- eliminerer ( 1 , R , [ 2 , 3 ]). R = [ 1 , 2 , 3 ] ; R = [ 2 , 1 , 3 ] ; R = [ 2 , 3 , 1 ] p- eliminerer ( X , [ 1 , 2 , 3 ], Y ). X = 1 , Y = [ 2 , 3 ] ; X = 2 , Y = [ 1 , 3 ] ; X = 3 , Y = [ 1 , 2 ] Sammenslå lister % Hvis vi ønsker å sette sammen to lister liste. % Konkatenering av en tom liste med L er L. % Sammenknytting av X|L1 med L2 er å sette det første %-elementet av den første listen (X) pluss %-sammenkoblingen av resten av listen (L1) med L2 konkatenere ([], L , L ). konkatenat ([ X | L1 ], L2 ,[ X | L3 ]):- konkatenat ( L1 , L2 , L3 ). a- konkatenat ([ 1 , 2 ], [ 3 , 4 ], R ). R = [ 1 , 2 , 3 , 4 ]. a- konkatenat ( X , Y , [ 1 , 2 ]). X = [], Y = [ 1 , 2 ] ; X = [ 1 ], Y = [ 2 ] ; X = [ 1 , 2 ], Y = [] Sjekk om en liste er det motsatte av en annen % Hvis vi ønsker å beregne inversen av en liste. % Det motsatte av en tom liste er en tom liste. % Inversen av H|T er inversen av T sammenkoblet med H. revers ([],[]). revers ([ H | T ], L ):- revers ( T , R ), sammenføyd ( R ,[ H ], L ). ?- invers ([ a , b , c , d ], [ d , c , b , a ]). Ja / Ja % Bruke en akkumulatorparameter. revers ( L1 , L2 ):- revers ( L1 , L2 ,[]). revers ([], L , L ). inver ([ H | T ], L , S ):- inver ( T , L ,[ H | S ]). ?- inver ([ a , b , c , d ], [ d , c , b , a ]). Og det er

Referanser

  1. Colmerauer, Alain og Roussel, Philippe. The Naissance of Prolog , juli 1992
  2. BERGIN, Thomas J. og GIBSON, Richard G., History of Programming Languages ​​II , New York, ACM Press, Addison-Wesley, 1996, ISBN 0-201-89502-1
  3. Kowalski, R. A. De første årene med logisk programmering . 
  4. PROLOG-språket , artikkel i ABC - avisen 12. oktober 1986
  5. Applications of Artificial Intelligence in Business, Science, and Industry , av Wendy B. Rauch-Hindin, side 644 et seq., ISBN 84-87189-07-5 , på Google Books .
  6. I mangel av en formell Edinburgh Prolog -spesifikasjon, har Bowens DEC-10 PROLOG Manual (1982) eller Clocksin og Mellishs Programmering i Prolog blitt brukt som referanser .

Se også

Eksterne lenker