Logikprogrammering och Prolog Logikprogrammeringsparadigmen Logikprogrammering Relationer Resolution Prolog

Logikprogrammering och Prolog • Logikprogrammeringsparadigmen • Logikprogrammering – Relationer – Resolution • Prolog – – Variabler och termer Klausuler och relationer Kontroll ”Slutna-världen” antagandet

Logikprogrammeringsparadigmen • Den logiska paradigmen ser ett program som en relation mellan invärde och utvärde (”functor”). Den funktionella bygger på program som avbildningar. Båda är (mer eller mindre) deklarativa! • Eftersom relationer är mer generella än avbildningar skulle man kunna säga att logikprogrammering är på en högre abstraktionsnivå än funktionell och imperativ programmering. • Relationer i logikspråk har liknande betydelse som funktioner och procedurer i andra språk.

Relation vs avbildning Många till många Många till en

Relationer och avbildning • Låt S och T vara mängder. • R är en relation mellan S och T om för varje x S och y T så är R(x, y) antingen sann eller falsk. T ex: större än (>) för heltal. • m är en avbildning mellan S och T om för varje x S existerar det ett m(x) T T ex: sin(x)

Användning • Avbildning – Givet a bestäm m(a) • Relation : – – Givet a och b, bestäm om R(a, b) är sann. Givet a, finn alla y sådana att R(a, y) är sann. Givet b, finn alla x sådana att R(x, b) är sann. Finn alla x och y sådana att R(x, y) är sann

Predikatlogik • Logiken som logikprogrammering bygger på är första ordningens predikatlogik • Det är ett sätt att beskriva logiska utsagor, relationer. natural(0) n, natural(n) natural(successor(n)) • Tillsammans med inferensregler (resolution) – Ett sätt att härleda eller bevisa nya utsagor.

Logikprogrammeringsspråk • Ett notationssystem för att skriva logiska utsagor tillsammans med specificerade algoritmer för att implementera inferensreglerna. • De utsagor som man utgår ifrån (axiom) kan ses som själva logikprogrammet. • De utsagor som man vill härleda är ”input” eller som det oftas kallas frågor (”queries”) eller mål (”goal”)

Horn-klausuler • Vid automatisk härledning är det svårt att hantera hela första ordningens predikat logik. • De flesta system är begränsade till en delmängd kallad Horn-klausuler. A 1 and A 2 and … and An B natural(0). natural(x) natural(successor(x)).

Horn klausuler i logik språk • A 0 if A 1 and. . . and An – Där Ai har formen Ri(. . . ) där Ri är namnet på en relation. – Betyder att om A 1. . . An är sann så är A 0 sann. – Specialfall när n = 0. A 0. är sann. • Procedurell tolkning – För att bevisa A 0 måste A 1 till An först bevisas. – A 0 är ett procedurhuvud och A 1 till An dess kropp

Logikprogram • Ett logikprogram består av en samling Horn klausuler. – Begränsningen till Horn klausuler gör att logikprogram är implementerbara och tillåter implementationen att bli tämligen effektiv. • Beräkningen av ett program består av att testa ett givet antagande/mål (A). – Om vi kan härleda ur programmet att A är sann så säger vi att A lyckas (succeeds) annars misslyckas vi (fail). • Om vi misslyckas innebär det inte att A är falsk.

Resolution • Testningen implementeras genom resolution. • Om programmet innehåller en klausul A 0. som matchar A lyckas det. • Om programmet innehåller en klausul A 0 if A 1 and. . . and An. sådan att A 0 matchar A fortsätter vi att testa A 1 till An separat som delmål. • Om alla lyckas drar vi slutsatsen att A är sann.

Flera alternativa vägar • Om något Ai misslyckas måste vi se om det finns någon annan klausul som matchar Ai. • När ingen fler klausul matchar A har vi misslyckats. • Detta ger upphov till en sökgraf. • I logikprogrammering definieras inte hur sökningen ska gå till • I ett logikprogrammeringsspråk (Prolog) måste det definieras för att vara implementerbart

Prolog • Prolog utvecklades gradvis under 70 -talet och ett flertal dialekter uppstod. • Numera är Edinburgh-dialekten accepterad som standard. • Japan: Fifth Generation Computing System (80 -talet) • Ett Prolog program består av en samling Horn klausuler som definierar relationer. • En strikt definition av hur inferensen ska ske.

Grundläggande element • Prologs ”byggstenar” är konstanter (tal, atomer), variabler och strukturer. Listor är en speciell struktur (och strängar är en speciell sorts listor). • Atomer – Atomer har inga andra egenskaper än att de går att skilja från varandra. E x red, blue, green. . • Variabler; deklareras ej, kan vara instantierad eller oinstantierad • Strukturer – Strukturer är ”taggade tupler”. T ex data(2000, jan, 1)

Typer • Prolog är otypat. • Tal, atomer och strukturer kan användas om varandra, ingen kontroll sker • Alla värden kan jämföras med varandra (m h a =)

