Föreläsning 11 i programmeringsparadigm. Negering.

Föreläsning 11 i programmeringsparadigm. Negering. Brna avsnitt 7.2. Prologs negering \+ fungerar som så att om vi har delmålet \+ p(...), så körs p(..). Om denna körnings lyckas så misslyckas \+ p(...)och tvärtom. Detta sätt att implementera negering i Prolog leder till en mängd konstigheter, speciellt om p(...) innehåller logiska variabler som vid körningen fortfarande ej är substituerade (bundna (bound)) till konstanter. Exempel som liknar bokens exempel: Program database: man(jim). man(fred). woman(x) :- \+ man(x). person(x) :- man(x). person(jane). Har vi denna databas ger frågorna man(jim), man(fred), man(jane) och man(x) vettiga svar, men frågan woman(x)ger svaret no vilket inte är det svar vi skulle få med en logisk läsning, vi vill kanske ha förslaget X = jane. woman(x) ger en körning av man(x) som lyckas med X = jim, varför woman(x) misslyckas och misslyckade körning ger inga substitutioner, bindningar. Inte heller denna definition funger bra : woman(x) :- \+ man(x), person(x). % Fungerar ej om X "unbound" Men denna fungerar bättre: woman(x) :- person(x), \+ man(x). % Fungerar. Detta beror på att när vi kör \+ man(x)så är X=jim, X=fred, eller X=jane och vi får vettiga resultat. Alltså. Konstiga svar när man kör \+ p(..) om inte de logiska variablerna i p(..) är substituerade, "bunda", när vi "kommer till" \+ p(..). Därför fungerar det ofta bättre om \+ "är långt till höger". Inför labben "Stabila äktenskap". Den procedurella läsningen av den lösning jag tänkt mig är att man först genererar man alla tänkbara kombinationer av par (detta var list-labben som förhoppningsvis redan är gjord), sedan testar man att en kombination inte är instabil med hjälp av \+. Vid instatbilitetstesten är då alla logiska variabler substituerade.

Fler icke-logiska saker i Prolog, dvs mer "non-pure Prolog". Det finns en massa saker i Prolog som överhuvud taget inte har en logisk läsning, och en del av dessa saker gör att Prolog kan användas lite mer som ett vanligt programmeringsspråk. read också write m fl för inmatning, och utmatning. Brna Interlude sid 105. \+ negering, not, se ovan. Brna 7.2 sid 6.7 is funktionell "räknemaskin" i Prolog. Brna 6.1.1 sid 54. assert m fl. Program som ändrar sig själv under körningen (livsfarligt). Brna 9.2 sid 91 findall m fl. Generar listor med lösningar som man sedan kan använda i programmet.! snitt (cut). Gör att man kan avbryta delar av "backtrackingen". Brna 9.1 sid 87. Snitt fungerar så här: a! a Exempel på vad som kan hända om a misslyckas (dvs vi "backtrackar" från a:s Fail-port). Vad som alltid händer om a misslyckas (dvs vi "backtrackar" från a:s Fail-port) och vi har ett snitt omedelbart till vänster om a. Snitt beskär delar av sökträdet. Vi kan använda snitt om vi är klyftigare än Prolog och med säkerhet vet att vissa "backtrackingar" är meningslösa för att vi vet att de ej kan producera nya lösningar. Sådana snitt kallas gröna och program med gröna snitt exekverar snabbare, men om programmet utan snitt har en logisk läsning så har programmet med snitt fortfarande samma logiska läsning. Andra snitt som påverkar körningen så att man får andra lösningar eller färre lösningar kallas röda snitt och förstör den logiska läsningen. \+ (negering, not) är implementerat med snitt på detta sätt \+ X :- X,!,fail. % kör X, lyckas det så passerar vi!, misslyckas, ingen "backtracking". \+ X. % misslyckades körningen "backtrackar" vi hit, vi lyckas.

