Einführung in die KI – Lisp

Präsentation zum Thema: "Einführung in die KI – Lisp"—  Präsentation transkript:

1 Einführung in die KI – Lisp
Michael Schenke | Einführung in die KI - Lisp 21/11/18 | Seite 1

2 5.1 Lambda-Ausdrücke Lambda-Kalkül

3 Einführung Als Initiator der λ-Ausdrücke gilt Alonzo Church ( ), der Doktorvater von u.a. Alan Turing, St. Kleene, M.O. Rabin. Lamda-Kalkül (Veröffentlichung 1936) „Es ist alles eine Funktion.“ Dort auch erstmals gezeigt, daß es unentscheidbare Probleme gibt. Äquivalenz des Lambda-Kalküls, der Turingmaschine und weiterer Mechanismen zum Berechnen von Funktionen. Church(-Turing)-These

4 Induktive Definition Definition
Sei eine Menge Var von Variablen gegeben. Die Menge Lλ der λ-Ausdrücke über Var ist wie folgt definiert: Jede Variable, ist ein λ-Ausdruck. Mit e1, e2  Lλ ist auch (e1 e2)  Lλ. „Anwendung“ Für x  Var, e  Lλ ist auch (λx.e)  Lλ. „Abstraktion“

5 Induktive Definition Durch Klammerregelungen (von links bei der Anwendung, von rechts bei der Abstraktion werden auch größere Ausdrücke definiert. (e1 e2 e3)  Lλ. (λxλy.e)  Lλ. Äußere Klammern werden oft weggelassen.

6 Einführung Auf der Menge Lλ sind einige Ableitungsregeln („Reduktionen“) definiert: Definition Eine Ableitungsregel der Form λx.e →α λy.eΘ heißt α-Reduktion. Dabei seien y keine freie Variable in e und Θ sei die Substitution Θ={x/y}.

7 Einführung Definition Eine Ableitungsregel der Form (λx. e1) e2 →β e1Θ heißt β-Reduktion. Dabei sei Θ die Substitution Θ={x/ e2}.

8 Einführung Ein Ausdruck der Form λ1 heißt reduzierbar auf einen Ausdruck der Form λ2, wenn es eine endliche Folge von Schritten der Form →α oder →β gibt, die λ1 in λ2 überführt. λ1 →* λ2 Die Reduktion wird also durch einen Kalkül bewerkstelligt, der aus den beiden Regeln α-Reduktion und β-Reduktion besteht. Dieser Kalkül heißt λ-Kalkül.

9 Konstruktion einer Fallunterscheidung: true = λ(x y). x false = λ(x y)
Konstruktion einer Fallunterscheidung: true = λ(x y).x false = λ(x y).y if = λ(t x y).(t x y) Zeigen Sie: if true x y →* x if false x y →* y

10 Konstruktion der Zahlen (Church-Numerale): f n (e) = e, falls n=0, f n (e) = f(f n−1 (e)), sonst. [n] =λfλx. f n (x). Zeigen Sie: succ = λnλfλx.n f (f x) definiert den Nachfolger. isnull = λn.n (λx.false) true testet, ob 0 vorliegt.

11 LISP LISt Programming

12 5.2 Lisp Einführung

13 Einführung Historisch gesehen ist Lisp zusammen mit Prolog die führende Programmiersprache der künstlichen Intelligenz. In Europa sind eher Programmiersprachen wie Assembler, Fortran oder Pascal als klassische Vertreter der Familie der prozeduralen Programmiersprachen bekannt. In den USA ist Lisp weiter verbreitet.

14 Symbolverarbeitung LISP ist eine hoch abstrakte Computersprache, deren Syntax einer simplen, listenähnlichen Struktur folgt. Man verwendet Lisp zur Symbolverarbeitung. Symbolverarbeitung ist vergleichbar mit dem Umgang mit Wörtern in formalen Sprachen.

15 Symbolverarbeitung In Lisp werden die grundlegenden aus Bits gebildeten Objekte Atome genannt und sind wortähnliche Objekte. Geordnete Ansammlungen solcher Atome bilden satzähnliche Objekte, die Listen genannt werden.

16 Symbolverarbeitung Listen können ihrerseits zu höherrangigen Listen kombiniert werden. Atome und Listen werden beide symbolische Ausdrücke oder kürzer einfach Ausdrücke genannt. Die Bearbeitung dieser symbolischen Ausdrücke wird als Symbolverarbeitung bezeichnet.

17 Geschichte Lisp steht für List Processing (Listen-Verarbeitung). Damit waren ursprünglich Fortran-Unterprogramme gemeint, mit denen symbolische Berechnungen durchgeführt werden sollten, wie sie im Lambda-Kalkül gebraucht werden. Der erste Interpreter für Lambda-Ausdrücke wurde von Steve Russell (1937- )für die IBM 740 programmiert, womit die Programmiersprache Lisp geboren war. Durch die Anwendung des Konzeptes der universellen Funktionen hat Russell letztlich das Paradigma der funktionalen Programmierung geschaffen.

18 Geschichte Die Grunddatenstrukturen von Lisp sind Einzelwerte (Skalarwerte), die Atome genannt werden, und Listen. Die Listen können beliebig verschachtelt werden (Listen von Listen). Damit lassen sich auch leicht Datenstrukturen wie ein assoziatives Array oder eine Matrix implementieren. Die Listen werden mit runden Klammern dargestellt: (A B C)

19 Lisp ist eine Familie von Programmiersprachen, die 1958 erstmals spezifiziert wurde und am Massachusetts Institute of Technology (MIT) in Anlehnung an den Lambda-Kalkül entstand. Es ist nach Fortran die zweitälteste Programmiersprache, die noch verbreitet ist.

20 Auf Basis von Lisp entstanden zahlreiche Dialekte
Auf Basis von Lisp entstanden zahlreiche Dialekte. Zu den bekanntesten zählen Common Lisp und Scheme. Daher bezieht sich der Begriff Lisp oft auf die Sprachfamilie und nicht auf einen konkreten Dialekt oder eine konkrete Implementierung.

21 Auch Programmanweisungen sind in Lisp Listen, wobei das erste Listenelement die auszuführende Funktion identifiziert. Es gibt somit keinen grundsätzlichen Unterschied zwischen Daten und Programmteilen. Diese Eigenschaft wird Homoikonizität (Selbst-Abbildbarkeit) genannt. Dies ermöglicht u. a., Programmteile zur Laufzeit beliebig zu manipulieren. weitere Beispiele für Homoikonizität : Prolog, Maschinensprachen

22 5.3 Auswahl von Sprach-elementen

23 Jedes Atom besitzt dabei einen Namen.
Atome Der elementarste LISP-Ausdruck ist das Atom. Ein Atom kann nicht weiter zerlegt werden und steht somit in LISP für eine bestimmtes Objekt oder einen Sachverhalt. Jedes Atom besitzt dabei einen Namen.

24 Gültige Namen sind zum Beispiel TOM lisp 23 23.4 michael-ist-lieb
Atome Gültige Namen sind zum Beispiel TOM lisp 23 23.4 michael-ist-lieb Mehrere Atome können durch Leerzeichen oder Zeilenvorschub voneinander getrennt werden: michael ist lieb würde also drei Atomen entsprechen.

25 Keine Atome sind alle Zeichenketten, die Klammern enthalten oder
LISP-Sonderzeichen. Die folgenden Zeichenketten sind also keine gültigen Atome: (a b c) (a a b a,b 23,4

26 Fehlermeldung: Zwei Werte zugewiesen
Definition von Atomen > (define x 23.4) > x 23.4 > (define x 23,4) Fehlermeldung: Zwei Werte zugewiesen

27 Auswertung Die Funktionen quote und eval steuern die Auswertung von Ausdrücken. quote verhindert die Auswertung, meist als ` geschrieben, eval erzwingt sie.

28 Auswertung > (quote (a b c)) (a b c) > (quote (+ 1 3)) (+ 1 3) > (eval (quote (+ 1 3))) 4

29 Kleine Übung Atome Bitte definieren Sie das Atom: t1 = 2 t2 = t1 t3 = `t1 Schauen Sie sich an, welche Werte die Atome nach der Belegung besitzen.

30 Kleine Übung Atome > (define t1 2) > t1 2 > (define t2 t1) > t2 > (define t3 `t2) > t3 `t2

31 Listen Aufbauend auf den Atomen, sind die Listen die wichtigste Struktur in LISP. Für Listen gibt es zwei verschiedene Schreibweisen:

32 Listen Einführend soll zuerst die einfache meistens benutzte Schreibweise verwendet werden. Syntax: (<ausdruck1> <ausdruck2> ... <ausdruckn>) Eine Liste beginnt und endet mit einer runden Klammer. Die Elemente einer Liste werden mit Leerzeichen voneinander getrennt und können Atome und/oder Listen sein. Die Anzahl der Listenelemente ist dabei (theoretisch) nicht begrenzt.

33 Listen Es kann auch ausdrücklich der Operator list hinzugefügt werden. > (define a `x) > (define b 1) > (define c `1) > (list a b c) (list `x 1 `1) > (list `a `b `c) (list `a `b `c)

34 Zugriff auf Listen Wie in Prolog kann man wegen der rekursiven Struktur von Listen auf den Kopf und den Rest zugreifen. > (define d (1 2 3)) > (car d) 1 > (cdr d) (2 3)

35 Zugriff auf Listen Man kann aber auch auf beliebige Elemente zugreifen. > (cadr d) 2 > (cdar d) Fehlermeldung: Das gibt es nicht. > (caddr d) 3

36 Zugriff auf Listen kleine Übung
Geben Sie (list d (list `x `y)) ein. Weisen Sie der Variablen t1 die Liste (list d (list `x `y)) zu. Greifen Sie auf das 3. Element der Liste d zu. Greifen Sie auf das 2. Element der Liste t1 zu. Welcher Befehl würde aus t1 `y herausfiltern?

37 Mit Listen arbeiten Nun folgen ein paar Funktionen, die im Umgang mit Listen immer wieder gebraucht werden. (length <liste>) bestimmt die Länge (auf der obersten Ebene) einer Liste. > (length '(a b (c d))) 3 > (length '())

38 Mit Listen arbeiten (reverse <liste>) Diese Funktion kehrt die Reihenfolge der Elemente (auf der obersten Ebene) um. > (reverse '(a b c d)) (d c b a) > (reverse '((a b) (c d))) ((c d) (a b))

39 Mit Listen arbeiten Zwei Listen können durch append verbunden werden. > (define d (1 2 3)) > (define e (4 5 6)) > (append d e) (list )

40 Abfrage (cond) cond ermöglicht es, eine Anzahl von Tests, die sequentiell, also nacheinander, abgearbeitet werden. Sobald ein Test nicht zu NIL evaluiert, wird die entsprechende Konsequenz ausgewertet und das cond mit dem Resultat der Konsequenz verlassen, die folgenden Tests werden damit nicht mehr beachtet.

41 Abfrage (cond) (cond (<Test1> (<Test2> ... (<Testn>
<Konsequenz1>) (<Test2> <Konsequenz2>) ... (<Testn> <Konsequenzn>) )

42 Abfrage (cond) Beispiel: (cond ((= A B) (* A B)) ((> A B) (- A B)))

43 Abfrage (cond) Es gehört zum guten Programmierstil, einen default-Wert T in die letzte Bedingungsklausel zu schreiben. Falls hier ein Test steht, der auch zu NIL auswertet, wertet cond insgesamt zu NIL aus. Das heißt, ein cond, in dem in keiner einzigen Bedingungsklausel ein Test zu Nicht-NIL evaluiert, liefert als Wert NIL zurück.

44 Abfrage (cond) Beispiel: (cond ((= A B) (* A B)) ((> A B) (- A B)) (#T (+ A B)))

45 5.4 Funktionen in Lisp

46 Funktionsdefinition Jede Liste kann in LISP eine Funktion sein. Da immer das erste Element als erstes evaluiert wird, kann - je nachdem, was der LISP-Interpreter dort findet - aus einer Liste sofort ein Funktionsaufruf werden. Für die Definition von Funktionen wird eine dem λ-Kalkül vergleichbare Schreibweise verwendet.

47 Funktionsdefinition (lambda <parameterliste> <funktionsrumpf>) Die Parameterliste beschreibt die Argumente des Funktionsaufrufes. Im <funktionsrumpf> können mehrere LISP- Ausdrücke stehen. Der Wert des letzten evaluierten Ausdruck wird als Wert des Funktionsaufrufes zurückgeliefert.

48 Funktionsdefinition Das Atom lambda zeigt an, daß der gesamte symbolische Ausdruck als Funktion der hinter dem λ-Ausdruck stehenden Argumente zu interpretieren ist.

49 Funktionsdefinition Beispiel: f(a,b,c,x) = a*x² + b*x + c >(define f (lambda (A B C X) (+ (* A X X) (* B X) C))) >( f ) 11

50 Alte Abfrage als Funktion
(define meine-funktion lambda(A B) (cond ((= A B) (* A B)) ((> A B) (- A B)) (#T (+ A B))))

51 Alte Abfrage als Funktion
> (meine-funktion 2 3) 5 >(meine-funktion 3 2) 1 >(meine-funktion 3 3) 9

52 Kleine Übung Pythagoras Programmieren Sie c2 = a2 + b2 2 der 3 Parameter sollen eingegeben werden, die jeweils dritte berechnet werden. Verwenden Sie dazu cond und die Strukturgleichheit (equal? a b)

53 Kleine Übung (define pythagoras (lambda(unbekannt x y) (cond ((equal? unbekannt 'a) (sqrt (- (* y y) (* x x)))) ((equal? unbekannt ‚'b) (sqrt (- (* y y) (* x x)))) (else (sqrt (+ (* y y) (* x x)))))))

54 Kleine Übung > (pythagoras 'a 3 5) 4 >(pythagoras 'b 4 5) 3 >(pythagoras 'c 3 4) 5

55 Apply Funktionsname als Wert Befindet sich in der Wertezelle eines Atoms ein gültiger Funktionsname, dann kann mittels der LISP-Funktion APPLY dieser Name als Funktionsaufruf ausgewertet werden.

56 Apply (apply <funktionsname> <argumentenliste> ) <funktionsname> ist der Bezeichner einer beliebigen (also auch System-)Funktion und <argumentenliste> ist eine Liste (!) der Argumente, die der Funktion übergeben werden sollen. Beispiel (apply + `( ))

57 Apply (define summe (lambda (liste) (apply + liste))) >(summe `(1 2 3)) 6 >(summe `( )) 21

58 In anderen Dialekten gibt es auch noch ähnliche Funktionen wie mapcar (Common lisp)
->( )

59 5.5 Rekursion in Lisp

60 Rekursion Beispiel: Fakultät (define fak (lambda (n) (if (= n 0) 1 (* n (fak (- n 1))))))

61 Rekursion Element aus Liste herausnehmen Gegeben Beispiel: Atom a Liste `(a c a a 3) Aufrufformat: (ausliste `a `(a c a a 3) `()) Rückgabe: (`c )

62 Rekursion (define ausliste (lambda (atom liste ausgabe) (if (equal? liste `() ) (reverse ausgabe) (if (equal? (car liste) atom) (ausliste atom (cdr liste) ausgabe) (ausliste atom (cdr liste) (append (car liste) ausgabe))))))

