Logikprogrammering och Prolog
• Logikprogrammeringsparadigmen
• Logikprogrammering
– Relationer
– Resolution
• Prolog
–
–
–
–
Variabler och termer
Klausuler och relationer
Kontroll
”Slutna-världen” antagandet
Relation vs avbildning
Relation
Indata
Indata
Många till många
Utdata
Många till en
Användning
• Avbildning
– Givet a bestäm m(a)
• Relation :
–
–
–
–
Relationer och avbildning
Avbildning
Utdata
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
Logikprogrammeringsparadigmen
• Den logiska paradigmen ser ett program som en
relation mellan invärde och utvärde. 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.
• 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 (funktion) mellan S och T
om för (varje) x ∈ S
existerar det ett m(x) ∈ T
T ex: sin(x)
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 i logik språk
• A0 if A1 and ... and An
– Där Ai har formen R i (...) 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 A 1 till An först bevisas.
– A0 är ett procedurhuvud och A 1 till A n dess kropp
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 A 1 and ... and An.
sådan att A 0 matchar A fortsätter vi att testa A1 till
An separat som delmål.
• Om alla lyckas drar vi slutsatsen att A är sann.
Horn-klausuler
• Vid automatisk härledning är det svårt att hantera
hela första ordningens predikatlogik.
• 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)).
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.
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.
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 =)
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)
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)
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.
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
Exempel
planet(B) :- orbits(B,sun).
?- planet(venus).
Yes
?- planet(B).
B = mercury
B = venus
…
Exemple
orbits(mercury,sun).
orbits(venus,sun)
…
?- orbits(venus,sun).
Yes
?- orbits(B,sun).
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
Exempel
append([],Xs,Xs).
append([X|Xs],Ys,[X|Zs]) :append(Xs,Ys,Zs).
• Sortering
?- append([1,2],[3,4],Zs).
• Största gemensamma delare
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]
sort(Xs,Ys) :permutation(Xs,Ys),sorted(Ys).
gcd(X,0,X).
gcd(X,Y,W) :Y \= 0,Z is X mod Y, gcd(Y,Z,W).
…
Kontroll
• Beteendet hos Prolog-program 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.
• Generellt sett har användaren (på gott och ont)
stor kontroll över effektiviteten
Kontroll, forts.
• Resolution botten-upp (forward chaining, börja i
databasen) eller top-down (backward chaining,
börja med frågan)?
• Prolog: Backward chaining.
Kontroll i Prolog
Kontroll i Prolog
• När en klausul har mer än ett mål bildar de möjliga
sökningarna/matchningarna ett sökträd. Ska sökning göras
djupet-först eller bredden-först?
• Prolog använder djupet-först sökning
• Kräver mindre resurser, men kan i elakartade fall leda till
oändlig rekursion
• 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.
• Om beviset (matchningen) av ett delmål misslyckas (givet
en viss instansiering av variablerna) måste bakåtspårning
göras
• ”Generate and test” programmeringsmetodik.
• Bakåtspårning kan avbrytas mha ”cut”, ”!”
Ex: a,b,!,c,d
• Strider mot grundidén med Prolog. Kan missbrukas p.s.s
som hopp
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
• 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
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
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å