Strukturer • I grunden en relation (ett predikat) • Kan användas för att representera data - ses som tupler/records, eller ses som ”funktionsanrop” • ”Taggen” används för att skilja på strukturer som representerar olika data men har samma värden. (jfr konstruerare). T ex point(2, 3), rational(2, 3). • Strukturer kan vara nästade.

Listor • Listor är en delmängd av alla strukturer där – [] representerar tomma listan och – '. ' är strukturtaggen. . (1, . (2, . (3, . (4, [])))) • Förkortade skrivformer [1, 2, 3, 4] [x|xs] =. (x, xs)

Variabler • Prolog variabler betecknar ett fixt men okänt värde (ej uppdaterbart). • Börjar alltid på stor bokstav för att skiljas från strukturer och atomer. • Variabler deklareras implicit genom sin förekomst i klausuler och dess räckvidd är just den klausulen.

Termer • En term kan vara en: – – variabel numerisk literal atom struktur (innehåller termer). • Termer är argument till relationerna. – R(t 1, . . . , tn) där t 1. . . tn är termer.

Klausuler och relationer • A 0 : - A 1, A 2, . . . , An. – ": -" står för if och ", " står för and • A 0 matchar ett påstående A om det existerar en substitution av termer för variabler sådan att A 0 och A blir lika. A och A 0 kan unifieras. • age(P, Y) matchar age(david, 42) under {P = david, Y = 42} • age(P, 33) matchar age(olof, A) under {P = olof, A = 33} • Räckvidden för varje relation är hela programmet.

Exempel star(sun). star(sirius). star(betelegeus). ? - star(sun). Yes ? - star(jupiter). False

Exemple orbits(mercury, sun). orbits(venus, sun) … ? - orbits(venus, sun). Yes ? - orbits(B, sun). B = mercury B = venus …

Exempel planet(B) : - orbits(B, sun). ? - planet(venus). Yes ? - planet(B). B = mercury B = venus …

Frågor • Fråga: existerar det instanser så att frågan blir sann. • Klausuler: A 0 är sant för alla värden på variablerna sådana att A 1. . . An är sanna. • Rekursiva klausuler: element(X, [X|Ys]). element(X, [Y|Ys]) : - X == Y, element(X, Ys).

Exempel append([], Xs). append([X|Xs], Ys, [X|Zs]) : - append(Xs, Ys, Zs). ? - append([1, 2], [3, 4], Zs). Zs = [1, 2, 3, 4] ? - append([1, 2], Ys, [1, 2, 3, 4]). Ys = [3, 4] ? - append(Xs, Ys, [1, 2, 3]). Xs = [] Ys = [1, 2, 3] Xs = [1] Ys = [2, 3] …

Exempel • Sortering sort(Xs, Ys) : - permutation(Xs, Ys), sorted(Ys). • Största gemensamma delare gcd(X, 0, X). gcd(X, Y, W) : Y = 0, Z is X mod Y, gcd(Y, Z, W).

Kontroll • Beteendet hos prolog program är beror på ordningen för resolutionen. neighbor(A, B) : - neighbor(B, A). neighbor(A, B) : - planet(A), orbits(B, A). • Om det icke rekursiva fallet används först hela tiden uppstår inga problem, men om det rekursiva fallet används först uppstår oändlig rekursion.

Kontroll, forts. • Resolution botten-upp (forward chaining) eller top -down (backward chaining)? • Sökning djupet-först eller bredden-först? • (Obegränsad) bakåtspårning?

Kontroll i Prolog • Backward chaining • Högerledet testas från vänster till höger i klausulerna, och om det finns flera klausuler för en relation testas de i ordning från första till sista. • Djupet-först sökning • Bakåtspårning kan avbrytas mha ”cut”, ”!” Ex: a, b, !, c, d

Den slutna världen • Ett påstående misslyckas om vi inte kan härleda att det är sant. • Det innebär inte att det är falskt utan kan också innebära att det är okänt. • Prolog utgår från att alla relevant fakta finns i programmet, d v s allt som är sant går att härleda ur programmet. • Det kallas för den slutna-världen antagandet.

Negation • Den slutna världen innebär att Prolog inte skiljer på falsk och okänt • Negationen av något okänt blir sant star(sun). star(betelegeus). ? - not(star(sirius)). yes

Negation • Misslyckande medför att bundna variabler släpps fria. • Efter ett misslyckande kan en variabel tappa ett relevant värde. ? - star(X). X = sun ? - not(star(X)). X = _34 ? - X = 0, not(X = 1). X=0 ? - not(X = 1), X = 0. no

Logikspråk vs funktionella språk • L: relationer, F: funktioner. Relationer kan användas på flera sätt. L potentiellt ickedeterministiska. Unifiering kraftfullare än mönstermatchning • F: ofta högre ordningens funktioner • F: ofta starkt typade. L: ofta otypade • F: enklare att implementera, enklare att förstå