Föreläsning 12 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. Genererar lista med lösningar som man sedan kan använda i programmet. set_of Genererar sorterad lista med unika lösningar.! 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 i kursen i år, kommer senare. 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: Brna Prolog Programming. Brna Kap 1. Hela kapitlet. Brna Kap 2. Hela kapitlet, Jag tycker dock inte att AND- och OR-träd i detta kapitel och nästa förklar så mycket, jag föredrar att förklara den procedurella lösning med Box-modellen. 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 i kursen. Kommer senare när vi läser om syntaxanalys.. 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 Input/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. Ytterligare exempel. Som avslutning visar jag i dessa förläsningsanteckningar och i nästa förläsningsanteckningar som orientering några program som innehåller en del som vi inte berört så ingående eller till och med inte alls men som exemplifierar vad man kan göra med Prolog och Haskell.
Tävlingsuppgift : Anagram. I programmeringstävlingar förekommer ofta uppgifter av kombinatorisk problem, som ofta lätt kan lösas i Prolog så länge inte problemstorleken är för stor. Ett exempel: Problem 5: Anagram You are to write a program that has to generate all posible words from a given set of letters. Exempel: Given the word "abc" your program should - by exploring all different combinations of the three letters - output the words "abc", "acb", "bac", "bca", "cab" and "cba". In the word some letters may appear more than once. For a given world, your program should not produce the same word more than once, and the word should be output in alphabeticaly ascending order. Prolog-lösning: Prolog-lösning på 10 rader (på /info/progp03/anagram.hs ) som klarar tävlingsledningens näst svåraste problem, strängen zgpdcedfg : % /info/progp03/anagram.pl member(x,[x _]). member(x,[_ Ys]):-member(X,Ys). select(x,[x Ys],Ys). select(x,[y Ys],[Y Zs]):- select(x,ys,zs). permutation(xs, [Z Zs]) :- select(z, Xs, Ys), permutation(ys, Zs). permutation([], []). anagram(xs, Rs) :- setof(as, permutation(xs, As), Pss), strs_to_atoms(pss, Rs). strs_to_atoms([a As], [At Ats]):- name(at, A), strs_to_atoms(as, Ats). strs_to_atoms([], []). Variant för utskrift rad för rad: writeanas([a As]) :- name(at, A), write(at), nl, writeanas(as). write_anagrams(xs) :- setof(as, permutation(xs, As), Pss), writeanas(pss). /* Körning :?-anagram("abc", Rs). Rs = [abc,acb,bac,bca,cab,cba]? yes
*/?- write_anagrams("abc"). abc acb bac bca cab cba Körning av?- write_anagrams("zgpdcedfg"). ger 90 720 anagram. setof(as, permutation(xs, As), Pss) kör andra parametern permutation(xs, As) och samlar ihop de förslag till lösningar av det som står som första parameter As som en lista, tredje parametern Pss. Motsvarighet om vi skulle göra det själv:? - permutation(xs, As). Xs =... As = <v1> ; % Pss = [v1, v2,..., vn] As = <v2> ;... As = <vn> ; no Haskell-lösning. Haskell-lösning på 25 rader (på /info/progp03/anagram.hs) som klarar tävlingsledningens svåraste problem : anagram :: Ord a => [a] -> [[a]] -- /info/progp03/anagram.hs anagram cs = (perm1 (isort False cs) (isort True cs)) where remove :: Ord a => a -> [a] -> [a] remove _ [] = [] -- remove all x from list yys remove x (y:ys) x == y = ys otherwise = y : remove x ys perm1:: Ord a => [a] -> [a] -> [[a]] perm1 [] _ = [[]] -- special verson of permutation perm1 xs zs = [ x:ps x <- xs, ps <- anagram (remove x zs)] isort:: Ord a => Bool -> [a] -> [a] isort dupl [] = [] -- inserttion sort; dupl = remove duplicats? isort dubl (x:xs) = insert dubl x (isort dubl xs) insert:: Ord a => Bool -> a -> [a] -> [a] insert dubl x [] = [x] insert dubl x (y:ys) x == y && (not dubl) = y:ys x <= y = x:y:ys otherwise = y : (insert dubl x ys) {- Main> anagram "aabc" ["aabc","aacb","abac","abca","acab","acba","baac","baca","bcaa", "caab","caba","cbaa"] -}
För att vara med i tävlingen behövs också lite IO-programmering, ca 14 rader, för att läsa och skriva på fil: Input Specification: The input consists of several words. The first line contains a number giving the number of words to follow. Each following line contains one word. Exampel: 2 abc acb Tävlingsledningens hemliga problem finns på inputfile1: 4 abc aabc zgpdcedfg bbbbbbbbbbaaaaaaaaa Detta problem tar några minuter att köra med hugs. Resultatet på filen slask blir på 2.7 Mbyte! Filen inputfile innehåller ett lite mindre problem. -- for participation in competition input/output on files: main :: IO () main = do putstr "Ge infilens namn : " infile <- getline contents <- (readfile infile) let (n:strings) = lines contents result <- loop (read n) strings "" writefile "slask" result loop :: Int -> [[Char]] -> [Char] -> IO [Char] loop 0 _ res = return res loop _ [] res = error " wrong input file" loop i (s:strings) res = do let rs = (concat (map ( \n :) (anagram s))) loop (i-1) strings (res ++ rs) {- Main> main Ge infilens namn : inputfile -} --svaret hamnar på filen slask.