Logisk programmeringsparadigm

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 Relation

Indata

Avbildning

Utdata

Många till många

Indata

Utdata

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. A  B och B  C AC

A och A  C C

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: – – – –

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 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å