PrologEdit

de programmeertaal Prolog werd ontwikkeld in 1972 door Alain Colmerauer. Het kwam voort uit een samenwerking tussen Colmerauer in Marseille en Robert Kowalski in Edinburgh. Colmerauer werkte aan het begrijpen van natuurlijke taal, met behulp van logica om semantiek te vertegenwoordigen en met behulp van resolutie voor het beantwoorden van vragen. In de zomer van 1971 ontdekten Colmerauer en Kowalski dat de clausale vorm van logica kon worden gebruikt om formele grammatica ‘ s weer te geven en dat resolutiestellingen gebruikt konden worden voor het ontleden. Ze merkten op dat sommige theorem provers, zoals hyper-resolutie, zich gedragen als bottom-up parsers en anderen, zoals SL-resolutie (1971), zich gedragen als top-down parsers.het was in de zomer van 1972 dat Kowalski, opnieuw in samenwerking met Colmerauer, de procedurele interpretatie van de implicaties ontwikkelde. Deze dubbele declaratieve / procedurele interpretatie werd later geformaliseerd in de Prolog notatie

H: – B1,…, Bn.

die zowel declaratief als procedureel kan worden gelezen (en gebruikt). Het werd ook duidelijk dat dergelijke clausules kunnen worden beperkt tot bepaalde clausules of Hoorn clausules, waarbij H, B1, …, Bn zijn allemaal atomaire predicaatlogica formules, en die SL-resolutie kan worden beperkt (en gegeneraliseerd) tot weelderige of SLD-resolutie. Kowalski ‘ s procedurele interpretatie en LUSH werden beschreven in een memo uit 1973, gepubliceerd in 1974.Colmerauer, samen met Philippe Roussel, gebruikte deze dubbele interpretatie van clausules als basis voor Prolog, dat in de zomer en de herfst van 1972 ten uitvoer werd gelegd. Het eerste Prolog-programma, ook geschreven in 1972 en geïmplementeerd in Marseille, was een Frans vraagbeantwoordingssysteem. Het gebruik van Prolog als een praktische programmeertaal werd een grote impuls gegeven door de ontwikkeling van een compiler door David Warren in Edinburgh in 1977. Experimenten toonden aan dat Edinburgh Prolog kon concurreren met de verwerkingssnelheid van andere symbolische programmeertalen zoals Lisp. Edinburgh Prolog werd de de facto standaard en beïnvloedde sterk de definitie van ISO-standaard Prolog.

Abductive logic programmingdit

Abductive logic programming is een uitbreiding van normaal Logic Programming waardoor sommige predicaten, die als abductable predicaten worden aangegeven, “open” of ongedefinieerd kunnen zijn. Een clausule in een abductive logic-programma heeft de vorm:

H: – B1,…, Bn, A1,…, An.

waarbij H een atomaire formule is die niet ontvoerbaar is, zijn alle Bi literalen waarvan de predicaten niet ontvoerbaar zijn, en de Ai zijn atomaire formules waarvan de predicaten ontvoerbaar zijn. De abducible predicaten kunnen worden beperkt door integriteitsbeperkingen, die de vorm kunnen hebben:

false: – L1,…, Ln.

wanneer de Li willekeurige literalen zijn (gedefinieerd of ontvoerbaar, en atomair of ontkend). Bijvoorbeeld:

canfly(X) :- bird(X), normal(X).false :- normal(X), wounded(X).bird(john).bird(mary).wounded(john).

waarbij het predicaat normaal ontvoerbaar is.

probleemoplossing wordt bereikt door hypothesen af te leiden die worden uitgedrukt in termen van de ontvoerbare predicaten als oplossingen van problemen die moeten worden opgelost. Deze problemen kunnen zowel observaties zijn die moeten worden verklaard (zoals in het klassieke abductieve redeneren) als doelen die moeten worden opgelost (zoals in normaal logisch programmeren). Bijvoorbeeld, de hypothese normaal(mary) verklaart de waarneming canfly (mary). Bovendien bevat dezelfde hypothese de enige oplossing X = mary van het doel om iets te vinden dat kan vliegen:

:- canfly(X).

Abductive logic programming is gebruikt voor foutdiagnose, planning, natuurlijke taalverwerking en machine learning. Het is ook gebruikt om negatie te interpreteren als mislukking als een vorm van ontvoeringsredenering.

Metalogic programmingdit