Man kan skriva \+ X istället för \+(X) eftersom \+ räknas som en operor. Detta är ett rött snitt. Märk också att argumentet (eller operanden) till operatorn \+, dvs X, blir första delmål i högerledet, dvs "data" har plötsligt blivit "kod" eller "program"!!! Detta underlättas ju i Prolog av att sammansatta termer ("data") och delmål ("kod") ser ut på samma sätt: T. ex tall(jim) kan ju ur syntaxsynpunkt t. ex. vara både ett argument till ett predikat eller element i en lista [.., tall(jim),...], men också ett faktum tall(jim). eller ett delmål i ett högerled... :-..., tall(jim),.... När datorer uppfanns var man fascinerad av att "data" vid körningen kunde övergå till "kod" (båda sakerna är ju följder av ettor och nollor), men man kom snart på att det i de flesta fall var alldeles för anarkistiskt att skriva program på detta sätt. Även användning av assert innebär ju att "data" blir "kod". Ett exempel på grönt snitt: Detta predikat är logiskt ekvivalent med minimum(n1,n2,n1) :- N1 <= N2,!. minimum(n1, N2, N1) :- N1 <= N2. minimum(n1,n2,n2) :- N2 < N1,!. minimum(n1, N2, N2) :- N2 < N1. Vi vet ju med våra mattekunskaper att "backtracking" är onödigt eftersom de två delmålen N1 <= N2 och N2 < N1 aldrig samtidigt kan vara sanna. Predikatet med gröna snitt undviker dock meningslös "backtracking". En imperativ programmerare kan ju frestas att förenkla detta till (rött snitt) : predikatet är inte logiskt ekvivalent med minimum(n1,n2,n1) :- N1 <= N2,!. minimum(n1, N2, N1) :- N1 <= N2. minimum(n1,n2,n2). minimum(n1, N2, N2). Prova till exempel minimum(2,5,5) som felaktigt blir sant i predikatet utan!, dvs predikatet med snitt har inte längre någon logisk läsning men påminner om if.. then.. else.. i imperativa språk. I eliza nedan används snitt och sidoeffekts mål, vilket gör att programmet delvis blir som ett imperativt språk. Att lära sig allt om Prolog är säkert en kurs på minst 8 poäng, så.vi är långt ifrån full-lärda. Språket är alltså komplext, men om man lär sig mycket om Prolog kan man skriva mycket mer sofiskerade program än vad vi gjort i denna kurs. I funktionella delen av kursen har vi däremot lärt oss stora delar av vad som finns att lära oss om Haskell, eftersom Haskell innehåller färre element än Prolog, men element som p g a sin generalitet är mycket kraftfulla. För att till fullo uppskatta Haskells potential krävs nog större vana än vi hunnit få i denna kurs.

Tillämpningar av Prolog. Ur förordet i boken Bratko: Prolog Programming for Artificial Intetelligence (tredje upplagan 2001) : The truth is that Prolog is a general programming language and any algorithm can be programmed in it. The impractical orthodox schools s position (dvs att programmen alltid skall ha en logisk deklarativ läsning, "Pure Prolog") was modified by Prolog practioners who adopted a more pragmatic view, benefiting from combining the new declarative approcach with the traditional, procedural one. Om vikten av att lära sig lite om Prolog säger Bratko detta, som även kan sägas om språken i den funktionella paradigmen: Wheras conventional languages are procedurally oriented, Prolog introduces the descripteve, or declarative, view. This greatly alters the way of thinking about problems and makes learning to program in Prolog an exciting intellectual challenge. Many belive that every student of computer science should learn something about Prolog at some point because Prolog enforces a different problem-solving paradigm complementary to other programming languages. AI. Vanliga språk för AI-tillämpningar är Lisp och Prolog eller moderna utvidningar av Prolog, t ex "constraint logic programming", CLP, som kan användas för schemaläggning och planering i logistiska sytem. Med hjälp av Induktiv logikprogrammering konstrueras Prolog-program från exempel. Expertsystem. Program som är tänkta att fungera som en expert på något område som t ex program för att bevilja krediter. Sådan program tänktes utveckas av en "kunskapsingenjör" som kan Prolog som "tappar" en expert på hur denne resonerar, både kvalitativt och kvantitativt. Spelprogram. I Bratkos bok diskuteras bl a schackspelande program. I Sterling och Shapiro Mastermind, Nim och Kalah. I båda böckerna diskuteras också allmänna principer och allmänna program för spel i allmänhet. Tolkar (grammatikor). Brna kap 8. I Prolog är det fascinerande enkelt at skriva enkla program för att kontrollera syntax för (främst formella) språk och även knyta syntaxen till semantiska åtgärder. Jag har bland annat gjort tentamensuppgifter för att kolla kemiska formler som också räknar ut molekylvikter, program för att tolka de franska respektive det danska sättet ( to och halvfems ) att uttrycka tal. Ingår inte i kursen i år. Sök-problem. Djupet först inbyggd, men andra söktekniker programmeras lätt i Prolog.

