Beruflich Dokumente
Kultur Dokumente
FACHARBEIT
Aus dem Fach
Mathematik
Leistungskurs: Mathematik
Abgabetermin: 29.1.2010
……………………………………………………..
(Unterschrift des Kursleiters)
Seite |2
Inhaltsverzeichnis
1. Einleitung ................................................................................................................................................ 4
1.1 Vorwort ............................................................................................................................................ 4
1.2 Biographie Turings ...................................................................................................................... 4
2. Die Turingmaschine in der Theorie ............................................................................................. 5
2.1 Was ist eine Turingmaschine? ................................................................................................ 5
2.1.1 Überführungsfunktion ....................................................................................................... 6
2.1.2 Funktionsweise .................................................................................................................... 7
2.1.3 Ein praktisches Beispiel (Bagger) ................................................................................. 8
2.2 Formale Definition....................................................................................................................... 9
2.3 Bedeutung in der Theoretischen Informatik .................................................................... 9
2.3.1 Formale Sprachen................................................................................................................ 9
2.3.2 Grammatiken ....................................................................................................................... 10
2.3.3 Chomsky-Hierarchie......................................................................................................... 12
2.3.4 Automaten und dazugehörige Sprachen .................................................................. 12
2.3.5 Auswirkungen auf die Berechenbarkeitstheorie.................................................. 15
3. Nachbau der Turingmaschine ...................................................................................................... 15
3.1 Konstruktion ................................................................................................................................ 15
3.1.1 Die Steuereinheit ............................................................................................................... 15
3.1.2. Das Band ............................................................................................................................... 16
3.1.3 Der Leser ............................................................................................................................... 16
3.1.4 Der Schreiber....................................................................................................................... 17
3.1.5 Vergleich mit anderen Nachbauten............................................................................ 17
3.2 Programmierung ........................................................................................................................ 17
3.2.1 Zielsetzung............................................................................................................................ 17
3.2.2 Der RCX .................................................................................................................................. 18
3.2.3 Bricx und NQC ..................................................................................................................... 18
2.3.4 Struktur / Umsetzung der Überführungsfunktionen in Programmcode.... 20
2.3.5 Eigenleistung bei der Programmierung ................................................................... 22
3.3 Beispiele ......................................................................................................................................... 23
3.3.1 Erhöhen einer Binärzahl um 1 ..................................................................................... 23
3.3.2 Addieren zweier Zahlen in Unärdarstellung .......................................................... 25
4. Ausblick ................................................................................................................................................. 27
5. Literaturverzeichnis ......................................................................................................................... 29
5.1 Bücher ........................................................................................................................................ 29
5.2 Internet ...................................................................................................................................... 29
5.3 Benutzte Software ................................................................................................................. 31
Seite |3
6. Anhang ................................................................................................................................................... 33
6.1 Quellcode ....................................................................................................................................... 33
6.1.1 Erhöhen einer Binärzahl um 1 ..................................................................................... 33
6.1.2 Addieren zweier Zahlen in Unärdarstellung .......................................................... 35
6.2 CD mit Dateien zur Facharbeit.............................................................................................. 37
Seite |4
1. EINLEITUNG
1.1 VORWORT
Heutzutage ist die Informatik allgegenwärtig. Geht man zum Beispiel nur mal schnell
in den nächsten Supermarkt, wird man den Computer an der Kasse bemerken. Aus
unserem Leben ist die Verarbeitung von Daten mithilfe eines Rechners nicht mehr
wegzudenken. Wie eine Studie belegt, benutzen 72% der Bundesbürger einen
Computer, 20% sitzen sogar mehr als sechs Stunden am Tag vor dem Rechner. Es
wird deutlich wie wichtig die angewandte Informatik in unserer Gesellschaft
geworden ist. Doch wo liegen die Ursprünge dieser noch gar nicht so alten
Wissenschaft?
Die Grundlagen schafften 1703 Gottfried Wilhelm Leibniz mit der vollständigen
Dokumentation des Dualsystems und George Bool 1854 durch Beschreibung der
nach ihm benannten Booleschen Algebra. Hierauf bauen fast alle späteren
Rechensysteme auf. 1936 führt Alan Turing mit dem mathematischen Modell der
Turingmaschine ein bis jetzt immer noch sehr wichtiges Werkzeug der
theoretischen Informatik ein. Konrad Zuses Rechner sind Weiterentwicklung der
Turingmaschine und die noch heute bei fast allen Computern angewandte von-
Neumann-Architektur wurzelt auch auf den Überlegungen Turings.
Die vorliegende Facharbeit soll nun im ersten Teil die Turingmaschine und ihre
Bedeutung für die theoretische Informatik näher erläutern. Zur Veranschaulichung
wird sie im zweiten Teil mithilfe LEGO Mindstorms nachgebaut und an diesem
Nachbau werden zwei Beispiele diskutiert.
Im Folgenden wird zunächst die Turingmaschine erklärt, hierauf wird sie formal
definiert, zuletzt wird ihre Bedeutung in der theoretischen Informatik beleuchtet.
Eine TM macht eine „Berechnung“ durch viele kleine Schritte. Jeder dieser Schritte
ist nach dem gleichen Schema aufgebaut:
↓ ↓ ↓ ↓
4. Schreiben eines Zeichens auf das Band was für ein Zeichen auf das Band
geschrieben wird
Auf dem nächsten Feld beginnt die TM wieder mit einem neuen Schritt, solange bis
sie den Endzustand erreicht hat.
Das ausgelesene Zeichen und der Zustand stellen sozusagen die zwei Bedingungen
für die drei darauffolgenden Befehle dar. Welchen Kombinationen von Zustand und
Bandzeichen welche Befehle zur Folge haben, wird in den Überführungsfunktionen
festgelegt. Die Aktionen der Steuereinheit werden sozusagen durch die
Überführungsfunktionen vorgegeben.
2.1.1 Überführungsfunktion
(vgl. 1; 12; 20; 29)
Bsp. :
2.1.2 Funktionsweise
(vgl. 1; 12; 20; 25)
Die TM geht immer, wie unter 2.1 schon erläutert, nach dem gleichen Schema vor.
Damit dies deutlicher wird, ziehen wir folgende Grafik zurate.
Zuerst prüft die Steuereinheit in welchem Zustand sie sich befindet. Dies ist am
Anfang der Startzustand . Dann wird das momentane Feld ausgelesen, was in
diesem Fall den Wert hat. Mit diesen beiden Werten sucht sie sich die passende
Überführungsfunktion . Hier sind beide Bedingungen erfüllt.
Jetzt weiß die Steuereinheit, welche Aktionen sie ausführen muss. Die erste
Anweisung nach dem ist , d.h. „Wechsle in Zustand 1!“ Hierauf soll auf das
Band geschrieben werden. Zuletzt fährt der Lese-/Schreibkopf ein Feld nach rechts,
was durch das Symbol zum Ausdruck kommt. Das Band und die Position des Lese-
/Schreibkopfes ist dann so:
Seite |8
Wenn man diesen einfachen Vorgang auf eine Turingmaschine überträgt sieht das so
aus:
Diese TM macht das Band „eben“, genauso wie der Bagger das Land einebnet. Sie
ändert die hohen bzw. die tiefen Stellen (1;3) auf ein Mittelmaß (2). Das leere Feld
entspricht der schon geteerten Straße, die nicht bearbeitet werden muss. Leer ist ein
Feld entweder dann, wenn durch die TM oder die Eingabe nichts an dieser Stelle auf
das Band geschrieben worden ist, oder das Feld von der TM geleert wurde, d.h. mit
dem Leerzeichen überschrieben wurde.
Seite |9
Schauen wir uns das nochmal genauer an. Sie startet so wie in der Grafik dargestellt
auf dem Feld mit der . Sie hat dabei den Startzustand . Die passende
Überführungsfunktion ( ) belässt den Zustand auf , schreibt die
Ziffer 2 auf das Band und bewegt den Lese-/Schreibkopf eine Position nach rechts.
Analog wird die 3 in eine 2 gewandelt und die 2 so belassen wie sie ist. Doch gelangt
der Lese-/Schreibkopf am Ende der Zahlenkette auf ein leeres Feld (hier
symbolisiert mit ), so
wechselt die
Steuereinheit in den
Endzustand und hält.
Das Ergebnis ist auf der
nebenstehenden Grafik abgebildet.
Wobei:
- Z die Menge der Zustände ist.
- das Eingabealphabet darstellt.
- das Arbeitsalphabet definiert, wobei gilt:
- die Menge aller Überführungsfunktionen darstellt, die die Form
besitzen.
- der Startzustand ist.
- das leere Zeichen ist.
- die Endzustände enthält, hierbei gilt:
Um die Bedeutung der Turingmaschine erläutern zu können, müssen zuerst ein paar
Grundlagen der theoretischen Informatik erklärt werden.
Wie wir oben schon erfahren haben, ist die Turingmaschine zur Beschreibung eines
bestimmten Typs formaler Sprachen ersonnen worden. Eine formale Sprache über
einem Alphabet ist eine Teilmenge aller überhaupt möglichen Verbindungen der
Elemente von .
S e i t e | 10
Bsp.: Sei
Es soll eine Sprache geben, die gültige Terme formuliert. Diese soll eine
Teilmenge von sein. So könnten z.B. einige Terme aussehen:
Man sieht, dass die Sprache unendlich ist, man aber eine endliche Definition
benötigt, um sie sinnvoll beschreiben zu können. Das nächste Kapitel geht darauf
näher ein.
2.3.2 Grammatiken
(vgl. 1)
Eine Möglichkeit eine formale Sprache zu definieren ist, sie durch eine Grammatik
zu beschreiben.
Welche Form hat eine Grammatik? Analysiert man ein einfaches Beispiel aus
unserer Sprache wird dies schnell deutlich:
Dabei sind Worte in spitzen Klammern (z.B. <Adverb>) sogenannte Variablen, die
während der Ableitung des Ausdrucks nach und nach durch die eigentlichen Worte
(= Terminalsymbole) ersetzt werden.
Das Gleiche kann auch durch einzelne Grammatik-Regeln abbilden:
Dies ist eine sehr einfache Grammatik. Für deren Alphabet gilt .
S e i t e | 11
Die Erkenntnisse angewandt auf das Beispiel einer Sprache, die sinnvolle Terme
bildet, (vgl. 2.3.1) ergeben folgende Grammatik:
Bsp. :
2.3.3 Chomsky-Hierarchie
(vgl. 1; 14)
Es wird nun eine Klassifizierung der Sprachen gesucht. Noam Chomsky lieferte mit
der nach ihm benannten Chomsky-Hierarchie dazu eine Möglichkeit.
Es werden bestimmte Regeln für die beschreibenden Grammatiken aufgestellt.
Alle Sprachen, die durch Grammatiken beschreibbar sind, gehören dem Typ-0 an. Sie
werden auch rekursiv aufzählbare Sprachen genannt. Sie sind genauso wie die
Menge der natürlichen Zahlen abzählbar.
Eine Typ-0 Grammatik ist genau dann vom Typ-1, wenn ihre Regeln folgender
Vorschrift entsprechen:
, wobei sein muss
Dadurch wird ein stetiges Wachstum der Wortlänge während der Ableitung erreicht.
So geartete Grammatiken werden auch kontextfrei bezeichnet. Das kann man sich
leicht klar machen, indem man ein Beispiel einer zugelassenen Grammatik-Regel
betrachtet.
Die Variable kann nur im Kontext von und durch ersetzt werden.
Typ-1 Grammatiken gehören der Menge der Typ-2 Grammatiken an, sobald ihre
Grammatik eine weitere Einschränkung erfüllt:
, wobei nur eine einzige Variable sein darf
Diese Regel führt zur sog. Kontextfreiheit, da nur noch Regeln der Form zugelassen
sind:
So kann die Variable egal in welchem Kontext sie steht durch ersetzt
werden.
Typ-2 Grammatiken sind vom Typ-3 oder regulär, falls die zugehörige Grammatik
folgende Regel erfüllt:
, wobei nur ein Terminalzeichen oder selbiges gefolgt von einer
Variablen sein darf
Grammatiken vom Typ-3 haben auch den Namen reguläre Grammatiken.
Automaten definieren eine Sprache auf eine andere Weise wie eine Grammatik. Man
gibt ihnen ein Wort und sie finden heraus, ob dieses Wort in der durch sie
definierten Sprache liegt. Die Vorgehensweise ist also umgekehrt im Vergleich zur
Grammatik. Denn diese konstruiert die Worte. Beim Automaten hat man das Wort
schon und will wissen, ob es in der Sprache liegt.
Eine Turingmaschine kann zur Definition von Typ-0 Sprachen benutzt werden. Man
schreibt das zu testende Wort auf das Band. Dieses gehört zu einer Typ-0 Sprache,
wenn die TM nach einer endlichen Zeit in einen Endzustand übergeht und somit
anhält.
Typ-1 Sprachen werden von linear beschränkten TM beschrieben. Das sind TM, die
nicht über die Felder der Eingabe hinausfahren können, d.h. die Länge des Bandes
ist beschränkt auf die Länge der Eingabe. Hier läuft die Prozedur genauso wie bei
der normalen TM ab. Das Wort, das auf das Band geschrieben wurde, ist dann
akzeptiert, wenn die beschränkte TM nach endlich vielen Schritten in einen
Endzustand übergeht.
Doch das Band kann nicht seitens des Automaten beschrieben werden. Die
Kellerautomaten besitzen auf dem Eingabeband nur eine Lesemöglichkeit
(Lesekopf!). Dafür können Zeichen in den Kellerspeicher gestapelt werden. Diese
können von dort auch gelesen und ebenso wieder gelöscht werden. Deswegen
bilden die Überführungsfunktionen bei Kellerautomaten das 3-Tupel
auf mehrere, ein oder kein 2-Tupel
ab. Die
Abbildung von auf mehrere
Möglichkeiten kennzeichnet die Nicht-Determinierung (= ohne Vorbestimmung). Es
existieren dadurch mehrere mögliche Wege durch die Überführungsfunktionen.
Man erkennt die Funktionsweise am besten an einem Beispiel.
Der obige Kellerautomat startet auf dem . Wenn er sich im Zustand befindet und
die oberste Zahl im Kellerspeicher ist (wie hier), kann er sich zwischen
und entscheiden. Wechselt er gemäß der
Überführungsfunktion in den Zustand und legt ein B auf den
Kellerspeicher, so hat der Kellerspeicher die nebenstehende Konfiguration.
S e i t e | 14
Ebenso könnte er aber auch die zweite Möglichkeit gewählt haben und der Speicher
wäre anders belegt. Dabei sieht man: Der Speicher wird wie ein Stapel benutzt. Neue
Symbole werden auf den Stapel gelegt, wobei die alten darunter erhalten bleiben.
Ähnlich wie bei der TM bewegt sich der Lesekopf nach Abarbeitung eines Schrittes
ein Feld weiter (beim Kellerautomat wird der Lesekopf aber immer nur in eine
Richtung ein Feld weiter bewegt) und die Prozedur beginnt von vorne. Es muss aber
nicht bei jedem Schritt in den Keller geschrieben werden. Aber es können ebenso
Zeichen aus dem Keller gelöscht werden.
Die Eingabe ist dann akzeptiert, wenn beim Abarbeiten der Eingabe mindestens ein
Weg durch die Überführungsfunktionen existiert, der nach Durchlaufen der Eingabe
mit leerem Kellerspeicher (#-Symbol gelöscht) endet. Dieses Wort ist dann einer
Typ-2 Sprache zugehörig, die durch den Kellerautomaten definiert wird.
Schließlich haben auch die Typ-3 Grammatiken ihren Pedant. Den endlichen
Automaten. Dieser besteht nur aus einem Lesekopf, einem Band und einer
Steuereinheit. Er wechselt während der Abarbeitung in verschiedene Zustände,
Startzustand ist wieder . Die Abarbeitung besteht einfach nur aus abfahren des
Wortes, meist von links nach rechts. Die Überführungsfunktionen bilden hierbei
auf ab.
Fast jedem ist intuitiv klar, dass manche Probleme berechenbar sind und andere
wiederum nicht. Doch kann man mit dem intuitiven Gefühl keine Beweise führen.
Also musste man eine Definition für die Berechenbarkeit finden. Turing postulierte
(und bewies später), dass alle berechenbare Probleme mithilfe der Turingmaschine
berechenbar sind. Somit lieferte er eine Definition des Berechenbarkeitsbegriffes.
Der Beweis und die genauere Auseinandersetzung mit der Berechenbarkeitstheorie
würde den Rahmen dieser Facharbeit sprengen. Bei Interesse kann dies in der im
Anhang genannten Literatur nachgelesen werden.
In diesem Teil soll der Nachbau einer Turingmaschine mithilfe von LEGO
geschildert werden. Im obigen, theoretischen Teil der Facharbeit (2. Die
Turingmaschine in der Theorie) ist bei der Bezeichnung der Bewegungsrichtung
immer die Bewegung des Lese-/Schreibkopfes gemeint, da es so in der verwendeten
Literatur gebräuchlich ist. Ab jetzt beziehen sich diese Kommandos
konstruktionsbedingt (vgl. 3.1.2. Das Band) auf die Bewegungsrichtung des Bandes.
3.1 KONSTRUKTION
In der praktischen Umsetzung ist die TM ist aus 4 verschiedenen Teilen aufgebaut:
befindet, so wird kein Licht reflektiert, sodass der Messwert niedriger ist. Hierbei
entspricht die Stellung am Lesekopf 0 und die vom Lesekopf weggeklappte
entspricht 1. Gleichzeitig kann das Lesen berührungslos bewerkstelligt werden,
sodass die Bewegung des Bandes nicht eingeschränkt wird.
3.2 PROGRAMMIERUNG
3.2.1 Zielsetzung
Das Programm sollte die Funktionen der Turingmaschine simulieren und die
Peripherie des RCXs ansteuern können. Die Struktur des Programmes sollte
möglichst nah an den Überführungsfunktionen der TM bleiben. Außerdem sollte
eine „einfache“ Eingabe der Überführungsfunktionen möglich sein.
S e i t e | 18
Der Microcontroller von LEGO besitzt einen 16MHz Prozessor von Hitachi, der auf
32 Kbyte statischen RAM und 16 Kbyte ROM zugreifen kann. Der RAM ist gemäß
seiner Natur flüchtig, d.h. er benötigt immer
einen kleinen Versorgungsstrom, um die
gespeicherten Daten nicht zu verlieren.
Er kann dafür aber vom RCX sowohl
beschrieben, als auch gelesen werden,
im Gegensatz zum ROM, der nur
lesbar ist. Die Speicheraufteilung
Um die oben genannten Ziele zu erreichen, habe ich mich entschlossen die
textbasierte Programmierumgebung Bricx , aufbauend auf NQC (=Not Quite C), für
das Projekt zu verwenden. Die Syntax der Sprache ähnelt C, wie der Name vermuten
lässt. Sie ist leistungsfähiger als die von Lego angebotenen grafischen
Programmiermöglichkeiten wie Mindstorms oder Robolab. Durch ihren hohen
Verbreitungsgrad ist sie zusätzlich sehr gut dokumentiert. Hier ein kleines
Beispielprogramm:
S e i t e | 19
task main()
{
OnRev(OUT_A);
Wait (43) ;
OnFwd(OUT_A);
Wait(43);
Off (OUT_A) ;
PlaySound(SOUND_UP);
}
Mit task main() wird eine Aufgabe (=task) mit dem Namen main gestartet. Um
die „Aufgaben“ (=Tasks) besser zu verstehen, wird ein kleines Beispiel aus der
realen Welt herangezogen: Eine Person hat z.B. die Aufgabe am Morgen mit der U-
Bahn in die Arbeit zu fahren. Hier müssen verschiedene Sachen erledigt werden:
Aufstehen, Frühstücken, zur U-Bahn Rennen, U-Bahn Fahren und Ähnliches. Diese
Dinge müssen alle in der richtigen Reihenfolge erledigt werden, da sonst alles
durcheinander kommt. Man kann z.B. schlecht nach dem auf die U-Bahn Rennen erst
Aufstehen. Somit bedarf das ganze einer gewissen chronologischen Ordnung. Man
listet sozusagen die einzelnen Befehle in der Aufgabe in richtiger zeitlicher Abfolge
auf.
So wird das auch im Programm gemacht. Nach task main() werden die einzelnen
Befehle in { } aufgelistet. OnRev(OUT_A)lässt den Motor an Ausgang A rückwärts
laufen. Darauf, während der Motor sich dreht, wartet der RCX 43ms, invertiert die
Drehrichtung (OnFwd(OUT_A)), wartet nochmal die gleiche Zeit und schaltet den
Motor zum Schluss aus (Off (OUT_A)) und spielt , um das Ende zu markieren
einen nach oben gleitenden Ton (PlaySound(SOUND_UP)).
Zurück zu dem Beispiel aus dem realen Leben. Bisher sind wir davon ausgegangen,
dass die Person in der Früh immer nur eine Sache gleichzeitig tun kann. Doch es ist
unter Umständen ebenso möglich während der U-Bahn-Fahrt zu frühstücken. Dieses
„Multitasking“ beherrscht auch der RCX. Er kann sogar 10 solche Tasks gleichzeitig
ausführen. Die anderen Tasks können beliebig benannt werden, es muss aber immer
eine task main() vorhanden sein, da diese beim Start (drücken auf den Run-
Knopf am RCX) ausgeführt wird. Die anderen Aufgaben müssen von der task
main() gestartet werden und können ihrerseits auch wieder Tasks starten und
stoppen. Innerhalb der auf jede Task folgenden geschweiften Klammern { } stehen
wieder Programmanweisungen.
task main()
{
write;
PlaySound(SOUND_UP);
}
Mit #define write wird das Makro write definiert. Alle Anweisungen, die
dahinter in der gleichen Zeile (hier aus Platzgründen nicht möglich) stehen, gehören
dann zu diesem Überbegriff. Nun kann man write im Programm aufrufen, worauf
nacheinander die dafür definierten Befehle ausgeführt werden. Also zuerst
OnRev(OUT_A) , dann Wait (43)usw. bis zum letzten Befehl Off (OUT_A).
Nachdem jetzt write abgearbeitet ist, werden die weiteren Befehle im
Programmcode befolgt. Der Aufruf PlaySound(SOUND_UP)lässt den
Microcontroller einen aufsteigenden Ton von sich geben. So verhält sich der RCX mit
dieser Programmierung genauso wie mit der unter 3.2.3 beschriebenen. Es ist
einfach nur eine andere Schreibweise für die gleichen Aktionen.
Wie man deutlich sieht, kann man mit den Makros die einzelnen immer gleichen
Schritte der TM übersichtlicher gestalten.
Bei der Programmierung der TM wird deswegen Anfang das Makro write(r)
erstellt. Es definiert den immer wiederkehrenden Vorgang des Schreibens. Dieses
Mal wird ein Argument (r) benötigt, das beim Aufruf an das Makro übergeben
wird. Wird write(1) aufgerufen, so schreibt der RCX 1 auf das Feld.
Dementsprechend wird bei write(0)wird der Kipper in die 0-Stellung gebracht.
Man kann so mit einem Makro sowohl 1 als auch 0 schreiben.
S e i t e | 21
Die TM hat noch zwei andere immer gleich bleibende Befehlsabläufe neben dem
Schreiben. Das Bewegen des Bandes und das Wechseln des Zustands. Diese Aktionen
werden auch in Makros zusammengefasst. Hier eine kleine Liste der Makros, ihrer
möglichen Argumente und deren Funktionen:
Es stellt sich nun die Frage wie man die Zustände der TM im Programm realisieren
kann. Hierzu bieten sich die unter 3.2.3 beschriebenen Tasks an. Jedem Zustand
wird eine Task zugeordnet.
Da es nur zwei Zeichen (1;0) auf dem Band möglich sind, existieren aus einem
Zustand immer nur zwei Überführungsfunktionen. Eine Task sieht z.B. für
Überführungsfunktionen aus dem Zustand folgendermaßen aus:
S e i t e | 22
ÜBERFÜHRUNGSFUNKTION CODE
task Z0 ()
{
if(SENSOR_1>hell)
//wenn NULL am Band
{
write(1);
move(0);
zustand(9);
}
else
//wenn EINS am Band
{
write(0);
move(2);
zustand(1);
}
}
Als erstes wird in der Zustandstask task Z0() geprüft, in welcher Stellung sich
der Kipper befindet. SENSOR_1 stellt hierbei den Lichtsensor dar. Darauf folgen
die Anweisungen in Form der oben erklärten Makros.
Am Ende jeder Task steht hierbei immer das Wechseln in einen anderen Zustand
(zustand(m)). Dabei wird die im Argument angegebene Task gestartet, der
wiederum ein Überführungsfunktionspaar zugeordnet ist. Nach dem Starten dieser
Task ist die für den Start verantwortliche Task beendet.
In dieser Art springt das Programm solange von Task zu Task, bis der Endzustand
erreicht wird.
Vor Beginn der eigentlichen Berechnung muss noch der Lichtsensor kalibriert
werden, da dieser je nach Intensität des Umgebungslichtes unterschiedliche Werte
liefert. Das Band fährt unter dem Sensor eine bestimmte Strecke ab, wobei der
niedrigste Wert in der Variable dunkel, der höchste Wert in der Variable hell
gespeichert wird. So wird der geringste, damit dunkelste, und der höchste, damit
hellste, Wert ermittelt. Durch Vergleich mit diesen Variablen kann dann die Stellung
der Kipper (vgl. 3.1.3) bestimmt werden.
Bei der Programmierung unterscheiden sich fast alle Lösungsmöglichkeiten. Ist die
Konstruktion fast dieselbe, so kann doch einmal Java als Programmiersprache
verwendet werden, das andere Mal wird PRO-BOT eingesetzt, eine andere, speziell
für LEGO-Microcontroller entwickelte Programmiersprache. Auch gibt es dabei viele
verschiedene Konzeptionsarten. So gibt es z.B. die Möglichkeit das Programm auf
dem PC laufen zu lassen und nur die Anweisungen über die Infrarotschnittstelle an
S e i t e | 23
den RCX zu senden, der diese nur noch ausführt. Mir hat keiner der Lösungsansätze
zugesagt oder konnte ihn durch die fehlende Leistungsfähigkeit des RCX nicht
verwirklichen.
Deswegen habe ich das Programm vollständig selbst entwickelt, ohne Orientierung
an anderen Lösungsmöglichkeiten.
3.3 BEISPIELE
Die TM soll zu einer Binärzahl, die auf das Eingabeband geschrieben ist 1 addieren.
Die Binärzahlen basieren ähnlich dem Dezimalsystem auf Stellenwerten. Im
Vergleich ( zeigt binärschreibweise an):
Binär Dezimal
Die Stellenwerte sind gemäß der obigen Tabelle, also erste Stelle von rechts 1,
zweite Stelle 2, dritte 4, und so weiter.
Um eine TM für eine Addition mit Eins zu programmieren, muss man zuerst den
Vorgang genau analysieren und verstehen. Die Schritte in denen man 1 zu einer
Binärzahl addiert sind wie folgt gestaltet (ab jetzt wird in diesem Kapitel
ausschließlich Binärschreibweise verwandt):
Bsp.:
1. Schritt: überprüfen, welche Ziffer auf der Einser-Stelle steht
2. Schritt: es steht eine 0
3. Schritt: ersetzen der 0 durch1
Bsp.: 11011+1=
1. Schritt: überprüfen, welche Ziffer auf Einser-Stelle steht
2. Schritt: es steht eine 1
S e i t e | 24
Die Überführungsfunktionen für eine TM, die auf der ersten Stelle der Binärzahl von
rechts, also der Einser-Stelle, startet, müssen nun dieser Gestalt sein:
ÜBERFÜHRUNGSFUNKTION KOMMENTAR
wenn auf 1er-Stelle 0 steht, schreibe 1 und
halte Endzustand
wenn auf 1-Stelle 1 steht, schreibe 0, fahre
nach rechts, wechsle in Zustand , der die
nächsten Stellen überprüft und
dementsprechend verändert
Das Programm gestaltet sich so: Zuerst wird die 1-Stelle überprüft. Ist diese eine 0,
so wird sie auf 1 abgeändert und die Berechnung ist abgeschlossen. Für den Fall
aber, dass eine 1 auf der ersten Stelle zur Null gemacht wird so eine Schleife
konstruiert. Diese macht alle direkt darauffolgenden Einsen zu Nullen, bis eine 0
kommt, die dann zu einer Eins werden muss.
Im Programm wird jedem Zustand eine Task zugewiesen (Erläuterung siehe 2.3.4).
Aus dem Startzustand existieren folgende Überführungsfunktionen.
Jetzt kann mit dem fertig programmierten Nachbau der TM jede beliebige Binärzahl
um eins erhöht werden. Man schreibt die Ausgangszahl auf das Band, lässt die TM
die Berechnung durchführen und schon kann man das Ergebnis auf dem Band
ablesen.
S e i t e | 25
Bsp.: Das Band wird mit beschrieben. Wenn man die TM startet, sieht das
dann so aus:
Dabei zeigt der gelbe Pfeil die Position des Lesekopfes an, die roten Rechtecke
symbolisieren die Kipper. Da der Startzustand bzw. task Z0 ist und auf dem
Feld eine 1 steht, wird der Kipper auf die Null Position gebracht. Daraufhin bewegt
sich das Band nach rechts und die task Z1 wird aufgerufen (=Zustand ). Das
Band befindet sich dann in dieser Position:
Jetzt werden alle links folgenden Einsen zu Nullen „gekippt“. Jetzt wird noch die Null
in eine 1 umgeschrieben und fertig ist die Addition mit Eins. Im Endzustand
angelangt steht das Ergebnis auf dem Band:
Das war zwar eine sehr einfache Aufgabe für die TM, aber dennoch konnte so die
Funktionstüchtigkeit des Nachbaus gezeigt werden. Im nächsten Kapitel wird ein
weiteres Programm vorgestellt.
Für dieses Beispiel habe ich das Band von 6 Kippern auf 20 erweitert, da sonst die
Forderung nach einem nahezu „unendlichen“ Band fast nicht mehr eingehalten
werden kann.
Die Unärdarstellung ist jedem geläufig. Man kennt sie vom zählen mit einer
Strichliste. Hierbei besitzt das einzig erlaubte Symbol (=meistens |) die Wertigkeit 1.
So ergibt sich ( für Dezimalzahlen; für Unärzahlen):
Bsp.:
Bei dem Nachbau wird die 1 als Strich verwendet, die Null hingegen als Leerzeichen.
Wenn man nun zwei Zahlen zusammenaddieren soll, so muss man sie also nur
aneinanderhängen. Bei der TM sieht das dann so aus:
ÜBERFÜHRUNGSFUNKTION KOMMENTAR
Abfahren der ersten Zahl
wenn 0 (=Leerzeichen), dann in den Zustand
wechseln, mit dem die zweite Zahl
abgefahren wird; die Lücke zwischen den
Zahlen mit einer 1 schließen
Sehen wir uns das am Beispiel mit der nachgebauten TM an. Die
Ausgangslage gestaltet sich so:
Hier ist aus Platzgründen nur der relevante Teil des 20 Kipper langen Bandes
abgebildet. Die Symbole sind aus den Grafiken in 3.3.1 schon bekannt.
Startet man die TM so wird nach der Kalibrierung zunächst die erste Zahl im
Zustand abgefahren, ohne sie zu verändern. Die Trennung der beiden Zahlen wird
daraufhin mit 1 überschrieben, die beiden Zahlen sozusagen zusammengehängt, und
es wird zum Zustand bzw. zur task Z1 gewechselt.
S e i t e | 27
Jetzt ist aber die Zahl um eine Ziffer zu lang, weshalb das Ende der zweiten Zahl
gesucht wird (in /task Z1). Ist das Ende der Ziffernkette gefunden (wenn ein
Leerzeichen auf dem Band steht), so wird die letzte Stelle der entstandenen Zahl
wieder unter den Lese-/Schreibkopf bewegt und in Zustand /task Z2
gewechselt.
In überschreibt die TM die Eins mit einer Null und fertig ist die Addition. Das
Ergebnis steht dann so auf dem Band:
4. AUSBLICK
(vgl. 5, 8)
Die TM ist und bleibt ein theoretisches Modell, das durch seine eingeschränkte
Leistungsfähigkeit und geringe Benutzerfreundlichkeit keine flächendeckende
praktische Umsetzung erfahren hat. Aber es ist für die theoretische Informatik ein
essentielles Modell mit dem, wie schon erläutert, vieles beschrieben oder bewiesen
werden kann.
Leider es ist meistens durch seinen theoretischen Charakter schwer zu erklären. Ein
Nachbau kann helfen die wirkliche Funktionsweise zu verstehen. Denn so kann man
direkt sehen, was die TM mit einer bestimmten Programmierung macht.
Dafür ist es eben auch wichtig, dass die Struktur der Programmierung möglichst den
Überführungsfunktionen ähnelt. Hierfür habe ich auch in Kauf genommen, dass
S e i t e | 28
durch meine Programmierungsweise nur 9 Zustände möglich sind. Doch so ist die
Struktur relativ einfach zu verstehen und der Programmcode gut zu lesen.
Noch besser wäre es, eine grafische Benutzeroberfläche zu schaffen, in die man die
Überführungsfunktionen und die Bandbelegung beim Start eingeben könnte. Dieses
Tool könnte dann automatisch den Code für den RCX erstellen und ihn vielleicht
sogar an diesen übermitteln. Dadurch könnte man den Code weniger anschaulich
gestalten, weil der Benutzer nicht mehr mit diesem in Kontakt kommen würde,
wodurch eine größere Anzahl an erlaubten Zuständen möglich wäre. So wäre eine
sehr große Benutzerfreundlichkeit realisierbar. Doch die Verwirklichung würde den
ohnehin schon fast zu kleinen Rahmen einer Facharbeit sprengen.
Die Seite „Lego of Doom“ dokumentiert einen sehr gut gelungenen Nachbau der TM.
Doch dieses Projekt hat es einfacher, da es die Weiterentwicklung des RCX, also den
NXT verwendet, der um einiges leistungsfähiger ist.
Was können wir aber aus dem Modell der Turingmaschine schließen?
Durch die enge Verknüpfung mit der Berechenbarkeitstheorie stellt sie auch die
menschliche Intelligenz in Frage. Denn alles, was ein Mensch berechnen kann, kann
eine TM auch berechnen. Sie muss nur gut genug programmiert werden. Hier taucht
aber eine Frage auf, die jeder für sich selbst beantworten muss: Ist Intelligenz
wirklich nur die Fähigkeit alles zu berechnen?
S e i t e | 29
5. LITERATURVERZEICHNIS
5.1 Bücher
1) Schoening, Uwe
Theoretische Informatik - kurzgefaßt
3. Auflage; 1. korrigierter Nachdruck
Seiten 11-92
Heidelberg; Berlin
Spektrum Akademischer Verlag
1997
2) unbekannt
Brockhaus Lexikon
in 20 Bänden, Band 8
Stichwort: Informatik
Mannheim; München
Deutscher Taschenbuch Verlag
1982; 1988
5.2 Internet
Normale Internetseiten
3) Agulló, Miguel; Ferrari, Mario; Carlson, Doug; Yabuki, Hideaki; Clague; Ferrari,
Giulio
Building robots with Lego Mindstorms ... - Google Bücher
http://books.google.de/books?id=8atl8tQgC08C&pg=PA107&lpg=PA107&dq
=turing+machine+rcx&source=bl&ots=B2bHgpO7gb&sig=GyPpRPLWxF8w9U
deRJKWRufb5xY&hl=de&ei=zc4WS7j8NdCB_QaE-
bn1Bg&sa=X&oi=book_result&ct=result&resnum=5&ved=0CBwQ6AEwBA#v
=onepage&q=turing%20machine%20rcx&f=false
4) BITKOM e.V.
Deutsche sitzen lange vor dem Computer (2008) - BITKOM
http://www.bitkom.org/de/presse/56204_53769.aspx
5) Cousineau, Denis
Turing machine
http://mapageweb.umontreal.ca/cousined/lego/5-
Machines/Turing/Turing.html
6) Mostowski, Andrzej
JSTOR: The Journal of Symbolic Logic, Vol. 4, No. 3 (Sep., 1939), pp. 128-129
http://www.jstor.org/pss/2266472
7) Mostowski, Andrzej
JSTOR: The Journal of Symbolic Logic, Vol. 4, No. 3 (Sep., 1939), pp. 129-130
http://www.jstor.org/pss/2266473
8) Nissen, Anders; Have, Martin; Vester, Mikkel; Geggie, Sean
Lego of Doom
http://legoofdoom.blogspot.com/
S e i t e | 30
9) unbekannt
Informatik - Endliche Automaten - Einführung
http://www.hsg-kl.de/faecher/inf/material/automaten/einf/index.php
10) unbekannt
Mindstorms Lichtsensor deutsch
http://www.kleinesteine.de/info/lichtsensor/lightsensor_german.htm
11) unbekannt
Von Neumann and Turing, 1937-39
http://www.turing.org.uk/sources/vonneumann.html
12) Weuffen, Georg
Die Turingmaschine – MathePrisma
http://www.matheprisma.de/Module/Turing/index.htm und alle Abhängigen
Wikipedia
PDF-Dateien
Biographie
Alle Bilder und Grafiken in dieser Facharbeit sind von mir selbst erstellt,
ausgenommen:
• Firefox
http://www.mozilla-europe.org/de/firefox/
• GIMP
ein Open-Source Pixel-Grafik Programm
http://www.gimp.org/
• Inkscape
ein Open-Source Vektor-Grafik Programm
http://www.inkscape.org/?lang=de
• LDraw
CAD-Software-Paket speziell für Legomodelle
http://www.ldraw.org/
• Opera
http://www.opera.com/
• Phase5
html-editor
http://www.phase5.info/
• Synkron
Open-Source Synkronisationssoftware
http://synkron.sourceforge.net/
• Turingmaschinen Simulator
von Weuffen, Georg
http://www.matheprisma.de/Module/Turing/Navi/Simulator.htm
• Windows XP Home
http://www.microsoft.com/germany/windows/windows-xp/
• Word 2007
http://office.microsoft.com/de-de/word/default.aspx
S e i t e | 33
6. ANHANG
6.1 QUELLCODE
Im folgenden Quelltext sind die Kommentare, also Teile im Quelltext, die nicht vom
RCX ausgeführt werden, sondern nur zum besseren Verständnis für Entwickler und
Quelltextleser beitragen sollen, so gekennzeichnet:
/* move(1) bewegt das Band vom Sensor aus gesehen nach links
move(2) bewegt es nach rechts
und move(0) belässt es an der Stelle */
/* write(1) klappt den Kipper vom Sensor weg, was einer 1 entspricht
write(0) bringt den Kipper an den Sensor (=0) */
/* zustand(m) ruft für m=1 task Z1 auf, für m=2 task Z2 und so weiter
zustand(9) ist hierbei der Endzustand, ein Ton wird gespielt,
das Programm stoppt , da keine task mehr läuft */
task main()
{
SetPower (OUT_C,1);
SetSensor(SENSOR_1,SENSOR_LIGHT);
SetSensor (SENSOR_2, SENSOR_ROTATION);
OnFwd(OUT_C+OUT_B) ;
while(SENSOR_2<=200) // während das Band einmal abgefahren wird
{
if(dunkel>=SENSOR_1) /* wird der Minimalwert des Lichtsensors
gefunden*/
{
dunkel=SENSOR_1;
S e i t e | 34
}
if(hell<=SENSOR_1) // und entsprechend der Maximalwert
{
hell=SENSOR_1;
}
}
dunkel+=3; /* der Minimalwert und Maximalwert werden entschärft,
um die Ungenauigkeiten des Lichtsensors auszugleichen */
hell-=10;
OnRev(OUT_C); // das Band wird wieder in die Ausgangslage gebracht
until(SENSOR_2<=0) ;
Off(OUT_C);
start Z0; // starte Anfangszustand Z0
}
task Z0 ()
{
if(SENSOR_1>hell) // wenn NULL
{
write(1);
move(0);
zustand(9);
}
else // wenn EINS
{
write(0);
move(2);
zustand(1);
}
}
task Z1()
{
if(SENSOR_1>hell) // wenn NULL
{
write(1);
move(0);
zustand(9);
}
else // wenn EINS
{
write(0);
move(2);
zustand(1);
}
}
task Z2 ()
{
task Z3 ()
{
task Z4 ()
{
}
S e i t e | 35
task Z5 ()
{
task Z6 ()
{
task Z7 ()
{
}
task Z8 ()
{
}
/* move(1) bewegt das Band vom Sensor aus gesehen nach links
move(2) bewegt es nach rechts
und move(0) belässt es an der Stelle */
/* write(1) klappt den Kipper vom Sensor weg, was einer 1 entspricht
write(0) bringt den Kipper an den Sensor (=0) */
/* zustand(m) ruft für m=1 task Z1 auf, für m=2 task Z2 und so weiter
zustand(9) ist hierbei der Endzustand, ein aufsteigender Ton wird
gespielt, das Programm stoppt , da keine task mehr läuft */
task main()
{
SetPower (OUT_C,1);
SetSensor(SENSOR_1,SENSOR_LIGHT);
SetSensor (SENSOR_2, SENSOR_ROTATION);
OnRev(OUT_C+OUT_B) ;
while(SENSOR_2>=-500) // während das Band einmal abgefahren wird
{
if(dunkel>=SENSOR_1) /* wird der Minimalwert des Lichtsensors
gefunden*/
{
dunkel=SENSOR_1;
}
S e i t e | 36
}
dunkel+=3; /* der Minimalwert und Maximalwert werden entschärft,
um die Ungenauigkeiten des Lichtsensors auszugleichen */
hell-=10;
OnFwd(OUT_C); // das Band wird wieder in die Ausgangslage gebracht
until(SENSOR_2>=0) ;
Off(OUT_C);
start Z0; // starte Anfangszustand Z0
}
task Z0 ()
{
if(SENSOR_1>hell) // wenn LEER
{
write(1);
move(1);
zustand(1);
}
else // wenn EINS
{
write(1);
move(1);
zustand(0);
}
}
task Z1()
{
if(SENSOR_1>hell) // wenn LEER
{
write(0);
move(2);
zustand(2);
}
else // wenn EINS
{
write(1);
move(1);
zustand(1);
}
}
task Z2 ()
{
if(SENSOR_1>hell) // wenn LEER
{
}
else // wenn EINS
{
write(0);
move(0);
zustand(9);
}
}
task Z3 ()
{
task Z4 ()
{
S e i t e | 37
task Z5 ()
{
task Z6 ()
{
task Z7 ()
{
task Z8 ()
{
Ordner Kommentar
/Facharbeit Hier ist diese Facharbeit als *.pdf vorhanden. Diese
Version empfiehlt sich v.a. für die Querverweise, da
man durch Klicken auf diese, direkt die gewünschte
Stelle angezeigt wird.
/Programme für den RCX Beinhaltet die beiden Beispielsprogramme als *.txt.
/Quellen Enthält in Ordnern (Normale Internetseiten,
Wikipedia, PDF, Biographie) gemäß den
Unterüberschriften aus 5.2 die Internetdokumente als
*.mht bzw. *.pdf.
Außerdem ist eine HTML-Datei vorhanden mit Links
auf diese Dokumente.
Für die *.mht-Files empfiehlt sich der Internet-
Explorer oder Opera. Firefox unterstützt diese Formate
nicht.
/Videos und Bilder Hier sind zu den zwei erläuterten Beispielen Videos
und Bilder abgespeichert.
S e i t e | 38
Ich erkläre hiermit, dass ich die Facharbeit ohne fremde Hilfe angefertigt und nur
die im Literaturverzeichnis angeführten Quellen und Hilfsmittel benützt habe.