Logisk programmeringsparadigm

advertisement
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å
Download
Random flashcards
Create flashcards