PrologEdit

programmeringsspråket Prolog utvecklades 1972 av Alain Colmerauer. Det framkom av ett samarbete mellan Colmerauer i Marseille och Robert Kowalski i Edinburgh. Colmerauer arbetade med naturlig språkförståelse, använde logik för att representera semantik och använde upplösning för frågesvar. Under sommaren 1971 upptäckte Colmerauer och Kowalski att den klausala formen av logik kunde användas för att representera formella grammatik och att upplösningssats provers kunde användas för tolkning. De observerade att vissa teoremprovers, som hyper-resolution, beter sig som bottom-up-parsers och andra, som SL-resolution (1971), beter sig som top-down-parsers.

det var sommaren 1972 som Kowalski, som återigen arbetade med Colmerauer, utvecklade procedurtolkningen av konsekvenser. Denna dubbla deklarativa/procedurtolkning formaliserades senare i Prolog notation

H: – B1, …, Bn.

som kan läsas (och användas) både deklarativt och procedurellt. Det blev också klart att sådana klausuler kan begränsas till bestämda klausuler eller horn klausuler, där H, B1, …, Bn är alla atompredikatlogiska formler, och att SL-upplösning kan begränsas (och generaliseras) till LUSH eller SLD-upplösning. Kowalskis procedurtolkning och LUSH beskrevs i ett memo från 1973, publicerat 1974.

Colmerauer, med Philippe Roussel, använde denna dubbla tolkning av klausuler som grund för Prolog, som genomfördes sommaren och hösten 1972. Det första Prolog-programmet, som också skrevs 1972 och implementerades i Marseille, var ett franskt svarssystem. Användningen av Prolog som ett praktiskt programmeringsspråk fick stor fart genom utvecklingen av en kompilator av David Warren i Edinburgh 1977. Experiment visade att Edinburgh Prolog kunde konkurrera med bearbetningshastigheten för andra symboliska programmeringsspråk som Lisp. Edinburgh Prolog blev de facto-standarden och påverkade starkt definitionen av ISO-standard Prolog.

Abductive logic programmingEdit

Abductive logic programming är en förlängning av normal logikprogrammering som gör att vissa predikat, deklarerade som abducerbara predikat, kan vara ”öppna” eller odefinierade. En klausul i ett abduktivt logikprogram har formen:

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

där H är en atomformel som inte är bortförbar, alla Bi är bokstäver vars predikat inte är bortförbara, och Ai är atomformler vars predikat är bortförbara. De bortförbara predikaten kan begränsas av integritetsbegränsningar, som kan ha formen:

false :- L1, …, Ln.

där Li är godtyckliga bokstäver (definierade eller bortförbara, och atomära eller negerade). Till exempel:

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

där predikatet normalt är bortförbart.

problemlösning uppnås genom att härleda hypoteser uttryckta i termer av de bortförbara predikaten som lösningar på problem som ska lösas. Dessa problem kan vara antingen observationer som måste förklaras (som i klassisk abduktiv resonemang) eller mål som ska lösas (som i normal logikprogrammering). Till exempel förklarar hypotesen normal(mary) observationen canfly(mary). Dessutom innebär samma hypotes den enda lösningen X = mary av målet att hitta något som kan flyga:

:- canfly(X).

Abduktiv logikprogrammering har använts för feldiagnos, planering, naturlig språkbehandling och maskininlärning. Det har också använts för att tolka Negation som misslyckande som en form av bortförande resonemang.

Metalogic programmingEdit

eftersom matematisk logik har en lång tradition av att skilja mellan objektspråk och metaspråk, tillåter logikprogrammering också metalevelprogrammering. Det enklaste metalogic-programmet är den så kallade ”vanilj” meta-tolken:

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

där true representerar en tom konjunktion, och klausul(A,B) betyder att det finns en objektnivåklausul i formA:-B.

Metalogic – programmering tillåter objektnivå-och metalevelrepresentationer att kombineras, som på naturligt språk. Det kan också användas för att implementera någon logik som anges som inferensregler. Metalogic används i logikprogrammering för att implementera metaprogram, som manipulerar andra program, databaser, kunskapsbaser eller axiomatiska teorier som data.

begränsning logik programmingEdit

begränsning logik programmering kombinerar Horn klausul logik programmering med begränsning lösa. Det utvidgar Hornklausuler genom att tillåta vissa predikat, deklarerade som begränsningspredikat, att förekomma som bokstäver i kroppen av klausuler. Ett begränsningslogikprogram är en uppsättning klausuler i formuläret:

H :- C1, …, CN Bisexuell B1, …, Bn.

där H och alla Bi är atomformler, och Ci är begränsningar. Deklarativt läses sådana klausuler som vanliga logiska konsekvenser:

H om C1 och … och Cn och B1 och … och Bn.

medan predikaten i huvudet på klausuler definieras av begränsningslogikprogrammet, är predikaten i begränsningarna fördefinierade av någon domänspecifik modellteoretisk struktur eller teori.

procedurellt löses delmål vars predikat definieras av programmet genom målreduktion, som i vanlig logikprogrammering, men begränsningar kontrolleras för tillfredsställelse av en domänspecifik begränsningslösare, som implementerar semantiken för begränsningspredikaten. Ett initialt problem löses genom att reducera det till en tillfredsställande kombination av begränsningar.

följande begränsningslogikprogram representerar en leksaks Temporal databas över Johns historia som lärare:

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.