omdat de wiskundige logica een lange traditie heeft om onderscheid te maken tussen objecttaal en metalanguage, staat logica programmering ook metalevel programmering toe. Het eenvoudigste metalogic programma is de zogenaamde “vanilla” meta-interpreter:

 solve(true). solve((A,B)):- solve(A),solve(B). solve(A):- clause(A,B),solve(B).

waar true een lege voegwoord vertegenwoordigt, en Clausule(A,B) betekent dat er een object-niveau clausule is in de vorm:-B.

Metalogic programming maakt het mogelijk om Object – niveau en metalevel representaties te combineren, zoals in natuurlijke taal. Het kan ook worden gebruikt voor het implementeren van elke logica die is gespecificeerd als inferentie regels. Metalogic wordt gebruikt in logische programmering om metaprograms te implementeren, die andere programma ‘ s, databases, kennisbases of axiomatische theorieën als gegevens manipuleren.

Constraint logic programmingdit

Constraint logic programming combineert Horn clause logic programming met constraint solving. Het breidt Hoorn clausules door toe te staan dat sommige predicaten, verklaard als constraint predicaten, voor te komen als literalen in het lichaam van de clausules. Een constraintlogic-programma is een verzameling van clausules in de vorm:

H :- C1, …, Cn B1 B1, …, Bn.

waar H en alle Bi atomaire formules zijn, en de Ci beperkingen zijn. Declaratief worden dergelijke clausules gelezen als gewone logische implicaties:

H indien C1 en … en Cn en B1 en … En Bn.

echter, terwijl de predicaten in de heads van clausules worden gedefinieerd door het constraintlogic-programma, worden de predicaten in de constraints vooraf gedefinieerd door een domeinspecifieke modeltheoretische structuur of theorie.

procedureel worden subdoelen waarvan de predicaten door het programma worden gedefinieerd, opgelost door doelreductie, zoals in gewone logica programmering, maar beperkingen worden gecontroleerd op bevrediging door een domein-specifieke constraint-solver, die de semantiek van de constraint predicaten implementeert. Een eerste probleem wordt opgelost door het te reduceren tot een bevredigende combinatie van beperkingen.

het volgende constraint logic programma vertegenwoordigt een toy temporal database van john ‘ s geschiedenis als leraar:

teaches(john, hardware, T) :- 1990 ≤ T, T < 1999.teaches(john, software, T) :- 1999 ≤ T, T < 2005.teaches(john, logic, T) :- 2005 ≤ T, T ≤ 2012.rank(john, instructor, T) :- 1990 ≤ T, T < 2010.rank(john, professor, T) :- 2010 ≤ T, T < 2014.

Hier ≤ en < zijn constraint predicaten, met hun gebruikelijke bedoelde semantiek. De volgende doelzin vraagt de database om uit te vinden wanneer john zowel logica onderwees als professor was:

:- onderwijst(john, logica, T), rang(john, professor, T).

de oplossing is 2010 ≤ T, T ≤ 2012.

Constraint logic programming is gebruikt om problemen op te lossen op gebieden als civiele techniek, werktuigbouwkunde, digitale circuitverificatie, geautomatiseerde dienstregeling, luchtverkeersleiding en financiën. Het is nauw verwant aan abductive logic programming.

Concurrent logic programmingdit

Concurrent logic programming integreert concepten van logica programmeren met gelijktijdig programmeren. Zijn ontwikkeling kreeg een grote impuls in de jaren 1980 door zijn keuze voor de systemen programmeertaal van de Japanse vijfde generatie Project (Fgcs).

een gelijktijdig logisch programma is een verzameling van bewaakte Claxon-clausules in de vorm: H :- G1, …, Gn / B1, …, Bn.

het voegwoord G1,… , Gn wordt de bewaker van de clausule genoemd, en / is de commitment operator. Declaratief worden bewaakte Hoornclausules gelezen als gewone logische implicaties:

H als G1 en … en Gn en B1 en … En Bn.

echter, procedureel, wanneer er meerdere clausules zijn waarvan de heads h overeenkomen met een bepaald doel, dan worden alle clausules parallel uitgevoerd, waarbij wordt gecontroleerd of hun guards G1, … Gn, wacht. Als de bewakers van meer dan één clausule houden, dan wordt een toegewijde keuze gemaakt om een van de clausules, en de uitvoering gaat met de subdoelen B1, …, Bn van de gekozen clausule. Deze subdoelen kunnen ook parallel worden uitgevoerd. Dus simultaneous logic programming implementeert een vorm van” don ’t care nondeterminism”, in plaats van”don’ t know nondeterminism”.

