AI - Lisp / Laboration 1 - Inledande Lisp - rekursion 1 LABORATION 1 Inledande Lisp - rekursion 1.0 LABFÖRORD Detta labbmaterial ger dig introduktion till Lisp för att kunna använda programmeringsspråket för AI-laborationer. Den dialekt du lär dig här är Common Lisp, som är ett mycket stort språk och innehåller allt det som programmeringsspråk i allmänhet innehåller. Dessutom använder vi Lisp som första programmeringsspråk på flera av våra datautbildningar. Där använder vi språket som ett verktyg för att studera principer för programmering med progam- och dataabstraktion som huvudteman samt en mer fullständig genomgång av imperativa konstruktioner som vi återfinner i de flesta andra språk. Vi förutsätter här att alla har programmerat i ett imperativt språk (C, C++, Ada, Java etc), vilket gör att man skall känna till många generella programspråksbegrepp. I denna kurs kommer vi emelllertid att mest koncentrera oss på s k funktionell programmering där rekursion är det nya. Ofta är det svårt för en del i början, men ses senare som ett helt naturligt sätt att konstrukera program, speciellt när man skall hantera träd- och grafstrukturer. Dessuotm använder vi listan som den grundläggande datastrukturen, där ni i de flesta andra programmeringsspråk använder arraystrukturer och poster. Uppgifterna i detta häfte är märkta som Övning eller UPPGIFT. Det är UPPGIFTerna som skall redovisas. 1.1 ATT KOMMA IGÅNG Lispsystemet vi använder heter Allegro. Systemet körs med Emacs som editor. Allt om Allegro, kopplingen med Emacs och den speciella programmeringsomgivningen Composer finns beskrivet i ett separat dokument på kursens hemsida. Detta dokument skall studeras noggrant både nu i början och successivt under laborationsseriens gång. Dessutom skall du redan nu se till att du kan komma åt kursens www-sidor. Du skall ha som vana att ha på en webbrowser med Steele s Common Lisp the Language 2nd Edition - en online manual för Common Lisp där du enkelt kan komma åt beskrivningar av alla funktioner och begrepp. 1.2 UPPMJUKNING Läs kapitel 2 i läroboken. Vi börjar med lite uppvärmningsövningar. Skriv in följande uttryck och försök att i förväg räkna ut vad Lisp'en kommer att svara. Gör gärna om uttrycket till vanlig infix form först. 12-12 1/3 ; Bråk (+ 12 45) (+ 12 45 78) ; Godtyckligt antal argument (+ 12 (- 45)) ; Unärt minus (+ 12 (- 45 78)) ; Binärt minus (1+ (* 2 3)) (1- (+ 2 3))
2 AI - Lisp / Laboration 1 - Inledande Lisp - rekursion (/ 35 13) (/ 35.0 13.0) (/ 35 5) ; Heltal (/ 34 5) ; Bråk (float (/ 34 5)) ; Flyttal (- (/ 1 (/ (+ 2 3) (* 4 5))) 6) 1.3 INFIX FORM TILL PREFIX FORM Dags att fortsätta, men nu går vi åt andra hållet: Gör om följande aritmetiska uttryck från infix form till Lisp s prefix form. Skriv sedan in dem till Lisp och kontrollera att resultatet blir rätt. INFIX FORM LISP-FORM 1+2. 3 (1+2). 3 2. 4+(6-8) 5 + ( 3 + 4) ------------------------------- 6 + -- 2 5 1.4 DEFINITION AV FUNKTIONER Gick allt bra? Utmärkt, då kanske det är dags att införa egna funktioner med defun. Övning 1.4a. Definiera en funktion average med två argument x och y som returnerar medelvärdet av x och y. (average 3 7) => 5 (average 1 2) => 3/2 ; dvs 1.5 Övning 1.4b. Definiera en funktion my-max med två argument, om returnerar det största av argumenten. (my-max 3 7) => 7 1.5 REKURSION Läs kapitel 3 i boken. Två viktiga begrepp införs: rekursiv och iterativ processlösning. Övning 1.5a. Definiera "upphöjt till"-funktionen. Kalla den pow och låt den ha två heltalsargument. Definiera två varianter, en som utför en rekursiv och en som utför en iterativ processlösning. Utför substitutionsmodellen och använd trace för att förstå beräkningen bättre. (pow 2 3) = 2 3 = 2*2*2 => 8 (pow 5 2) = 5 2 = 5*5 => 25 Tips: Vad som helst upphöjt till 0 är alltid 1.
AI - Lisp / Laboration 1 - Inledande Lisp - rekursion 3 Övning 1.5b. Definiera en funktion add-to som adderar ihop de n första heltalen, dvs. (add-to n) = 1 + 2 +... + n. Gör två versioner, med en rekursiv och en iterativ processlösning. (add-to 6) => 21 (add-to 0) => 0 Övning 1.5c. Vill du lösa en lite större uppgift kan du ta övning 2.8.E ur läroboken. Skriv en funktion dagar som räknar ut antalet dagar mellan två datum. Vi anger ett datum som ett heltal på formen yymmdd. Använd primitiver för att ta ut delarna, dvs år, månad och datum, ur datumet. (dagar 19931215 19940110) => 26 Hjälp: Räkna ut antalet dagar från år 1900 för båda datumen och ta absolutbeloppet på skillnaden. Övning 1.5d. om-funktionen. Se övning 3.3.D i läroboken. Innan du tittar i lösningen, fundera på problemet. Skriv in funktionerna och testa för att komma underfund med vad som händer. Jämför med andra språk. Är det samma problem där? 1.6 SYMBOLISKA UTTRYCK Dessa övningar berör avsnitt från läroboken kapitel 4, 5 och 6. Här införs de viktigaste datatyperna för Lisp, symbolen och listan. Dessutom införs quote eftersom program och data både representeras som listor. I kapitel 4 finns en stor mängd med fördefinierade funktioner. I kapitel 6 beskrivs olika rekursiva mallar för bearbetning av listor och binära träd. Övning 1.6a. Prova att skriva in följande S-uttryck till Lisp'en. Fundera i förväg ut vad Lisp'en bör svara. (setq a 123) a (quote a) 'a (+ a 17) '(+ 1 17) (setq a 'b) a '(hej hopp ditt feta nylle) '(quote x) ''x "Kalle Pettersson" 'Kalle\ Pettersson ' Kalle Pettersson 1.7 GRUNDLÄGGANDE LISPFUNKTIONER Titta igenom sammanställningarna av LISP-funktioner i avsnitt 4.6 och 4.10 i läroboken. Sök även efter funktionerna både i Common Lisp manualen som finns on-line i Allegro och den som finns på www. Prova och testa.
4 AI - Lisp / Laboration 1 - Inledande Lisp - rekursion Övning 1.7a. Vad blir resultaten? (first '(one two three)) (car '(one two three)) (rest (first '((one two) three four))) (cdr (car '((one two) three four))) (cdar ((one two) three four))) (second '(one two three)) (cadr (one two three)) (cons '(eva lisa) '(karl sven)) (list '(eva lisa) '(karl sven)) (append '(eva lisa) '(karl sven)) (remove 'sven '(eva sven lisa sven anna)) (subst 'gittan 'birgitta '(eva birgitta lisa birgitta karin)) (make-list 5) (make-list 5 :initial-element 'start) (copy-list '(a new list)) (intersection '(a b c) '(x b z c)) (union '(a b c) '(x b z c)) (last '(karl adam nilsson)) (butlast '(karl adam nilsson)) (butlast '(a b c d e) 3) (nthcdr 2 '(a b c d e)) (nth 2 '(a b c d e)) (assoc 'tre '((ett. one) (två. two) (tre. three))) 1.8 SEKVENSIELL BEARBETNING Här behövs mycket träning. Läroboken innehåller i avsnitt 6.1 mallar för sekvensiell bearbetning, dvs vi går igenom en lista element för element. Dessutom finns många exempel och övningar. Utför substitutionsmodellen på några exempel så förstår du rekursionen bättre. Vid testning på dator kan du göra trace på funktionerna så kan du följa de successiva rekursiva anropen med värden på parametrarna och de beräknade värdena. Övning 1.8. Skriv en funktion summera-endast-tal som summerar de element som är tal på en lista. (summera-endast-tal '(a 1 b (b 4) 2 3)) => 6 Övning 1.8b. Skriv en funktion ta-bort-vokaler som tar en lista med bokstäver och returnerar en ny lista med vokalerna borttagna. (ta-bort-vokaler '(b i r g i t t a)) => (b r g t t) Övning 1.8c. Skriv en funktion finns-bokstav? som returnerar ett sant värde om en given bokstav finns i ett ord, Ordet har representerats som en lista av bokstäver. (finns-bokstav? 'u '(h u s)) (finns-bokstav? 'a '(b i l)) => nil Övning 1.8d. Hantering av mängder. Definiera mängdoperationerna union (kalla den t ex min-union, ty det finns redan en Common Lisp funktion som heter union), snitt och differens. Definiera även en operation lägg-till som lägger till ett element till en mängd, samt en operation medlem? som undersöker om ett element är medlem i en mängd. Se listan som en mängd. (setq ettor (sven lisa peter anna karl)) (setq fotboll (lisa eva karl sven)) (setq teater (karin lisa peter nisse eva)) (setq alla (min-union ettor (min-union fotboll teater)))
AI - Lisp / Laboration 1 - Inledande Lisp - rekursion 5 Vilka ettor spelar fotboll och kan bilda lag med Ravelli. (lägg-till ravelli (snitt ettor fotboll)) Vilka ettor har intresse? (snitt ettor (min-union fotboll teater)) Är Eva ej en etta och med ett intresse (medlem? eva (differens (min-union fotboll teater) ettor)) 1.9 DUBBELREKURSION - SEKVENSIELL BEARBETNING Läs avsnitt 6.1.6 i läroboken. Där visar vi mallar för att kunna bearbeta alla elementen, oavsett nivå, på en godtycklig lista, dvs när en lista i sin tur innehåller listor som element. Detta avsnitt kräver mycket övning, se exempel och övningsuppgifter i boken. Övning 1.9a. Ändra i övningen 1.8a, så att funktionerna adderar talen oavsett nivå. Kalla dem summeratal-elementen. (summera-tal-elementen '(a 1 b (b 4) 2 3)) => 10 Övning 1.9b och c. Ändra i övningarna 1.8b och 1.8c, så att funktionerna bearbetar elementen oavsett nivå. Kalla funktionerna ta-bort-alla-vokaler resp finns-någon-bokstav?. (ta-bort-alla-vokaler '((v a d) (h e t e r) ((d i n) (b i l)))) => ((v d) (h t r) ((d n) (b l))) (finns-någon-bokstav? 'e '((v e m) (s e r) (d u))) 1.10 BINÄRA TRÄD Läs avsnitt 6.2 i läroboken. Här tolkar vi listan som binära träd, dvs listan byggs upp av punkterade par. Repetera avsnitt 4.8 om punkterade par och 4.9 den grafiska representationen av liststrukturer. Detta avsnitt kräver mycket övning, se exempel och övningsuppgifter i boken. Övning 1.10a. Skriv om listan (1 (2 3)) med punkterad par-notation. Ge båda listorna som quote-ade uttryck till Lisp och se resultaten. Vad blir (cons (cons 'a 'b) (cons 'c nil)) Övning 1.10b och c. Vi tolkar listan som ett binära träd, vilket betyder att listan kan innehålla punkterade par. Vi önskar en funktion summera-tallöven, som i ett binärt träd summerar de löv som är tal och en funktion finns-tal-som-löv? som returnerar ett sant värde om åtminstone ett löv är ett tal. (summera-tallöven '(((a. 1). 3). (c. 4))) => 8 (finns-tal-som-löv? '(((a. b). (c. 4)). e)) 1.11 FORMELUTTRYCK - LOGISKA UTTRYCK Vi skall här visa hur enkelt vi kan hantera formeluttryck i Lisp. Exempel på hantering av aritmetiska formler ges i avsnitt 6.4.3. Bearbetning av formeluttrycken följer den binära träd-mallen, dvs "bearbeta vänster-deluttryck" och "bearbeta höger-deluttryck". Dessutom önskar vi hantera logiska formler. Är du inte säker på
6 AI - Lisp / Laboration 1 - Inledande Lisp - rekursion begreppen gå tillbaka till böckerna eller kompendierna i kursen Diskret matematik och logik. Försök hitta fler exempel från Diskret matematik och logik-kursen där du kan använda Lisp för att lösa dessa. Övning 1.11.a. Definiera de logiska konnektiven disjunktion ( ), konjunktion ( ) och implikation ( ) med hjälp av Commonlispfunktionen if. Kalla de nya funktionerna för my-or, my-and 1 och my-implication. (my-or t nil) (my-and nil t) => nil (my-implication nil t) Övning 1.11.b. Prefix -> infixnotation. Skriv en funktion transform som överför ett uttryck från prefix notation till infix notation. Alla operatorer är binära. (transform 10) => 10 (transform '(+ 10 7)) => (10 + 7) (transform '( (+ 10 x) (- 20 ( 2 y)))) => ((10 + x) (20 - (2 y))) Övning 1.11.c. Använd Lisp för att visa att följande propositionslogiska uttryck är tautologier. (p (p q)) q ((p q) q) p 1. I denna uppgift har vi två argument till my-and och my-or och vi beräknar båda argumenten. I Common Lisp beräknas endast så många argument som behövs för att sanningsvärdet skall kunna bestämmas. Vill man definiera dessa operatorer som i Common Lisp måste dessa definieras som makrofunktioner, se kapitel 15. I avsnitt 15.7 visas hur and (med godtyckligt antal argument) definieras som makrofunktion.
AI - Lisp / Laboration 1 - Inledande Lisp - rekursion 7 VIKTIGA BEGREPP I DENNA LABORATION: Innan du går över på uppgifterna. Tänk till om Du har förstått dessa begrepp? - Lisp-uttrycket, parentesstrukturen. - Lisp s datatyper: tal, tecken, sträng, symbol och lista. - Har du basuppsättningen av Lisp s grundläggande funktioner klart för dig? Kan du skillnaden på cons, list och append? - Quote-tecknet, när skall uttryck beräknas och när står de som konstanta dataobjekt? - Sekvenser och binära träd. Lisp's punkterade par. - Rekursiva funktioner - rekursiv och iterativ processlösning - Dubbelrekursion - sekvens- och binär trädlösning. - Rekursiv traversering av formeluttryck REDOVISNING AV LABORATIONER Vi vill att du redovisar dina laborationer på följande sätt: Programkoden: Du skall tänka på att din kod skall läsas och användas av andra personer än dig självt. - namnet på dina funktioner, parametrar och variabler skall ha mnemoniska namn, dvs namn som beskriver vad funktionen, parametern etc står för - datatypen / abstrakta datatypen skall beskrivas för dina parametrar och på värdet som funktionen returnerar - du skall skriva ut programkoden indentera på ett riktigt sätt - i de laborationer där du arbetar med delvis redan skriven kod så skall du endast redovisa de funktioner som du har skrivit. Testningen: Du skall beskriva hur du testat din funktion: - bifoga först ett antal representativa testfall som övertygar läsaren att ditt program löser den givna uppgiften. Testa inte bara med exemplen givna i uppgiften. - bifoga sedan tester på hela programmet eller för enskilda funktioner där du visar att du testat de olika typfall som kan uppstå. Här gäller det att testa specialfallen - tomma listan, binära trädet är ett löv, repetition med 0 eller maximalt antal varv samt även felaktiga testdata för att se att feltester fungerar. Genom att du angivit datatyp / abstrakt datatyp för dina parametrar så begränsar du för vilka data din funktion är definierad, och det kan då vara tillåtet att programmet går helt fel för data som ligger utanför det definierade området. - sammanställ ovanstående i ett snyggt dokument och lägg in i ett labbomslag.
8 AI - Lisp / Laboration 1 - Inledande Lisp - rekursion UPPGIFT 1A - BERÄKNING AV LOGIKUTTRYCK Skriv en funktion logikvärde som tar två argument, en propositionslogisk formel och en värdetilldelning (sant eller falskt) av de ingående propositionssymbolerna, som beräknar sanningsvärdet. Vi kan se logikvärde som en interpretator för ett logikspråk. Vi representerar värdena sant och falskt med symbolerna sant resp falskt. Propositionslogik finner du i Russel-Norvig s lärobok Artificial intelligence, A Modern Approach i avsnitt 6.4 med en sanningsvärdestabell. I övning 1.11.a har du definierat egena logiska konnektiv. Definiera en ny uppsättning sådana konnektiv som arbetar på Lispsymbolerna sant och falskt (ej som i övning 1.11.a Lispvärdena t och nil). Vi kan lagra värdetilldelningarna t ex som en associationslista. Exempel ((a. sant) (b. falskt) (c. sant)) Ett logiskt uttryck log-uttr kan skrivs som: "logisk konstant", en av värdena sant eller falskt "propositionssymbol" (t ex a, b, c, p1, p2) (icke log-uttr) (log-uttr och log-uttr) (log-uttr eller log-uttr) (log-uttr medför log-uttr) (logikvärde a ((a. sant))) => sant (logikvärde (a eller (icke a)) ((a. falskt))) => sant (logikvärde ((p1 och p2) och (icke (p3 eller falskt))) ((p1. sant) (p2. falskt) (p3. sant))) => falskt UPPGIFT 1B - FIND OCH BACKFIND Gör övning 6.3.C i läroboken. Kalla find-funktionen för t ex ed-find. Det finns redan en Common Lisp funktion som heter find. För att lösa uppgifterna kan du behöva använda felsökningshjälpmedlen. Använd trace. Se till att du inte får en lösning där du går igenom listorna mer än nödvändigt, det märker du om du studerar trace-utskrifterna. (ed-find 'y '((a b) c y d)) => (y d) (ed-find 'x '((a x b x c) x d)) => (x b x c) (ed-find x ((a b) c)) => ((a b) c) ;endast en förekomst av elementet ; fler förekomster, den första gäller ;fanns ej, ursprungslistan returneras (backfind 'x '((a (x x)) x c x d e)) ; fler förekomster, den sista önskas => (x d e) (backfind 'z '((a z) c d)) => (z) (backfind x ((a b) c)) => ((a b) c) ; endast en förekomst ;fanns ej, ursprungslistan returneras