Läsanvisning: Paradigmer. Lär dig vilka paradigmer det finns, vad som utmärker dem (semantik) och några exempel på språk. Se föreläsningsanteckningar 1. Viktigt att förstå varför OO används i stället för klassisk imperativ programmering, läs "Vitsen med OO" i föreläsningsanteckningarna. Läsanvisning: Funktionell programmering. Två alternativ: Jag har ju inte följt böckerna slaviskt, så att läsa förläsningsanteckningarna kan vara bra. Typklasser behandlas utförligare i föreläsningsanteckningarna 7, läs där. C&K : Introduction to Computing Alla kapitel utom 2, 6, 9,11, 12, 13. Dessa kapitel är dock lätt kursiv läsning för den intresserade. Lat evaluering behandlas ej; läs föreläsningsanteckningarna. Fokker : Functional programming : kap 1. Hela kapitlet. En del praktiska saker skiljer mellan Gofer och Hugs. Hur man kör rent praktiskt kommer förstås inte på tentan. kap 2. Hela kapitlet. Avsnitt 2.4 kan läsas som exempel på har man programmerar i Haskell, men det kommer inte några utpräglade numeriska uppgifter på tentan. kap 3. Hela kap. Avsnitt 3.3.3 om bråk och 3.4.2. sökträd kan se som exempel på hur man programmerar en ADT, men jag frågar inte på just dessa exempel. Från labbhäftet repeterara hur man skriver interaktiva program. Där finns också ett avsnitt om typer som man kan läsas som komplement till Fokker. Läsanvisning: Brna Prolog Programming. Brna Kap 1. Hela kapitlet. Brna Kap 2. Hela kapitlet. Brna Kap 3. Hela kapitlet. "Resolution tables" och "search space trees" kommer jag inte att fråga om. Jag har dock främst förklarat Prologs sätt att jobba med Byrd-boxar, se kapitel 5. Brna Kap 4. Hela kapitlet. write/1 behöver man inte kunna. Brna Kap 5. Hela kapitlet, dock inte exekverings-träd och bevisträd. Jag har dock mer ingående använt lådmodellen, se i första hand förläsningsanteckningarna. Brna Kap Interlude Practal matters. De mesta i detta kapitel lämpar sig inte för tentafrågor eller ingår inte, men det kan komma frågor på min variant av Byrd-box-modellen och dess förhållande till Sicstus trace-utskrifter, se förläsningsanteckningarna. Brna Kap 6. Hela kapitlet, dock inte bevisträd 6.4. Kapitlet innehåller tips ("schemata") om hur man tänker när man programmerar predikat för listor, tips som vi tillämpat, fast jag inte direkt har föreläst utgående från boken.

Brna Kap 7. Kunna lite om negering avsnitt 7.2 och tillräckligt om "generate and test" för att klara labbarna "Tidernas knepigaste problem", "Stabila äktenskap" och liknade tentaproblem. Brna Kap 8. Ingår ej i kursen. (Antagligen nästa år, kursen då 5 p) Brna Kap 9. Läs en del om vad snitt, cut (!) är. Även föreläsningsanteckningarna.gröna och röda snitt. Brna Kap 10. Läs 10.1 t o m 10.5. Brna Another Interlude Inpu/Output. Ingår ej i kursen Brna Kap 11. Ingår ej i kursen Brna Kap 12. Ingår ej i kursen Jag har ju inte följt boken slaviskt, så att läsa förläsningsanteckningarna kan vara bra. Ett klassiskt datorprogram : Eliza. Efter Sterling och Shapiro Program 14.15. Programmen i denna bok finns på http://www.informatik.uni-trier.de/~ley/books/sterling.html.programmet eliza finns på /info/progp02/prolog/eliza.pl (men för att få det att fungera bytte jag /== till /= i lookup). Det är ett roligt program att köra. Ett likande program skrevs 1966 av Weizenbaum. Han blev förskräckt av folks reaktioner på programmet och skrev en mycket bra bok om datorer och mänskligt vetande (Weizenbaum, J : Computer Power and Human reason. 1976.) /* Körning?- eliza. : [i, am, unhappy]. How long have you been unhappy? : [my, father, loves, me]. Please you tell me more about father : [i, am, unhappy]. How long have you been unhappy? : [since, yesterday]. Please go on. : [what, shall, i, do]. Please go on. : [i, feel, happy]. Do you often feel that way? : [bye]. Goodbye. I hope I have helped you yes */ /* eliza :- Simulates a conversation via side effects. */ % You need to type in a list of words such as [i, am,unhappy]. eliza :- read(input), eliza(input),!. eliza([bye]) :- reply([ Goodbye. I hope I have helped you ]). eliza(input) :- pattern(stimulus,response), match(stimulus,table,input), % Sophisticated multi-use match(response,table,output), % of match! reply(output), read(input1),!, eliza(input1).