63 Rekursion >(ausliste `a `(a c a a 3) `()) (list `c )

64 Rekursion Die Anzahl der Elemente, die in einer gegebenen Liste vorkommen, soll bestimmt werden. Gegeben Beispiel: Atom a Liste `(a c a a 3) (elementezaehlen `a `(a c a a 3)) Rückgabe 3

65 Rekursion (define elementezaehlen (lambda (atom liste) (if (equal? liste `() ) 0 (if (equal? (car liste) atom) (+ (elementezaehlen atom (cdr liste)) 1) (elementezaehlen atom (cdr liste))))))

66 Rekursion >(elementezaehlen `a `(a c a a 3)) 3

67 Iteration In verschiedenen Lisp-Dialekten gibt es (do …) oder (loop …) Hier wird eine „versteckte“ Rekursion verwendet!

68 5.6 Lisp-Maschinen

69 Lisp-Maschinen Eine Lisp-Maschine (kurz oft LispM) ist ein Computer, dessen Prozessor für die Ausführung von LISP-Programmen optimiert ist und dessen Betriebssystem in LISP geschrieben ist. Des weiteren sind auch typische Anwendungen in Lisp geschrieben.

70 Lisp-Maschinen Lisp-Maschinen boten eine komfortable Entwicklungsumgebung. Manche Lisp-Maschinen wurden aber auch ohne Entwicklungsumgebung für die Nutzung von Lisp-Anwendungen eingesetzt. Lisp-Maschinen wurden in den 1970er und 1980er Jahren entworfen, damit Aufgaben im Bereich der Künstlichen Intelligenz (KI) besser erledigt werden können.

71 Lisp-Maschinen Auch für Animation wurden einige Maschinen benutzt. Die Anzahl der eingesetzten Lisp-Maschinen war sehr gering. Es gibt Schätzungen zwischen 5000 und 7000 Stück.

72 Lisp-Maschinen Trotz dieser geringen Stückzahl wurden einige Konzepte heutiger Computersysteme auf Lisp-Maschinen erprobt und erstmals produktiv eingesetzt, wie farbige Grafik, Fenstersysteme, Computermäuse, Rechnernetze, Hypertext, inkrementelle Kompilierung und das Konzept von Einzelbenutzer-Workstations.

73 Lisp-Maschinen Wegen der großen Fortschritte in der Prozessor-Technologie in den 1990er Jahren, die auch ausreichend schnelle allgemeine Mikroprozessoren ermöglichten, und dem KI-Winter, der KI-Krise in den 1990ern, stürzten die Lisp-Maschinen-Hersteller in eine Krise und die Produktion von Lisp-Maschinen endete.