Programmiermethoden der Künstlichen Intelligenz

439 Pages·1991·11.126 MB·German

by  Herbert Stoyan (auth.)

Studienreihe Informatik
Herausgegeben von W. Brauer und G. Goos
Herbert Stoyan
PTogr~ernnethoden
der
Künstlichen Intelligenz
Band2
Mit 25 Abbildungen
Springer-Verlag
Berlin Heidelberg GmbH
Herbert Stoyan
Institut für. Mathematische Maschinen
und Datenverarbeitung (IMMD) Vlll
Universität Erlangen-Nürnberg
Martensstraße 3, W-8520 Erlangen, FRG
ISBN 978-3-540-52469-4 ISBN 978-3-642-87955-5 (eBook)
DOI 10.1007/978-3-642-87955-5
CIP-Titelaufnahme der Deutschen Bibliothek
Stoyan, Herbert:
Programmiermethoden der künstlichen Intelligenz I Herbert Stoyan. -
Berlin; Heidelberg; NewYork; London; Paris; Tokyo; Hong Kong; Barcelona: Springer
(Studienreihe Informatik)
Bd. 2 (1991)
Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbeson
dere die der Übersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen
und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfältigung auf ande
ren Wegen und der Speicherung in Datenverarbeitungsanlagen, bleiben, auch bei nur
auszugsweiser Verwertung, vorbehalten. Eine Vervielfältigung dieses Werkes oder von
Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestim
mungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September
1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich vergütungspflichtig.
Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes.
© Springer-Verlag Berlin Heidelberg 1991
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in
diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, daß
solche Namen im Sinne der Warenzeichen-und Markenschutz-Gesetzgebung als frei zu
betrachten wären und daher von jedermann benutzt werden dürften.
4513140 - 54 3 21 0 Gedruckt auf säurefreiem Papier
Vorwort
Hiermit liegt nun der zweite Band der "Programmiermethoden der Künstlichen
Intelligenz" vor. Er enthält Relationenmodelle, Regelmodelle, objektorientierte
Modelle und zwei Netz-Modelle (Klassifikation und ATNs).
Wiederum liegt die Hauptbetonung auf Denkmodellen. Formale Ausarbei
tung ist nicht in allen Fällen vollständig durchgeführt worden. Hier bleibt dem
Leser noch einige Arbeit. Auch der Programm-Code konnte nicht vollständig
wiedergegeben werden- die Implementationen von FRL oder OPS sind nun
einmal sehr umfangreich. Wieder können interessierte Leser vom Autor eine
Diskette mit allen Programmen erhalten.
Die Kapitel haben unterschiedlichen Charakter. So bringt besonders das
1. Kapitel (das 11. des gesamten Werkes) eine Einführung in einen ganz ak
tuellen Forschungsbereich. Demgegenüber mag das 3. Kapitel weniger aktuell
erscheinen, da eine alte KI-Sprache vorgestellt wird. Sie dient aber zu Stu
dienzwecken. Der Leser sollte die lmplementation radikal modernisieren! Etwas
zwiespältig wirkt die objekt-basierte Sprache des Kapitels 5. Sie war zunächst
als echte Nachrichtenversendungssprache gedacht, d.h. ohne implizite Antwor
ten. Doch erwies es sich, daß mit ihr nur unverständliche atomisierte Pro
gramme geschrieben werden können. Den aktuellen Programmen sieht man dies
an manchen Stellen noch an. Die beabsichtigte strenge Typisierung der Spra
che ist in den Programmen allenfalls angedeutet. Das spekulativste Kapitel ist
das vorletzte, in dem verschiedene Varianten von im Netzverbund rechnenden
Programmen diskutiert werden. Implementiert wird dann ein Klassifikator. Der
Leser sei ermuntert, in der Netzrichtung weiterzudenken.
Auch diesmal habe ich einer Reihe von Freunden und Kollegen zu danken,
die durch Hinweise und Verbesserungsvorschläge die Unvollkommenheit dieses
Bandes mit verringern halfen. Unter ihnen möchte ich Frank Spade hervor
heben, dessen unermüdliche und sorgfältige Arbeit auch für den ersten Band
besonders wichtig war, aber noch nicht genug gewürdigt worden ist.
Des weiteren haben C. Beckstein, T. Christaller, G. Görz, R. Kuhlen,
F. diPrimio, U. Reimer, U. Schreier, M. Tielemann und H. Wedekind Kapitel
versionen gelesen und verbessert. Ihnen gebührt mein Dank. Wenn sie nicht so
erfolgreich waren, wie sie es hätten sein können, dann liegt die Schuld bei mir.
Erlangen, im Oktober 1990 Herbert Stoyan
Inhaltsverzeichnis Band 2
1 Constraints - Relationen-orientierte Programmierung (1) ... . 1
1.1 Ausbreitung von Einschränkungen ........................... . 1
1.1.1 Ein Datenflußmodell für PROLOG .......................... . 1
1.1.2 Das Constraint-Datenfiuß-Modell ............................ . 3
1.1.2.1 Eine einfache numerische Constraint-Programmiersprache .... . 7
1.1.2.2 Steeles Constraint-Programmiersprache ...................... . 8
1.1.3 Restriktionsausbreitungssysteme als Spezialfälle
für Relationen verarbeitende Systeme ........................ . 11
1.1.3.1 Rekursive Constraints und nichtnumerische Datentypen ...... . 12
1.1.4 Vorgänger und zentrale Ideen ................................ . 14
1.2 Constraints: Verarbeitungsmodell, Programmierstil
und Programmiersprache .................................... . 16
1.2.1 Verarbeitungsmodelle von Waltz, Montanari, Freuder,
Sussman und Steele ......................................... . 16
1.2.1.1 Waltzsches Verarbeitungsmodell ............................. . 16
1.2.1.2 Waltz' Algorithmus als Ausbreitung von symbolischen
Wertbeschreibungen ......................................... . 19
1.2.1.3 Waltz' Algorithmus als Ausbreitung von Wertemengen ....... . 21
1.2.1.4 Waltz' Algorithmus als Ausbreitung von symbolischen
Wertverboten ............................................... . 22
1.2.1.5 Waltz' Algorithmus als Ausbreitung von Mengen
verbotener Werte ............................................ . 23
1.2.1.6 Waltz' Algorithmus als Ausbreitung von Werten ............. . 23
1.2.1. 7 Vergleich der fünf Sichtweisen ............................... . 24
1.2.1.8 Montanaris Verarbeitungsmodell ............................. . 28
1.2.1.9 Freuders Verarbeitungsmodell ............................... . 29
1.2.1.10 Das Verarbeitungsmodell von Gosling ........................ . 32
1.2.1.11 Das Verarbeitungsmodell von Steele ......................... . 33
1.2.2 Der einfache relationen-orientierte Programmierstil .......... . 36
1.2.3 Eine Constraint-Sprache ..................................... . 36
1.3 Programmieren mit einfachen Relationen .................... . 38
1.3.1 Einfache Beispiele ........................................... . 38
1.3.2 Ein Constraint-Programm für das krypto-arithmetische
Problem .................................................... . 41
VIII Inhaltsverzeichnis Band 2
1.4 lmplementation einer Constraint-Sprache . . . . . . . . . . . . . . . . . . . . . 48
1.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.6 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
2 Relationale Datenbanken - Relationen-orientierte
Programmierung ( 2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
2.1 Funktionen und Relationen - Einführung . . . . . . . . . . . . . . . . . . . . . 69
2.1.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
2.1.2 Rechnen mit Relationen - die Grundaufgaben . . . . . . . . . . . . . . . . 71
2.2 Relationenkalküle: Verarbeitungsmodelle, Programmierstil,
Programmiersprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
2.2.1 Relationenverarbeitungsmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
2.2.1.1 Relationenverarbeitung durch Verarbeitung von Tupelmengen . 73
2.2.1.2 Verarbeitung von Relationsausdrücken durch
Reduktionsmaschinen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.2.1.3 Verarbeitung von Relationen durch anweisungs-basierte
Programmstücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.2.2 Der relationen-orientierte Programmierstil . . . . . . . . . . . . . . . . . . . . 75
2.2.3 Beschreibungsformalismen für Relationen - relationen-basierte
Programmiersprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
2.2.3.1 Die primitive Mengenbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
2.2.3.2 Der Gleichungsformalismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
2.2.3.3 Der allgemeine Mengenformalismus - der Relationenkalkül . . . . 78
2.2.3.4 Relationenalgebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
2.2.4 Eine relationale Programmiersprache . . . . . . . . . . . . . . . . . . . . . . . . . 85
2.3 Programmieren mit Relationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.3.1 Einfache Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2.3.2 Ein Programm für das krypta-arithmetische Problem . . . . . . . . . 88
2.4 Implementierung der relationen-basierten Programmiersprache 93
2.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
2.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
2.7 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
3 METEOR- Regel-orientierte Programmierung (1) . . . . . . . . . . . 113
3.1 METEOR .................................................... 113
3.2 Regel-orientierte Programmierung: Verarbeitungsmodell,
Programmierstil und Programmiersprache . . . . . . . . . . . . . . . . . . . . 117
3.2.1 Verarbeitungsmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.2.1.1 Postsehe Produktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.2.1.2 Markow-Algorithmen ......................................... 117
3.2.1.3 CO MIT-Verarbeitungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3.2.1.4 METEOR-Verarbeitungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
3.2.2 Der frühe regel-orientierte Programmierstil . . . . . . . . . . . . . . . . . . . 119
3.2.3 Die METEOR-Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
3.2.3.1 Die Bedingungsmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Inhaltsverzeichnis Band 2 IX
3.2.3.2 Die Transformationsmuster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
3.2.3.3 Seiteneffekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
3.3 Programmieren in METEOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
3.3.1 Kleinere Beispiele ............................ , . . . . . . . . . . . . . . . 121
3.3.2 Ein METEOR-Programm für krypta-arithmetische Probleme . 122
3.4 Implementation von METEOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
3.6 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
4 Produktionensysteme - Regel-orientierte
Programmierung (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
4.1 Von METEOR zu OPS5 ...................................... 137
4.2 Produktionensysteme: Verarbeitungsmodell, Programmierstil
und Programmiersprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
4.2.1 Produktionensysteme - Langzeitgedächtnis, Kurzzeitgedächtnis,
Konfliktbeseitigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
4.2.2 Der regel-orientierte Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . . 142
4.2.3 OPS5 als regel-basierte Programmiersprache . . . . . . . . . . . . . . . . . . 142
4.3 Programmieren in OPS5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
4.3.1 Einfache Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
4.3.2 Ein OPS5-Programm für das krypta-arithmetische Problem . . . 147
4.4 Implementation von OPS5 - Das RETE-Verfahren . . . . . . . . . . . . 156
4.5 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
4.6 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
5 Nachrichtenverarbeitung - 0 bjekt-orientierte
Programmierung (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
5.1 Die Welt der Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
5.2 Na chrichtenverarbeitung: Verarbeitungsmodell,
Programmierstil und Programmiersprachen . . . . . . . . . . . . . . . . . . . 184
5.2.1 Das Modell der kommunizierenden Objekte . . . . . . . . . . . . . . . . . . . 184
5.2.1.1 Das Modell in globaler Sicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.2.1.2 Das Modell in lokaler Sicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.2.1.3 Nachrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
5.2.1.4 Klassen und Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
5.2.2 Der objekt-orientierte Programmierstil . . . . . . . . . . . . . . . . . . . . . . . . 190
5.2.3 Objekt-basierte Sprachen ................. :. . . . . . . . . . . . . . . . . . . 191
5.2.3.1 Dimensionen des Entwurfs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
5.2.3.2 Smalltalk als objekt-basierte Programmiersprache . . . . . . . . . . . . . 196
5.2.3.3 Die objekt-basierte Sprache OBPL . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
5.3 Objekt-orientiertes Programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
5.3.1 Einfache Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
5.3.2 Ein objekt-orientiertes Programm für das
krypta-arithmetische Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
X Inhaltsverzeichnis Band 2
5.4 lmplementation der objekt-basierten
Programmiersprache OBPL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
5.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
5.5.1 SIMULA- ein Vorläufer objekt-basierter Sprachen ............ 215
5.5.2 Smalltalk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
5.5.3 Actor-Sprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
5.5.4 Objekt-orientierte Programmierung und LISP . . . . . . . . . . . . . . . . 226
5.5.5 Objekt-orientierte Komponenten in hybriden
Expertensystemsprachen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
5.5.6 Objekt-orientierte Systementwicklung . . . . . . . . . . . . . . . . . . . . . . . . . 228
5.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
5.7 Literatur ..................................................... 231
6 Frames- Objekt-orientierte Programmierung (2) . . . . . . . . . . . . . 245
•
6.1 Einleitung - Gedächtnismodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
6.2 Frames: Verarbeitungsmodell, Programmierstil und
Programmiersprache . . . . . . . . . . . .. . . . . . . . .. .. . . . .. . . . . . . . . . . . . 252
6.2.1 Frame-Verarbeitungsmodell "Vererbung" . . . . . . . . . . . . . . . . . . . . . 252
6.2.2 Perlins Frame-Verarbeitungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
6.2.3 Unterschied zum klassischen Nachrichtenverarbeitungsmodell . 253
6.2.4 Frame-Programmierstil . . . . .. . . . . . . .. . . . . . . . . . . . . . . . .. . . . . . . . . 253
6.2.5 FRL - eine Frame-"Programmiersprache" . . . . . . . . . . . . . . . . . . . . . 253
6.2.5.1 Identitätsdimension von FRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
6.2.5.2 Veränderlichkeit in FRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
6.2.5.3 Nebenläufigkeit in FRL ....................................... 260
6.2.5.4 Dauerhaftigkeit in FRL ....................................... 260
6.2.5.5 Typ1s1erung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
6.2.5.6 Abstraktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
6.2.5.7 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
6.3 Programmieren in FRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
6.3.1 Ein einfaches Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
6.3.2 Ein FRL-Programm für das krypto-arithmetische Problem . . . . 265
6.4 lmplementation von FRL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
6.5 Historische Anmerkungen: Gedächtnismodelle,
Begriffshierarchien und Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
6.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
6.7 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
7 Frames - Plan-orientierte Programmierung
(Klassifikation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
7.1 Minskys Frames als Erkennungsprogramme . . . . . . . . . . . . . . . . . . . 325
7.1.1 Mögliche Plannetz-Modelle am Beispiel der krypto-
arithmetischen Rätsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
7.1.1.1 Variante 1: Konkurrierende Gesamtpläne . . . . . . . . . . . . . . . . . . . . . 330
7.1.1.2 Variante 2: Einzelne Pläne entsprechend den Gleichungen. . . . . . 333
Inhaltsverzeichnis Band 2 XI
7.1.1.3 Variante 3: Plan-Hierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
7.1.1.4 Variante 4: Koordination von Plänen durch einen Meta-Plan . . 337
7.1.1.5 Variante 5: Klassifikation durch Zielkonglomerate . . . . . . . . . . . . . 339
7.1.2 Klassifikation in Frame-Netzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.2 Frames: Dynamische Verarbeitungsmodelle,
Programmierstil und Programmiersprache . . . . . . . . . . . . . . . . . . . . 343
7.2.1 Verarbeitungsmodelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
7.2.1.1 Das Plan-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
7.2.1.2 Das Klassifizierungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
7.2.2 Plan-orientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
7.2.3 Die Programmiersprache XFRAME . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
7.3 Programmieren in XFRAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
7.3.1 Ein XFRAME-Programm für das krypta-arithmetische Problem 351
7.4 Implementation von XF RAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
7.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
7.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
7.7 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
8 Programmieren von ATNs- eine Art der anweisungs-
orientierten Progranunierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
8.1 Automaten und ATNs- Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . 371
8.2 ATNs - Verarbeitungsmodell, Programmierstil und
Programmiersprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
8.2.1 Das ATN-Verarbeitungsmodell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
8.2.2 Der anweisungs-orientierte ATN-Programmierstil . . . . . . . . . . . . . 379
8.2.3 Eine ATN-Programmiersprache ............................... 380
8.3 Programmieren mit ATNs .................................... 381
8.3.1 Ein ATN-Programm für das krypta-arithmetische Problem .... 385
8.4 Implementation eines ATN-Interpreters . . . . . . . . . . . . . . . . . . . . . . . 397
8.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
8.6 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
8. 7 Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Sachverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Personenverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
Funktionsverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
Inhaltsverzeichnis Band 1
1 Einleitung
1.1 Was sind Methoden der Künstlichen Intelligenz?
1.2 Eine Arbeitsmethode für die KI
1.3 Literatur
2 Programmierstile-Verarbeitungsmodelle-Programmiersprachen
2.1 Programmiermethoden
2.2 Programmierstile
2.3 Verarbeitungsmodelle
2.4 Programmiersprachen
2.5 Übersicht
2.6 Literatur
3 Ein Beispielproblem: Krypta-arithmetische Rätsel
3.1 Einfache Grundtatsachen und methodisches Expertenwissen
3.2 Grundwissen über Additionsgleichungen
3.3 Expertenwissen über Additionsgleichungen
3.3.1 Kombinationen gleicher oder ungleicher Ziffernsymbole
3.3.2 Ungleichungen
3.3.3 Einbeziehung konkreter Werte
3.4 Grundwissen über Multiplikationsgleichungen
3.5 Expertenwissen über Multiplikationsgleichungen
3.5.1 Kombinationen gleicher oder ungleicher Ziffern
3.5.2 Ungleichungen
3.5.3 Ausnutzen spezieller Werte
3.6 Ein Beispiel
3.7 Übungsaufgaben
3.8 Literatur
4 Funktionale Programmierung - Der funktions-orientierte
Programmierstil
4.1 Programmieren mit Funktionen
4.2 Verarbeitungsmodelle, Programmierstile, Programmiersprachen
4.2.1 FUnktionale Verarbeitungsmodelle
4.2.1.1 Das konventionelle Verarbeitungsmodell