här är exporten och < begränsningspredikat, med sin vanliga avsedda semantik. Följande målklausul frågar databasen för att ta reda på när john både undervisade i logik och var professor:

:- undervisar(john, logic, T), rank(john, professor, T).

lösningen är 2010 t, t 2012.

Begränsningslogikprogrammering har använts för att lösa problem inom områden som civilingenjör, Maskinteknik, digital kretsverifiering, automatiserad tidtabell, flygkontroll och ekonomi. Det är nära relaterat till abduktiv logikprogrammering.

samtidig logikprogrammeringredigera

samtidig logikprogrammering integrerar begrepp för logisk programmering med samtidig programmering. Dess utveckling fick en stor drivkraft på 1980-talet genom sitt val för systemprogrammeringsspråket för det japanska femte Generationsprojektet (FGCS).

ett samtidigt logikprogram är en uppsättning bevakade Hornklausuler i formuläret:

H: – G1, …, Gn | B1, …, Bn.

konjunktionen G1,… , GN kallas vakt för klausulen, och | är åtagandeoperatören. Deklarativt läses bevakade Hornklausuler som vanliga logiska konsekvenser:

H om G1 och … och Gn och B1 och … och Bn.

men procedurellt, när det finns flera klausuler vars huvuden h matchar ett visst mål, då alla klausuler exekveras parallellt, kontrollera om deras vakter G1,… , Gn håll. Om vakterna i mer än en klausul håller, då görs ett engagerat val till en av klausulerna, och utförandet fortsätter med delmålen B1, …, Bn av den valda klausulen. Dessa delmål kan också utföras parallellt. Således implementerar samtidig logikprogrammering en form av” bryr sig inte nondeterminism”, snarare än”vet inte nondeterminism”.

till exempel definierar följande samtidiga logikprogram en predikatblandning (Vänster, Höger, sammanslagning), som kan användas för att blanda två listor åt vänster och höger och kombinera dem till en enda listfusion som bevarar ordningen för de två listorna åt vänster och höger:

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

här representerar den tomma listan och representerar en lista med första elementhuvud följt av listsvans, som i Prolog. (Observera att den första förekomsten av | i den andra och tredje klausulen är listkonstruktören, medan den andra förekomsten av | är åtagandeoperatören.) Programmet kan till exempel användas för att blanda listorna och genom att åberopa målklausulen:

shuffle(, , Merge).

programmet genererar icke-deterministiskt en enda lösning, till exempel Merge = .

förmodligen är samtidig logikprogrammering baserad på meddelandeöverföring, så den är föremål för samma obestämdhet som andra samtidiga meddelandeöverföringssystem, såsom aktörer (se obestämdhet i samtidig beräkning). Carl Hewitt har hävdat att samtidig logikprogrammering inte bygger på logik i hans mening att beräkningssteg inte logiskt kan härledas. Men i samtidig logisk programmering är varje resultat av en avslutande beräkning en logisk följd av programmet, och varje partiellt resultat av en partiell beräkning är en logisk följd av programmet och det återstående målet (processnätverk). Således innebär obestämdhet av beräkningar att inte alla logiska konsekvenser av programmet kan härledas.

samtidig begränsningslogikprogrammeringredigera

samtidig constraint logic programming kombinerar samtidig logikprogrammering och constraint logic programming, med hjälp av begränsningar för att styra samtidighet. En klausul kan innehålla en vakt, som är en uppsättning begränsningar som kan blockera tillämpligheten av klausulen. När vakterna i flera klausuler är nöjda gör samtidig begränsningslogikprogrammering ett engagerat val att bara använda en.

Induktiv logikprogrammeringredigera

Induktiv logikprogrammering handlar om att generalisera positiva och negativa exempel i samband med bakgrundskunskap: maskininlärning av logiska program. Det senaste arbetet inom detta område, som kombinerar logikprogrammering, lärande och sannolikhet, har gett upphov till det nya fältet för statistiskt relationellt lärande och probabilistisk induktiv logikprogrammering.

högre ordningslogikprogrammeringedit

flera forskare har utökat logikprogrammering med högre ordningsprogrammeringsfunktioner härledda från högre ordningslogik, såsom predikatvariabler. Sådana språk inkluderar Prolog-tilläggen HiLog och jacobprolog.

linjär logikprogrammeringredigera

att basera logikprogrammering inom linjär logik har resulterat i utformningen av logiska programmeringsspråk som är betydligt mer uttrycksfulla än de som bygger på klassisk logik. Hornklausulprogram kan bara representera tillståndsändring genom ändring av argument till predikat. I linjär logikprogrammering kan man använda den omgivande linjära logiken för att stödja tillståndsändring. Några tidiga mönster av logiska programmeringsspråk baserade på linjär logik inkluderar LO , Lolli, ACL och Forum . Forum ger en målinriktad tolkning av all linjär logik.

objektorienterad logikprogrammeringedit

F-logic utökar logikprogrammering med objekt och ramsyntaxen.

Logtalk utökar programmeringsspråket Prolog med stöd för objekt, protokoll och andra OOP-koncept. Den stöder de flesta standardkompatibla Prolog-system som backend-kompilatorer.

Transaction logic programmingEdit

Transaction logic är en förlängning av logikprogrammering med en logisk teori om tillståndsmodifierande uppdateringar. Den har både en modellteoretisk semantik och en procedur. En implementering av en delmängd av Transaktionslogik finns i Flora-2-systemet. Andra prototyper finns också tillgängliga.