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 avbild-ningar. Båda är (mer eller mindre) deklarativa! Eftersom relationer är mer generella än avbild-ningar skulle man kunna säga att logikprogram-mering ä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 Relation : Givet a bestäm m(a) 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. A1 and A2 and … and An B natural(0). natural(x)  natural(successor(x)).

Horn klausuler i logik språk A0 if A1 and ... and An Där Ai har formen Ri(...) där Ri är namnet på en relation. Betyder att om A1...An är sann så är A0 sann. Specialfall när n = 0. A0. är sann. Procedurell tolkning För att bevisa A0 måste A1 till An först bevisas. A0 är ett procedurhuvud och A1 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 A0. som matchar A lyckas det. Om programmet innehåller en klausul A0 if A1 and ... and An. sådan att A0 matchar A fortsätter vi att testa A1 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: Termer är argument till relationerna. variabel numerisk literal atom struktur (innehåller termer). Termer är argument till relationerna. R(t1,...,tn) där t1 ... tn är termer.

Klausuler och relationer A0 :- A1, A2, ..., An. ":-" står för if och "," står för and A0 matchar ett påstående A om det existerar en substitution av termer för variabler sådan att A0 och A blir lika. A och A0 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: A0 är sant för alla värden på variablerna sådana att A1...An är sanna. Rekursiva klausuler: element(X,[X|Ys]). element(X,[Y|Ys]) :- X \== Y, element(X,Ys).

Exempel append([],Xs,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 Största gemensamma delare 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(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å