Föreläsning 7-8

Logik med tillämpningar97-11-18

Innehåll

Predikatlogik, relationer, formler Logikprogrammering Kapitel 3.1-3.4 i Ben-Ari Kapitel 1-3 i Shapiro

Satslogiken är för ”grov”

Försök uttrycka detta i satslogik:Alla män är dödliga.Sokrates är en man.Därför är Sokrates dödlig

Intuitivt förstår vi att utsagan är valid men i satslogiken skulle formeln se ut så här:A SD och det är inte en valid formel.

Samma sak i predikatlogik:

x(man(x) dödlig(x))man(Sokrates)dödlig(Sokrates)

Hela implikationen uttrycks som man(Sokrates) x(man(x) dödlig(x)) dödlig(Sokrates)

Relationer och predikat En n-relation är en delmängd av den kartesiska

produkten D1 x ... x Dn där varje Di är en mängd. Definition (3.1.1)

D är en mängd. R är en n-relation på domän D om R är en relation på Dn.

R är en n-relation på domän D. Predikatet R associerat med R är:

R(d1,..., dn) = T omm {d1,..., dn}R

Det vi har lärt oss om satslogiken kan nu överföras på predikatlogiken.

Vi har infört domäner och predikat, vilket komplicerar detaljerna, men de underliggande mekanismerna kvarstår.

För att undvika att behöva referera till element i specifika domäner inför vi kvantifierare för att kunna uttrycka att ett predikat är sant för några eller alla element i en domän.

Definition (3.2.1) är allkvantor och uttalas "för alla", är existens-kvantor och uttalas "det existerar". I en kvantifierad formel som (x A) kallas x för kvantifierad variabel eller bunden variabel och formeln A är räckvidden för x. x måste inte förekomma i A.

Kvantifierare binder lika starkt som negation

Exempel på formler

xy(p(x, y) p(y, x))

y p(x, y)

xy(p(x) p(y))

xp(a, x)

Definition:Låt A vara en formel, x en variabel och a en konstant. A[xa] är en substitution av a för x i A, och definieras induktivt:

Om A är en atomisk formel (predikat, variabel eller konstant), byt ut alla x mot a i A.

Om A = B, A[x a] = B[x a]Om A = B op C, A[x a] = B[x a] op C[x a]Om A = xB, A[x a] = A. Lika för A = xB.Om A = yB, y x, A[xa] = yB[x a]. Lika för A = xB.

Definition (3.2.3)Om A[x a] A, dvs subtitutionen av a för x i A har medfört en förändrad formel, så kallas x för en fri variabel i A.En formel utan fria variabler är stängd.

Lemma (3.2.4)Om A är en stängd formel så är även A [x a] stängd.

Fria variabler och stängda formler

Instansiering

Definition (3.2.5)xA(x) är en kvantifierad formel och a är en konstant. A[x a] eller A(a) är en instans av xA(x). Att substituera en konstant för en kvantifierad variabel kallas för instansiering.

Definition: A är en formel och {P1, …, Pn} är alla predikat i A och {a1, ..., ak} är alla konstanter i A. En interpretation (tolkning) I är en trippel

(D,{R1, ..., Rn}, {d1, …, dk})

innehållande: D, en icke-tom domän. En tilldelning av en n-relation Ri på D till varje n- predikat pi

En tilldelning av ett element dj D till varje konstant aj.

Definition (3.3.3)A är en stängd formel. v(A), värdet av A under en tolkning I, fås genom att först ersätta varje konstant i A med motsvarande element ur I, och därefter genom induktion över A:– Om A = pi(c1, …, cn) är en atomisk formel (inga variabler) så

är v(A) = T omm {c1, ..., cn} Ri, där Ri är den relation som tilldelats pi av I.

– v(A1) = T omm v(A1) = F.

– v(A1 op A2) följer sanningstabellen för op.

– v(xA1) = T omm för alla c D, v(A1[x c]) = T.

– v(xA1) = T omm för något c D, v(A1[x c]) = T.

Modeller, satisfierbarhet,validitet

Definition (3.3.4)A är sann för I, eller I är en modell för A, om v(A) = T under I. Notation IA

Definition (3.3.5)En formel A är satisfierbar om det finns en tolkning I så att I A. A är valid om I A för alla tolkningar I. Notation A.

Sanningsvärden för öppna formler då?

Teorem 3.3.7 säger:– En öppen formel är satisfierbar omm dess

existensial closure är satisfierbar.– En öppen formel är valid omm dess

universial closure är valid.

Figur 3.2 i Ben-Ari är viktig!

För att kunna göra substitutioner måste antalet fria variabler vara detsamma i båda formlerna.

Kvantifikatorerna kan definieras i termer av varandra:

xA(x) xA(x)xA(x) xA(x)xA(x) xA(x)

Logikprogrammering De flesta programspråk utgår ifrån von

Neumanns maskinmodell, dess instruktioner och dess begränsningar när de skapas.– Arbetet delas upp på flera personer: de som löser

problemet och de som implementerar lösningen. Logikprogrammering börjar med ett abstrakt

tänkande som inte är beroende av en viss datormodell.– Enda begränsningen är det mänskliga tänkandet...

Logikprogrammering

I det utopiska fallet:– Program = mängd av axiom som beskriver

kunskapen som finns om problemet tillsammans med gjorda antaganden

– Beräkning = programmet löser ett problem genom att producera ett konstruktivt bevis av formeln som beskriver problemet

Ett programs uppbyggnad Ett program består av en mängd satser. Det

finns tre typer av satser:– Fakta– Regler– Frågor (kallas även mål)