/* match(patterm,dictionary,words) :- Pattern matches the list of words Words, and matchings are recorded in the Dictionary. */ match([n Pattern],Table,Target) :- integer(n), lookup(n,table,lefttarget), append(lefttarget,righttarget,target), match(pattern,table,righttarget). match([word Pattern],Table,[Word Target]) :- atom(word), match(pattern,table,target). match([],table,[]). /* pattern(stimulus,response) :- Response is an applicable response pattern to the pattern Stimulus. */ pattern([i,am,1],[ How,long,have,you,been,1,?]). pattern([1,you,2,me],[ What,makes,you,think, I,2,you,?]). pattern([i,like,1],[ Does,anyone,else,in,your,family,like,1,?]). pattern([i,feel,1],[ Do,you,often,feel,that,way,?]). pattern([1,x,2],[ Please,you,tell,me,more,about,X]) :- important(x). pattern([1],[ Please,go,on,. ]). important(father). important(sister). important(son). important(mother). important(brother). important(daughter). reply([head Tail]) :- write(head), write( ), reply(tail). reply([]) :- nl. lookup(x,[(x,v) XVs],V). lookup(x,[(x1,v1) XVs],V) :- X \= X1, lookup(x,xvs,v). /* append(xs,ys,xsys) :- XsYs is the result of concatening the lists Xs and Ys. */ append([],ys,ys). append([x Xs],Ys,[X Zs]) :- append(xs,ys,zs). Annan klassiker : Placera damer på schackbräde. Från Sterling och Shapiro. Problem: Placera 8 damer på ett schackbräde så att de ej hotar varandra. /* queens(n,queens) :- Queens is a placement that solves the N queens problem, represented as a permutation of the list of numbers [1,2,...,N] i. e.[row for column 2, row for column 2... ] */ Naivt generera-test-program: queens(n,qs) :- range(1,n,ns), permutation(ns,qs), safe(qs). % -- generate ----------------- and - test - % safe(qs) :- The placement Qs is safe. safe([q Qs]) :- safe(qs), not attack(q,qs). safe([]). attack(x,xs) :- attack(x,1,xs). attack(x,n,[y Ys]) :- X is Y+N ; X is Y-N. attack(x,n,[y Ys]) :- N1 is N+1, attack(x,n1,ys).