bijvoorbeeld, het volgende gelijktijdige logische programma definieert een predicaat shuffle (Links, Rechts, samenvoegen), die kan worden gebruikt om twee lijsten links en rechts te shuffelen, door ze te combineren in een enkele lijst samenvoegen die de volgorde van de twee lijsten links en rechts behoudt:

shuffle(, , ).shuffle(Left, Right, Merge) :- Left = | Merge = , shuffle(Rest, Right, ShortMerge).shuffle(Left, Right, Merge) :- Right = | Merge = , shuffle(Left, Rest, ShortMerge).

hier, vertegenwoordigt de lege lijst, en vertegenwoordigt een lijst met eerste element Head gevolgd door list Tail, zoals in Prolog. (Merk op dat het eerste voorkomen van | in de tweede en derde clausule de lijstconstructeur is, terwijl het tweede voorkomen van | de verplichtingsexploitant is.) Het programma kan bijvoorbeeld worden gebruikt om de Lijsten door elkaar te schuiven en door de doelzin aan te roepen:

shuffle(, , Merge).

zal het programma niet-deterministisch een enkele oplossing genereren, bijvoorbeeld Merge = .

Het is mogelijk dat het gelijktijdig programmeren van logica gebaseerd is op het doorgeven van berichten, dus het is onderworpen aan dezelfde onbepaaldheid als andere gelijktijdige systemen voor het doorgeven van berichten, zoals acteurs (zie onbepaaldheid in gelijktijdige berekening). Carl Hewitt heeft betoogd dat het gelijktijdig programmeren van logica niet gebaseerd is op logica in zijn zin dat computationele stappen niet logisch kunnen worden afgeleid. Echter, in gelijktijdige logica programmering, elk resultaat van een eindigende berekening is een logisch gevolg van het programma, en elk gedeeltelijk resultaat van een gedeeltelijke berekening is een logisch gevolg van het programma en het resterende doel (proces netwerk). Aldus impliceert de onbepaaldheid van berekeningen dat niet alle logische gevolgen van het programma kunnen worden afgeleid.

Concurrent constraint logic programmingdit

gelijktijdig constraint logic programming combineert gelijktijdig logisch programmeren en constraint logic programming, waarbij beperkingen worden gebruikt om concurrency te controleren. Een clausule kan een guard bevatten, wat een reeks beperkingen is die de toepasselijkheid van de clausule kunnen blokkeren. Wanneer aan de guards van meerdere clausules is voldaan, maakt het gelijktijdig programmeren van constraint logic een gecommitteerde keuze om er slechts één te gebruiken.

inductieve logica programmedit

inductieve logica programmeren houdt zich bezig met het veralgemenen van positieve en negatieve voorbeelden in de context van achtergrondkennis: machine learning van logische programma ‘ s. Recent werk op dit gebied, dat logica programmeren, leren en waarschijnlijkheid combineert, heeft geleid tot het nieuwe gebied van statistisch relationeel leren en probabilistische inductieve logica programmeren.

hogere-orde logic programmingdit

verschillende onderzoekers hebben logic programming uitgebreid met hogere-orde programmeerfuncties afgeleid van hogere-orde logica, zoals predicaat variabelen. Dergelijke talen omvatten de Prolog extensies HiLog en λProlog.

Linear logic programmingdit

het baseren van logic programming binnen de lineaire logica heeft geresulteerd in het ontwerp van logic programming languages die aanzienlijk expressiever zijn dan die gebaseerd op klassieke logica. Horn-clausule programma ‘ s kunnen alleen statusverandering weergeven door de verandering in argumenten naar predicaten. In lineaire logica programmering, kan men de omringende lineaire logica gebruiken om toestandsverandering te ondersteunen. Sommige vroege ontwerpen van logische programmeertalen gebaseerd op lineaire logica zijn LO, lolli, ACL en Forum . Forum biedt een doelgerichte interpretatie van alle lineaire logica.

Object-oriented logic programmingdit

F-logic breidt logisch programmeren uit met objecten en de frame syntaxis.

Logtalk breidt de Prolog programmeertaal uit met ondersteuning voor objecten, protocollen en andere OOP Concepten. Het ondersteunt de meeste standaard-compliant Prolog systemen als backend compilers.

Transactielogica programmedit

Transactielogica is een uitbreiding van logica programmeren met een logische theorie van state-modifying updates. Het heeft zowel een modeltheoretische semantiek als een procedurele. Een implementatie van een subset van Transactielogica is beschikbaar in het Flora-2 systeem. Andere prototypes zijn ook beschikbaar.