Ett fakta talar om att det existerar en relation mellan objekt. Kallas även predikat.Ex:mother(eva, kain). % Eva är mor till Kain.

Uppbyggnad forts… Om man vill fråga om Eva är mor till Kain

skriver man mother(eva, kain).

och trycker return. Svaret man får i detta fall är yes.

Frågor och fakta ser syntaktiskt likadana ut men kan skiljas åt av kontexten.

Programmet kontrollerar om frågan är en logisk konsekvens av programmet.

Logisk variabelplus(0, 0, 0). plus(0, 1, 1). plus(1, 0, 1).plus(0, 2, 2). plus(2, 0, 2). plus(1, 1, 2).…plus(X, Y, 2). plus(X, X, 2)X = 0, Y = 2; X = 1;X = 2, Y = 0; noX = 1, Y = 1;no

Variabler kan summera fakta också:

plus(0, X, X) times(0, X, 0) Variabler som bara förekommer en gång i ett

fakta eller en regel kan göras anonyma:times(0, _, 0)

Term

En term definieras induktivt:– konstanter och variabler är termer– en sammansatt term består av en funktor och

argument En term som inte innehåller variabler kallas för

en grund term.

Regler Man kan definiera nya relationer ur gamla med

hjälp av regler:man(kain).man(adam).kvinna(eva).

far(adam, kain).mor(eva, kain).

förälder(X, Y)far(X, Y).förälder(X, Y)mor(X, Y).

son(X, Y)förälder(Y, X), man(X).

Logikprogram består av klausuler med högst en positiv literal: B1 ... Bn A Vi skriver normalt dessa klausuler på formen A B1, ..., Bn. Den positiva literalen (A) kallas för huvud, och de negativa (Bi) för kropp. En enhetsklausul A. kallas för fakta (då inget behöver vara uppfyllt för att den ska vara sann). En klausul utan huvud kallas för mål.

B1, …, Bn.

Program, procedur, databas

Ett program består av ett antal procedurer. En procedur är en mängd regler och fakta med

samma predikatnamn. Om proceduren består av enbart grunda fakta

(utan variabler) kallas den för en databas.

Frågor Grunda frågor - inferens genom identitetplus(0, 2, 1) plus(0, 2, 2)no yes

Existensiella frågor - inferens genom generalisering plus(0, X, 2)X plus(0, X, 2)X = 2;no

Konjunktiva frågor mor(anna, X), mor(X, Y).

Universella fakta

Variabler är förstås användbara i fakta också, där är de dock implicit allkvantifierade.

plus(0, X, X).x plus(0, X, X)

Inferens genom instansiering: xp(x) p(a)

Regler Intressanta konjunktiva frågor introducerar nya relationer:mormor(X,Y):- mor(X,Z),mor(Z,Y).

Disjunktiva regler - alternativa regler:dotter(X, Y):- far(Y, X), kvinna(X).dotter(X, Y):- mor(Y, X), kvinna(X).

Rekursiva reglerforfader(X, Y):-

foralder(X, Z),forfader(Z, Y).

forfader(X, X).

Definition: Meningen med ett logikprogram P, M(P), är mängden grunda enhetsmål härledbara från P.

Definition: Ett program P är korrekt i hänseende till en tänkt mening M om meningen med P, M(P), är en delmängd av M. D.v.s. ett korrekt program säger inte saker som inte var tänkt.

Definition: Ett program P är komplett i hänseende till en tänkt mening M, om M är en delmängd av M(P). D.v.s. ett komplett program säger allt som är tänkt.

Listor Listan är den fundamentala rekursiva strukturen

inom logikprogrammering. Tomma listan, kallad nil, betecknas här med []. Vi behöver också en listkonstruerare, en funktor

av aritet två. Historiskt betecknas den med "." Vi betecknar dock .(X,Y) med [X | Y]. X kallas huvud och Y kallas svans. list([]). list([X | Xs]) :- list(Xs).

Formellt objekt Cons-par Syntax.(a,[]) [a | []] [a].(a,.(b,[])) [a | [b | []]] [a, b].(a,.(b,.(c,[]))) [a | [b | [c | []]]] [a, b, c].(a,X) [a | X] [a | X].(a,.(b,X)) [a | [b| X]] [a, b | X]

Member

member(X, [X | Xs]). member(X, [Y | Ys]) :- member(X, Ys).

Exempel på frågormember(b,[a, b, c]).member(X, [a, b, c]). member(b, X).

Att skriva logikprogram

Hur skriver vi då ett logikprogram, som exempelvis delete, som givet frågan

delete([a,b,c,b] ,b ,X).

returnerar det intuitivt korrekta svaret

X= [a,c]

Determinism vs ickedeterminism Givet programmet

son(X,Y) :- far(Y,X), man(X). far(olle, kalle). far(olle, pelle). man(kalle).

så kan vi visa son(S, olle) på två sätt. Vi kan först visa far(olle, S) med S=kalle och sedan man(kalle), eller vi kan visa man(S) med S=kalle och därefter far(olle, kalle).

Vilken Prolog använder vi?

Sicstus version3#6 finns uppkompilerad på alla RS6000-burkar.

Kan köras direkt i emacs… Manual finns på www:

http://www.sics.se/ps/sicstus/sicstus_toc.html Man kan antingen skriva programmet direkt i

Sicstus eller också läsa in en fil.

Enkla kommandon: Starta Sicstus Prologsicstus (vid prompten) run-prolog (i emacs)

Läsa in en textfil med namnet filename:[filename].

Spåra en körning och se hur Prolog arbetartrace.Stänga av spårningen notrace.

Avsluta Sicstus^D (dvs ctrl-D)