Sprachverarbeitung mit LISP und PROLOG auf dem PC

310 Pages·1987·9.01 MB·German

by  Jürgen Handke (auth.)

Jürgen Handke
Sprachverarbeitung
mit LISP und PROLOG
auf dem PC
Programmieren von Mikrocomputern
Die Bände dieser Reihe geben den Benutzern von Heimcomputern, Hobbycomputern bzw.
Personalcomputern über die Betriebsanleitung hinaus zusätzliche Anwendungshilfen. Der Leser
findet wertvolle Informationen und Hinweise mit Beispielen zur optimalen Ausnutzung seines
Gerätes, besonders auch im Hinblick auf die Entwicklung eigener Programme.
Bisher erschienene Bände
Band 1 Einführung in BASIC Band 16 Einführung in die Anwendung des
von W. Schneider Betriebssystems MS-DOS
von W. Schneider
Band 3 BASIC für Fortgeschrittene
von W. Schneider Band 17 Einführung in die Anwendung des
UCSD p-5ystems
Band 4 Einführung in Pascal von K. Buckner/M. J. Cookson/
von W. Schneider A. I. Hinxman/ A. Tate
Band 6 BASIC-Programmierbuch zu den Band 18 Mikrocomputer-CDBOL
grundlegenden Ablaufstrukturen von W. Kähler
der Datenverarbeitung
von E. Kaier Band 19 Fortgeschrittene Programmier-
techniken in Turbo Pascal
Band 7 Lehr-und Übungsbuch für von E. Hering und K. Scheurer
Commodore-Volkscomputer
von G. Oetzmann Band 20 Einführung in die Anwendung des
Betriebssystems Apple DOS
Band 9 Einführung in die Anwendung des (Apple II)
Betriebssystems CP/M von H. R. Behrendt und
von W. Schneider H. Junghans
Band 10 Datenstrukturen in Pascal und Band 22 Einführung in Turbo Pascal unter
BASIC CP/MBO
von D. Herrmann von G. Harbeck
Band 11 Programmierprinzipien in BASIC Band 23 Pascal mit der Turtle
und Pascal von K. und K. H. Seelieh
von D. Herrmann
Band 24 Programmieren mit UNIX
Band 13 Strukturiertes Programmieren in von G. Martin und M. Trostmann
BASIC
von W. Schneider Band 25 Murmeltierwelt und Pascal
von H. Pinke
Band 14 Logo-Programmierkurs für
Commodore 64 Logo und Band 27 Sprachverarbeitung mit LISP
Terrapin Logo (Apple II I und Prolog auf dem PC
von 8. Schuppar von J. Handke
Band 15 Entwerfen von Programmen
(Commodore 64)
von G. Oetzmann
Programmieren von Mikrocomputern Band 27
Jürgen Handke
Sprachverarbeitung
mit LISP und PROLOG auf dem PC
Springer Fachmedien Wiesbaden GmbH
Das in diesem Buch enthaltene Programm-Material ist mit keiner Verpflichtung oder Garantie irgend
einer Art verbunden. Der Autor und der Verlag übernehmen infolgedessen keine Verantwortung und
werden keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Be
nutzung dieses Programm-Materials oder Teilen davon entsteht.
Alle Rechte vorbehalten
©Springer Fachmedien Wiesbaden 1987
Ursprünglich erschienen bei Friedr. Vieweg & Sohn Verlagsgesellschaft mbH, Braunschweig 1987
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede
Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne
Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für
Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung
und Verarbeitung in elektronischen Systemen.
ISBN 978-3-528-04570-8 ISBN 978-3-322-89424-3 (eBook)
DOI 10.1007/978-3-322-89424-3
V
Vorwort
Die folgenden Motivationen haben zu dem vorliegenden Buch geführt:
Da ist zunächst einmal die eigene Unzufriedenheit mit derzeit verfügbaren Büchern, die
sich mit der gleichen oder ähnlicher Materie befassen. Sowohl theoretische Abhandlungen
über das Thema ,Künstliche Intelligenz', Einführungen in moderne Programmiertechniken
oder den Umgang mit Computersystemen scheinen sich heutzutage fast ausschließlich an
Mathematiker, Physiker oder Informatiker zu wenden, an potentielle Computerbenutzer
also, die mit vielen Aspekten der Materie bereits vertraut sind. Dies mußte ich beim
Studium von Programmiersprachen wie LISP oder PROLOG schnell erkennen. Entnervt
von mathematischen Problemen wie etwa dem Errechnen der Fakultät natürlicher Zahlen
oder allgemeinen Problemlösungsverfahren wie etwa dem Turm von Hanoi dachte ich so
manchmal daran, das Studium der jeweiligen Programmierhandbücher aufzugeben. Dabei
wollte ich mich doch als Linguist mit den Problemen der natürlichen Sprache auseinander
setzen und nicht etwa mit dem Lösen algebraischer Probleme. Das allerdings, so wurde
mir bald klar, war nicht vorgesehen.
Also machte ich mich selbst ans Werk. Über das Studium der elektronischen Datenver
arbeitung allgemein, ersten Schritten mit einem Betriebssystem, dem Verstehen des
Zusammenwirkans der Komponenten eines Computersystems bis hin zum Erlernen der
Programmiersprachen BASIC, LISP und PROLOG gelang es mir, mich in die Geheimnisse
moderner Computertechnologie einzuarbeiten. Schon bald wurde mir die Relevanz der
Informationsverarbeitung auf einem Computer für mein Hauptarbeitsgebiet, die Lin
guistik, klar. Geht es doch heute der modernen Linguistik u. a. darum, die Regeln der
natürlichen Sprache auf Computersystemen zu implementieren.
Was folgte lag auf der Hand: ln meinen Lehrveranstaltungen nahm das Thema ,Künstliche
Intelligenz' einen breiten Raum ein. Neben theoretischen Themen waren nun auch prak
tische Übungen an der Tagesordnung. ln Ermangelung adäquater Lehrbücher mußten wir
allerdings eigene Wege gehen. Diese Wege sind im vorliegenden Buch ausgeführt.
Zum zweiten wird vielfach die neue Forschungsrichtung ,Künstliche Intelligenz' mit der
Beschäftigung mit Expertensystemen gleichgesetzt. Zwar spielen Expertensysteme in
diesem Zusammenhang eine wichtige Rolle. Dennoch gibt es einen großen Bereich inner
halb der Künstlichen Intelligenz, der sowohl in Einführungsbüchern in die Künstliche
Intelligenz als auch in den relevanten Programmierhandbüchern vielfach unerwähnt bleibt:
Der Bereich der maschinellen Sprachverarbeitung. Bisher war dieser Bereich ausgesproche
nen Experten vorbehalten: Da die Sprachwissenschaftler vielfach im Umgang mit Com
putern nicht vertraut waren und Programmierexperten die Komplexität natürlicher
Sprache oft nur ungenügend bekannt war, gab es nur einen kleinen, exklusiven Kreis von
Wissenschaftlern, dem dieser Themenkomplex vorbehalten war. Das vorliegende Buch
versucht diese Diskrepanz, wenigstens zu einem Teil, zu beheben. Anhand natürlich
sprachlicher Probleme wird die Programmiersprache LISP eingeführt, dem Leser werden
VI Vorwort
die wichtigsten Programmiermethoden der Verarbeitung grundlegender Strukturen natür
licher Sprache erläutert. Auf der Basis des bis dahin erarbeiteten Wissens wird ein aus
führlicher Vergleich zwischen LISP und der zweiten Programmiersprache der Künstlichen
Intelligenz, PROLOG gezogen. Auch PROLOG wird dabei auf der Basis linguistischer
Probleme vorgestellt. Sowohl für Linguisten als auch für Informatiker dürfte dies höchst
interessant sein.
Das Buch wendet sich daher primär an all jene, die an den Problemen der natürlichen
Sprache und deren Umsetzung in Computerprogramme, geschrieben in den jeweils rele
vanten Programmiersprachen, interessiert sind. Darüberhinaus werden auch in der Lin
guistik unerfahrene Leser eine Reihe interessanter Fragestellungen und Probleme sowie
deren Beantwortung finden. Da viele Leser aus diesem Personenkreis in Bezug auf Com
putertechnologie oft völlig unbedarft sind, geht dem Kernthema eine allgemeine Ein
führung in die Computertechnologie und den Umgang mit Computern voran. Darüber
hinaus hat die Erfahrung gezeigt, daß der hier angesprochene Personenkreis, wenn über
haupt, dann Erfahrungen auf dem Gebiet der Heimcomputer hat. Das schließt meistens
die Kenntnis der Programmiersprache BASIC ein. Daher werden im Programmierteil
dieses Buches gelegentlich Parallelen zu BASIC gezogen.
Insgesamt also ist das vorliegende Buch als eine Einführung in den Umgang mit den Pro
grammiersprachen der Künstlichen Intelligenz am Beispiel sprachverarbeitender Probleme
gedacht, wobei Kenntnisse im Bereich der Informatik oder der Mathematik nicht nötig
sind.
Zu danken habe ich den Studenten der Universität Wuppertal, die neben theoretischen
KI-Lehrveranstaltungen viel Zeit mit mir im Computerraum verbracht haben und meine
Vorschläge in die Tat umgesetzt aber auch häufig kritisiert und modifiziert haben. Be
sonders danke ich denjenigen Studenten, die Teile dieses Buches gelesen, am Computer
erprobt und viel nützliche Kommentare abgegeben haben.
Darüberhinaus danke ich meinen Kolleginnen Anette Kahre und Gisa Rauh, die beim
Vorablesen dieses Buches mit konstruktiver Kritik nicht gespart und zahlreiche nütz
liche Hinweise gegeben haben. Schließlich habe ich Christine Bentlage zu danken, die mit
ihren vortrefflichen Graphiken die oft abstrakten Probleme anschaulich illustriert hat.
Daß sie dabei die Programmiersprachen LISP und PROLOG noch besser kennengelernt
hat, ist ein nützlicher Nebeneffekt. Für Fehler und Unzulänglichkeiten, die dieses Buch
trotz aller hilfreichen Kommentare enthält, bin ich allerdings allein verantwortlich.
Wuppertal, Juni 1987 Jürgen Handke
VII
Der Umgang mit dem Buch
Je nach Art der Vorkenntnisse sollte man dieses Buch auf unterschiedliche Art und Weise
handhaben:
Dem Kernthema des Buches, dem Umgang mit den Programmiersprachen LISP und
PROLOG auf der Basis natürlichsprachlicher Fragestellungen, geht eine kurze Einführung
in die Geschichte der Künstlichen Intelligenz sowie ein Überblick über die höheren Pro
grammiersprachen voraus. Dem mit diesem Themenkatalog nicht vertrauten Leser wird
empfohlen, diese Einführung (Kapitel 1 bis 3) zu bearbeiten und ggf. ein allgemeines in
die EDV einführendes Handbuch zusätzlich zu Rate zu ziehen.
Der mit allgemeinen EDV-Kenntnissen ausgestattete Personenkreis kann direkt in Kapitel
4 einsteigen, um sich mit LISP und natürlichsprachlichen Problemen vertraut zu machen.
Allerdings sind eine Reihe natürlichsprachlicher Phänomene in Kapitel 1 bereits erwähnt,
so daß auch dieses Kapitel von Nutzen sein kann.
Da in Kapitel 5 PROLOG auf der Basis der im Umgang mit LISP erworbenen Kenntnissse
vorgestellt wird, sollte man dieses Kapitel in jedem Fall nach den vorangegangenen
Kapiteln bearbeiten.
Bezüglich der zahlreichen Programmierbeispiele und Aufgaben wird empfohlen, diese auf
den Mikrocomputer umzusetzen bzw. die Aufgaben zu lösen.
Alle Programme wurden auf einem IBM PC bzw. IBM AT programmiert und auf Lauf
fähigkeit überprüft.
IX
Inhaltsverzeichnis
Vorwort V
Der Umgang mit dem Buch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VII
Inhaltsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IX
Tabellen und Graphiken XII
1 Die Geschichte der Künstlichen Intelligenz . . . . . . . . . . . . . . . . . . . . . 1
1.1 ZahlensystemeundZählen................................ 3
1.2 Von Babbage biszum ENIAC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Von Generation zu Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.4 Von der Rechenmaschine zur Künstlichen Intelligenz . . . . . . . . . . . . . . 8
1.5 K I-Anwendungen (allgemein) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Natürlichsprachliche Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.7 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.8 Literaturhinweise zu Kapitel 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2 Computersysteme und Datendarstellung . . . . . . . . . . . . . . . . . . . . . . 25
2.1 Die Komponenten eines Computers . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.1.1 Die Zentraleinheit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.1.2 Die Peripherie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.2 Die Darstellung von Daten im Computer . . . . . . . . . . . . . . . . . . . . . . . 33
2.3 Maschinen-orientierte Programmiersprachen . . . . . . . . . . . . . . . . . . . . 33
2.4 Höhere Programmiersprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.4.1 Typen höherer Programmiersprachen . . . . . . . . . . . . . . . . . . . . 35
2.4.2 Programmiersprachen der Kl. . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.6 Literaturhinweise zu Kapitel 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3 Die Bedienung des Computers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.1 Das Betriebssystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.2 Betriebssysteme für den Personal Computer . . . . . . . . . . . . . . . . . . . . . 48
3.3 Der Kl-taugliche Computer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.4 Programmierdisziplin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.5 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.6 Literaturhinweise zu Kapitel 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
X Inhaltsverzeichnis
4 LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
4.1 Die LISP-Familie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.2 Datenstruktur und Dateneingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.1 Der LISP-Interpreter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.2 Die Struktur von Ausdrücken in LISP . . . . . . . . . . . . . . . . . . . . 62
4.2.3 Die Auswertung von S-Ausdrücken . . . . . . . . . . . . . . . . . . . . . . 64
4.2.4 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.3 Das Definieren und Manipulieren von Werten und Listen . . . . . . . . . . . . 68
4.3.1 Wertzuweisung in LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.3.2 Listen-Selektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3.3 Listen-Konstrukteren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.3.4 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.3.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.4 Die Flexibilität von LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
4.4.1 Einfache selbstdefinierte Funktionen . . . . . . . . . . . . . . . . . . . . 82
4.4.2 Übertragungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4.5 Verzweigungen im Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.5.1 LISP Prädikate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.5.2 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.5.3 Das Treffen von Entscheidungen . . . . . . . . . . . . . . . . . . . . . . . 97
4.5.4 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.5.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.6 Datenein-und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.6. 1 Das Lesen von Daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
4.6.2 Die Ausgabe von Daten auf den Bildschirm . . . . . . . . . . . . . . . . 108
4.6.3 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
4. 7 Rekursion und Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
4.7.1 Rekursion in natürlicher Sprache . . . . . . . . . . . . . . . . . . . . . . . 112
4.7.2 Rekursion in LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
4.7.3 Iteration in LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
4.7.4 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
4.7.5 Übungsaufgaben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
4.8 Assoziations- und Eigenschaftslisten . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.8.1 Assoziationen in Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.8.2 Eigenschaftslisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
4.8.3 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.8.4 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.9 Das Zerlegen von Eingabewörtern . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.9.1 String-Prozeduren in LISP . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
4.9.2 Die morphologische Analyse von Verben. . . . . . . . . . . . . . . . . . 136
4.9.3 Die Generierung von Wörtern . . . . . . . . . . . . . . . . . . . . . . . . . 143
4.9.4 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
4.9.5 Übungsaufgaben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147