range(m,n,[m Ns]) :- M < N, M1 is M+1, range(m1,n,ns). range(n,n,[n]). Modifikationer för ett mycket effektivare program: queens(n,qs) :- range(1,n,ns), queens(ns,[],qs). queens(unplacedqs,safeqs,qs) :- select(q,unplacedqs,unplacedqs1), not attack(q,safeqs), queens(unplacedqs1,[q SafeQs],Qs). queens([],qs,qs). Problemet löst i Haskell (med Prologliknade körsätt) : module Queens where import Interact -- Prolog like presentation of list::[a] haskellprolog :: Show a => ([a], String) -> IO() haskellprolog ([], _) = putstr "\nno" haskellprolog (list, qv) = makeinteractiveprogram startstatus firstpromt f where firstpromt = qv ++ " = " ++ show firstsolution ++ "? " (firstsolution : startstatus) = list f:: Show a => [a] -> String -> ([a], String, Bool) f [] _ = ( [], "\nno", False) f (a:as) ";" = ( as, qv ++ " = " ++ show a ++ "? ", True) f (a:as) _ = ( as, "\nyes", False) -- 8 queens problem queens (n,qv) = (try [1..n] [] [], qv) try ::[Integer] -> [Integer] -> [Integer] -> [[Integer]] try [] [] safeqs = [safeqs] -- found one solution try [] triedqs safeqs = [] -- no solution try (q:unplacedqs) triedqs safeqs attack q safeqs = res2 otherwise = res1 ++ res2 where res1 = try (triedqs++unplacedqs) ([]) (q:safeqs) res2 = try (unplacedqs) (q:triedqs) (safeqs) attack :: Integer -> [Integer] -> Bool attack x xs = att x 1 xs where att x n [] = False att x n (y:ys) = x == y+n x == y-n att x (n+1) ys -- Körning: Queens> haskellprolog (queens(8, "Rs")) Rs = [4,2,7,3,6,8,5,1]? ; Rs = [5,2,4,7,3,8,6,1]? ; Rs = [3,6,4,2,8,5,7,1]? yes

Fikitiv tenta, prologdel. 1. a) Skriv ett Prolog-predikat för double/2 : % double(list, ListLIst) varje element i List finns två gånger i % ListList dvs double([1, 2, 3], [1, 1, 2, 2, 3, 3]) är sant. b) Vad ger Prolog för körresultat om du ställer frågan :?- double([1, 2, 3], Rs). c) Vad ger Prolog för körresultat om du ställer frågan :?- double(rs, [1,1,2,2,3,3]). d) Vad ger Prolog för körresultat om du ställer frågan :?- double(rs, [1,1,2]). 2. Skriv ett program för select(x,harxs,ettmindrexs) med betydelsen att listan EttMindreXs är resultat av att en förekomst av X har tagits bort från HarXs. 3. Skriv ett Prolog-predikat för twiceinlist/2: % twiceinlist(x, Xs) Elementet X förkommer minst två gånger i Xs. 4. Vad avses med ett prologprogram som gör "generate-and_test"? Hur kan sådana program ofta fås att exekvera fortare? 5. Rena Prolog program ("pure Prolog") 1) Har bara en deklarativ (logisk) läsnig X) Har både en deklarativ och en procedurell läsning 2) Har bara en procedurell läsning För att förstå Prolog program med röda snitt! 1) Måste man göra en deklarativ (logisk) läsnig X) Måste man göra en procedurell läsning 2) Är obegripliga. "Backtracking" kan innebära att 1) Att Prolog försöker på nytt att få ett delmål (subgoal) att lyckas om efterföljande delmål har misslyckats. X) Att Prolog använder klausulerna i ett predikat i omvänd ordning. 2) Att Prolog traverserar elementen i en lista i omvänd ordning. Logiskt och (konjunktion) skrivs i Prolog med 1) :- X) ny klausul 2), Logiskt eller (disjunktion) skrivs i Prolog med 1) :- X) ny klausul 2), 6. Bestäm om följande unifieringar misslyckas eller lyckas, och i det senare fallet vilka substitutioner som görs. house(red, Nat, dog, water, Cig) = house(y, noweigan, Z, water, Cig1). p(x, [X Xs], f) = p(f, Zs, Y). p(x, [X Xs], g) = p(f, Zs, X). 3 = 2+1.

Svar fikitiv tenta, prologdel. double([], []). -- 1a) double([x Xs], [X,X Zs]) :- double(xs, Zs). Rs = [1,1,2,2,3,3]? ; no -- b Rs = [1,2,3]? ; no -- c no -- d labbupgift, inget svar här -- 2 twiceinlist(x, Xs) :- select(x, Xs, WXs), select(x, WXs, WWXs) -- 3 genmerate_and_test(svar) :- generate(svar), test(svar). -- 4 Effektivisering: Flytta delar av testet in i generatorn. generate(r). Föreslår en massalösningar test(y). Tillåter bara BaraTillåtnaLösningar XX12X --5 Y = red, Z = dog, Nat = noweigan, Cig1 = Cig -- 6 X = f, Y = f, Zs = [f Xs] unifierar ej unifierar ej