Sie sind auf Seite 1von 38

GYMNASIUM FÜRSTENRIED Kollegstufenjahrgang 2008/2010

FACHARBEIT
Aus dem Fach

Mathematik

Thema: Automatentheorie (speziell die Turingmaschine)

Verfasser: David Kittlaus

Leistungskurs: Mathematik

Kursleiter: Herr Dr. Spohrer

Abgabetermin: 29.1.2010

Erzielte Note: ……………………. In Worten: ……………………………….

Erzielte Punkte: ……………………. In Worten: ……………………………….


(einfache Wertung)

……………………………………………………..
(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

(vgl. 2; 4; 11; 15; 17; 22; 30)

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.

1.2 BIOGRAPHIE TURINGS

(vgl. 6; 7; 13; 31)

Alan Mathison Turing geboren am 23. Juni 1912 in


London hatte ein sehr ereignisreiches Leben. Schon in
der Kindheit fühlte er sich stark zu Zahlen und Rätseln
hingezogen, was später auch von seinen Lehrern auf dem
Malborough College und dem Sherborne-Internat als
naturwissenschaftliche Begabung wahrgenommen
wurde. Seine Faszination für die Naturwissenschaften
schloss aber nicht die Begeisterung für
Geisteswissenschaften ein. Dadurch verschlechterte er
seinen Notenschnitt so sehr, dass er 1931 nur ein College
zweiter Wahl (King’s College in Cambridge) besuchen
konnte. Nach seinem Studium veröffentlichte Turing im Jahr 1936 seine
bahnbrechende Arbeit „On Computable Numbers, with an Application to the
Entscheidungsproblem“ , in der er das Konzept der Turingmaschine zum ersten Mal
formulierte. Die folgenden Jahre verbrachte er an der Princetown University mit
einem Aufbaustudium, in dessen Verlauf er seine Doktorarbeit „Sytems of logic
based on ordinals“ schrieb. Er entwickelt darin die nicht-finite Logik weiter.
Seite |5

Während den Kriegsjahren trug Turing mithilfe seiner theoretischen Grundlagen


maßgeblich zur Dechiffrierung von deutschen Funksprüchen bei. Er leistete damit
einen nicht geringen Beitrag, der zum Sieg der Alliierten im U-Bootkrieg beigetragen
haben könnte.
Nach der Kapitulation Deutschlands widmete er sich der Entwicklung von
Computern am National Physical Laboratory in Teddington, später an der
Universität in Manchester. Dort entwickelte er eine Software für einen der ersten
echten Rechner, wobei er sich nebenbei immer mit theoretischen, mathematischen
Arbeiten beschäftigte. In dieser Zeit veröffentlichte er auch seine Gedanken zur
künstlichen Intelligenz. Er formuliert darin den sogenannten Turing-Test. Es wird
dabei untersucht, ob Intelligenz einer bestimmten Maschine der eines Menschen
ebenbürtig ist. Turing sagt, dass dies der Fall sei, sobald man in einem Gespräch mit
der Maschine über eine Tastatur, d.h. ohne Sichtkontakt, diese nicht von einem
Menschen unterscheiden kann.
Ab 1952 forschte Turing auch an mathematischen Problemen in der Biologie. So ist
ein nach ihm benannter Mechanismus in der Biologie immer noch Ansatzpunkt
vieler aktueller Theorien.
Im Jahr 52 wurden die Strafverfolgungsbehörden durch einen Einbruch in seinem
Haus auf seine Homosexualität aufmerksam. Die Neigung zum gleichen Geschlecht
hatte er schon im College festgestellt, doch barg sie bisher keine Probleme für ihn.
Doch damals standen in England homosexuelle Handlungen noch unter Strafe. In
Folge dessen wurde er wegen „grober Unzucht und Perversion“ angeklagt und
verurteilt. Turing sollte sich zwischen Haftstrafe und psychiatrischer Behandlung
entscheiden, worauf der letzteres bevorzugte. Infolge der eingeleiteten
Hormonbehandlung veränderte sich sein Körper und eine Depression entwickelte
sich als Nebenwirkung der „Therapie“. 1954 schließlich nahm sich Turing
vermutlich selbst das Leben mit einem durch Cyanid vergifteten Apfel.

2. DIE TURINGMASCHINE IN DER THEORIE

Im Folgenden wird zunächst die Turingmaschine erklärt, hierauf wird sie formal
definiert, zuletzt wird ihre Bedeutung in der theoretischen Informatik beleuchtet.

2.1 WAS IST EINE TURINGMASCHINE?

(vgl. 1; 12; 18; 25)

Eine Turingmaschine (=TM) besteht aus einem (idealerweise) unendlichen Band,


auf dem Felder festgelegt sind, einem Lese-/Schreibkopf, der immer genau auf
einem Feld positioniert ist und einer Steuereinheit.
Die Felder sind je mit einem Zeichen aus dem erlaubten Alphabet oder einem
Leerzeichen beschrieben. Sie können vom Lese-/Schreibkopf analysiert und
verändert werden. Zusätzlich kann der Lese-/Schreibkopf über das Band bewegt
werden, sodass dieser alle Felder erreicht. Das Band muss insofern „unendlich“ sein,
da der Lese-/Schreibkopf nie an die Grenzen des Bandes stoßen darf.
Seite |6

Die Steuereinheit koordiniert alle obigen


Aktionen. Sie kann verschiedene
„Zustände“ erreichen. Der Zustand
bestimmt, wie auf die Zeichen, die sich
auf dem Band befinden, reagiert werden
soll. Die TM startet in einem bestimmten
Startzustand. Auch muss ein Endzustand
vorhanden sein, in den sie nach endlicher
Zeit wechselt und anhält. Damit ist eine
„Berechnung“ der Turingmaschine beendet.

Eine TM macht eine „Berechnung“ durch viele kleine Schritte. Jeder dieser Schritte
ist nach dem gleichen Schema aufgebaut:

1. Prüfen des Zustandes Die Kombination aus Zustand und


2. Auslesen des Bandes ausgelesenem Zeichen bestimmt,

↓ ↓ ↓ ↓

3. Zustandsänderung in welchen Zustand gewechselt wird

4. Schreiben eines Zeichens auf das Band was für ein Zeichen auf das Band
geschrieben wird

5. Bewegen des Lese-/Schreibkopfes und wohin der Lese-/Schreibkopf


zum nächsten Feld bewegt werden soll

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)

Eine Überführungsfunktion hat immer den Aufbau:


(Zustand, ausgelesenes Zeichen) (neuer Zustand, zu schreibendes Zeichen, Bewegung)
Auf der linken Seite des Pfeils stehen die zwei Bedingungen, bestehend aus dem
nötigen Zustand und dem vom Band gelesenen Zeichen. Auf die rechte Seite werden
die drei darauf folgenden Anweisungen geschrieben. Die Zustände werden mit
Seite |7

bezeichnet. Der Endzustand wird geschrieben, der Startzustand


ist . Die zu schreibenden und zu lesenden Werte werden mit sich selbst
bezeichnet. Die Bewegungsrichtung für den Schreib-/Lesekopf wird mit für
„rechts“, für „links“ und für „neutral“ verdeutlicht.

Bsp. :

Diese Überführungsfunktion sagt aus: Wenn sich die TM im Zustand


befindet und auf dem Band ein steht, soll in den Zustand gewechselt
werden. Zusätzlich soll ein an die Stelle (an der vorher das stand)
geschrieben werden und das Band nach rechts bewegt werden.

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

2.1.3 Ein praktisches Beispiel (Bagger)


Das klingt jetzt wahrscheinlich alles ein wenig abstrakt. Das liegt daran, dass die TM
ist gedankliches Modell ist, mit dem man versucht die Typ-0 Grammatiken (vgl.
Kapitel 2.3.2 und 2.3.4) zu beschreiben und den Begriff der Berechenbarkeit (vgl.
Kapitel 2.3.5 ) zu definieren.
Obwohl es daher schwer anschaulich darzustellen ist, wird im Folgenden versucht
das Prinzip durch einen realen Bezug ein wenig zu verdeutlichen.

Ein Baggerfahrer (=Steuereinheit) sitzt in seinem Bagger (=Lese-/Schreibkopf) und


hat die Aufgabe die Landschaft (=Band) zu ebnen. Nun beginnt er an den Stellen
(=Felder) die zu hoch sind etwas abzutragen; zu niedrige füllt er mit Abraum auf
und passende belässt er so. Hat er die Verbindung zwischen zwei schon fertig
geteerten Straßen eingeebnet, hört er auf und macht Brotzeit.

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.

2.2 FORMALE DEFINITION

(vgl. 1; 20; 29)


Definition. Eine Turingmaschine M wird
durch ein 7-Tupel beschrieben

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:

2.3 BEDEUTUNG IN DER THEORETISCHEN INFORMATIK

Um die Bedeutung der Turingmaschine erläutern zu können, müssen zuerst ein paar
Grundlagen der theoretischen Informatik erklärt werden.

2.3.1 Formale Sprachen


(vgl. 1; 26)

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

Menge aller möglichen Verbindungen:

wobei das leere Wort ist

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:

Bsp.: Ich bin müde

Der Ausdruck kann durch den folgenden Baum gebildet werden.

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:

Hierbei ist die Möglichkeit gegeben, für eine Variable mehrere


Ableitungsmöglichkeiten zu bieten. So kann z.B. entweder auf oder
auf abgeleitet werden. So wird ein
Einschieben eines Summanden ermöglicht, somit eine beliebige Verlängerung des
Terms realisiert. Es ist aber ebenso die Ableitung kurzer Terme möglich. Auch
können durch die verschiedenen Möglichkeiten abzuleiten
unterschiedlich lange Zahlen erstellt werden. Ein Beispiel mit dieser Grammatik:

Bsp. :

Die Ableitung sieht im Syntax-Baum folgendermaßen aus:

Der Term wird schrittweise abgeleitet. Zuerst wird die Regel

benutzt, um abzuleiten. Daraufhin wird einmal zu


und einmal zu . Die Variable wird nochmal erweitert zu
gemäß der Regel:

Daraufhin werden die letzten Variablen durch Terminalsymbole ersetzt,


wird zu , wird zu .
S e i t e | 12

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.

Die Mengen der Sprachtypen, die durch die jeweilige


Grammatik definiert werden, verhalten sich
zueinander folgendermaßen:

2.3.4 Automaten und dazugehörige Sprachen


(vgl. 1; 9)

Nun kann man die Sprachen der Chomsky-Hierarchie


anstelle von Grammatiken auch mit sog. Automaten
definieren. Es gibt für jeden Typ einen oder mehrere
korrespondierende Automaten. Auch die
Turingmaschine ist ein solcher Automat.
S e i t e | 13

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.

Typ-2 Sprachen können von nichtdeterministischen Kellerautomaten definiert


werden. Der Aufbau dieser ähnelt dem der TM.

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.

Ein Wort ist dann Teil einer Typ-3 Sprache,


wenn sich der Automat in einem Endzustand
befindet, wenn das Wort durchlaufen ist.
Man kann endliche Automaten auch mit
Zustandsgraphen visualisieren. Hierbei wird
der Startzustand mit einem eingehenden
Pfeil bezeichnet und der Endzustand mit
einem doppelten Ring. Ein Beispiel
anhand nebenstehender Grafik:

Das Wort lässt den Automaten


zuerst von nach übergehen. Mit den nächsten beiden ’s wechselt er zu und
danach , worauf ihn die ’s wieder zu , , und schließlich zu bringen. Der
Automat befindet sich am Schluss in einem Endzustand, also ist das Wort in der vom
Automat definierten Sprache enthalten.
S e i t e | 15

2.3.5 Auswirkungen auf die Berechenbarkeitstheorie


(vgl. 1, 25)

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.

3. NACHBAU DER TURINGMASCHINE

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:

- Band mit beschreib- und auslesbaren Feldern


- Lesekopf
- Schreibkopf
- Steuereinheit, die die Überführungsfunktionen ausführt

3.1.1 Die Steuereinheit


Die Steuereinheit wird hier mit einem
programmierbaren LEGO Microcontroller,
dem RCX (Robotics Command System),
realisiert. Der RCX empfängt die
nötigen Daten (Wert des Bandes,
Bandposition) und speichert den
aktuellen Zustand.
Dementsprechend führt er die
Anweisungen der programmierten
Überführungsfunktionen aus. Die
Übersetzung der Überführungsfunktionen
in ein Programm wird in 3.2 abgehandelt.
S e i t e | 16

3.1.2. Das Band


Man muss entweder das Band unter dem Lese-/Schreibkopf bewegen oder
andersherum, um die verschiedenen Felder zu erreichen. Die Lese-/Schreibeinheit
kann jedoch schlecht über das Band bewegt werden, da diese, um z.B. ihre
ausgelesenen Werte zur Steuereinheit zu schicken, mit ihr über ein Kabel verbunden
sein muss. Daher ist es einfacher das Band zu
bewegen. Dieses muss beschreibbar bzw.
lesbar sein. Die Konstruktion sieht
folgendermaßen aus:
Man baut einen Wagen, der später auf einer
Bahn verschiebbar ist. Das starre Zahnrad
(grau) auf der linken Seite wird hierzu in
eine Kette eingehängt, die den Wagen auf

der Bahn bewegt. Die Kette wird


durch einen E-Motor angetrieben.
Damit gewährleistet ist, dass das
Band immer genau um ein Feld
weitergezogen wird, wird an den E-
Motor ein Sensor angeschlossen, der
die Anzahl der Umdrehungen dessen
misst. So kann unabhängig von der
Drehgeschwindigkeit des Motors z.B. durch geringe Betriebsspannung eine
äquidistante Verschiebung des Bandes bewerkstelligt werden.
Bewegliche Kipper (rot) im inneren des Wagens können durch die Schreibeinheit
umgeklappt werden und von einem Leser analysiert werden. Sie stellen die
beschreibbaren Felder des Bandes dar.
3.1.3 Der Leser
(vgl. 10)

Die LEGO-Steine reflektieren durch ihre glatte


Oberfläche sehr gut das Licht. Der Lesekopf ist
deswegen ein Lichtsensor (blau), da dieser das in
die Photo-Diode fallende Licht misst. Zur
Verstärkung des Messsignals, ist neben dem
Sensor noch eine Lichtquelle montiert. Diese
Einheit ist wie
im
nebenstehenden
Bild leicht schräg
neben dem Band positioniert, sodass das
reflektierte Licht senkrecht, d.h. optimal, in die
Photo-Diode fällt. Ist der Kipper auf der Seite des
Lichtsensors, so wirft die glatte Oberfläche des
Kippers das Licht zurück, sodass der von der
Photo-Diode gemessene Wert hoch ist. Wenn sich
der Kipper auf der sensorabgewandten Seite
S e i t e | 17

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.1.4 Der Schreiber


Damit die Felder auf dem Band beschrieben werden können, müssen die Kipper
bewegt werden. Gleichzeitig darf der Schreibkopf die Bewegung des Bandes nicht
beeinträchtigen.
Zwei bewegliche Stangen (dunkelgrau), die
rechts und links der Kipper sind, können
deren Position verändern. Diese sind über
eine weitere Stange (grün) miteinander
verbunden. Angetrieben wird der
Schreibkopf durch einen Micromotor
(blau). Im Bild sind alle störenden Teile
weggelassen, sodass es scheint, als
schwebe der Schreiber über dem Band.

3.1.5 Vergleich mit anderen Nachbauten


(vgl. 3; 5; 8)

Die beschriebene Konstruktionsweise ist komplett von mir selbst entworfen


worden, ohne Zuhilfenahme andere Bauanleitungen. Die Ähnlichkeit mit fast allen
anderen Konstruktionsvorschlägen ist leicht zu erklären. Sie entspricht fast der
theoretischen TM. So ist im Nachbau ebenso ein Band vorhanden, ein Lese-
/Schreibkopf und eine Steuereinheit, die von Überführungsfunktionen determiniert
wird.
Es finden sich auch andere Lösungen für einen Nachbau. Doch sind diese entweder
nicht mit meinem LEGO-Teilen realisierbar oder haben zu wenig Ähnlichkeit mit
einer Turingmaschine. Denn es soll eine TM nachgebaut werden und kein ähnlicher
„Rechenroboter“.

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

3.2.2 Der RCX


(vgl. 16; 19; 27; 28)

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

und -nutzung ist in der obenstehenden Grafik


dargestellt.

Die Ausgänge sind am RCX entsprechend der


nebenstehenden Abbildung platziert. Es
existieren drei Ausgänge (A, B, C) für Motoren,
Lampen oder Ähnliches. 1, 2 und 3 sind
Eingänge, die mit Temperatur-, Licht-,
Berührungssensoren usw. belegt werden
können. Der rote Knopf (On-Off) ist der Ein-
/Ausschalter. Mit View kann man sich die Werte
der Eingänge auf dem Display anzeigen lassen.
Durch den grauen Knopf (Prgm) wählt man eins
der fünf Programme an. Der Run-Taster startet
das ausgewählte Programm.

3.2.3 Bricx und NQC


(vgl. 23; 24; 27; 28)

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.

Bricx bietet eine


Entwicklungsumgebung für
NQC und Zusatzfunktionen, wie
„Watch the Brick“, ein
umfangreiches
Überwachungstool, „Direct
Control“, mit dem eine
Bedienung fast aller Funktionen
des RCX möglich ist, und viele
weitere nützliche Hilfsmittel.
S e i t e | 20

2.3.4 Struktur / Umsetzung der Überführungsfunktionen in Programmcode


(vgl. vor allem 27)

Das Programm sollte möglichst übersichtlich und dennoch leistungsfähig gestaltet


sein.
Zum einen wird dies durch sogenannte Makros erreicht. Das sind am Anfang des
Quellcodes definierte Abläufe von Befehlen. Man könnte sich das so vorstellen: Das
zur Arbeit Fahren beinhaltet jeden Morgen die gleichen Teilschritte. Um nicht immer
alle Teilschritte aufzählen zu müssen, findet man dafür einen Überbegriff: „Weg zur
Arbeit“
So wird das auch im Programm gemacht. Man beschreibt immer wiederkehrende
Abfolgen von Befehlen mit einem Überbegriff (=Makro). Dies dient der
Vereinfachung des Programms, da man z.B. nicht mehr die einzelnen Befehle dafür
im Programmcode jedes Mal ausschreiben muss, sondern die ganze Befehlskette mit
dem Überbegriff aufrufen kann.
Wenn man z.B. das unter 3.2.3 gegebene Programm mithilfe eines Makros schreibt,
sieht das so aus:

#define write OnRev(OUT_A); Wait (43);


OnFwd(OUT_A); Wait(43); Off (OUT_A);

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:

Makro Argument Funktion


write(r) r=1 eine 1 auf das aktuelle
Feld schreiben
r=0 Eine 0 auf das aktuelle
Feld schreiben

move(s) s=0 Band nicht bewegen

s=1 Band vom Sensor aus


gesehen nach links
bewegen
s=2 Band nach rechts
bewegen

zustand(m) m=n in Zustand wechseln


mit
m=9 9 entspricht dem
Endzustand

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.

2.3.5 Eigenleistung bei der Programmierung


(vgl. 3; 5; 8)

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

Hier werden einzelne Beispielsprogramme mit dem Nachbau der TM näher


erläutert. Der Quellcode der Programme ist im Anhang beigelegt. Videos der TM in
Aktion und Bilder dazu sind ebenfalls im Anhang auf einer CD vorhanden.

3.3.1 Erhöhen einer Binärzahl um 1


(vgl. 15)

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):

Die Binärschreibweise unterscheidet sich durch die Verwendung von nur 2


Ziffersymbolen, meist 0 und 1. Ein weiterer Unterschied von dem gebräuchlichen
Zehnersystem zum Zweiersystem ist die Basis. So sind die Stellenwerte durch die
Verwendung von 2 anstatt von 10 als Basis verschieden.

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

3. Schritt: ersetzen der 1 durch eine 0, „1 gemerkt“


4. Schritt: überprüfen, welche Ziffer auf der nächsten Stelle steht
5. Schritt: es steht eine 1
6. Schritt: ersetzen der 1 durch eine 0, „1 gemerkt“
7. Schritt: überprüfen, welche Ziffer auf der nächsten Stelle steht
8. Schritt: es steht eine 0
9. Schritt: ersetzen der 0 durch eine 1

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

wenn auf nächster Stelle 0, schreibe 1 und


halte  Endzustand
wenn auf nächster Stelle 1, schreibe 0, fahre
nach rechts und überprüfe und ändere die
nächste Stelle wieder dementsprechend

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.

Diese werden nun in die Programmiersprache übersetzt und müssen in task Z0


aufgelistet werden (Code im direkten Vergleich zur Überführungsfunktion ist im
Kapitel 2.3.4 in der Tabelle zu finden). Die Überführungsfunktionen aus dem
Zustand

werden dementsprechend in task Z1 umgesetzt.

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.

3.3.2 Addieren zweier Zahlen in Unärdarstellung


(vgl. 21)

Die TM soll zwei Zahlen in der „Strichlisten“-Darstellung (=Unärdarstellung)


addieren. Diese sind getrennt durch eine Leerstelle (=0) auf das Band geschrieben.
Ist der Endzustand erreicht, so soll das Ergebnis auf dem Band stehen. Die TM
startet mit dem Lese-/Schreibkopf auf der ersten Stelle von links der linken Zahl.
S e i t e | 26

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

Abfahren der zweiten Zahl


wenn das Ende der zweiten Zahl da ist,
wechsle in und fahre auf die letzte 1 der
Zahlenkette zurück

mache die entstandene Einser-Kette um eine


Eins kürzer, da ja eine 1 in die Lücke
geschrieben wurde

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:

Das beweist die Funktionstüchtigkeit des Nachbaus ein weiteres Mal.

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

13) Alan Turing – Wikipedia


http://de.wikipedia.org/wiki/Alan_Turing
14) Chomsky-Hierarchie – Wikipedia
http://de.wikipedia.org/wiki/Chomsky-Hierarchie
15) Dualsystem – Wikipedia
http://de.wikipedia.org/wiki/Dualsystem#Geschichte
16) Festwertspeicher – Wikipedia
http://de.wikipedia.org/wiki/Festwertspeicher
17) Gottfried Wilhelm Leibniz – Wikipedia
http://de.wikipedia.org/wiki/Gottfried_Wilhelm_Leibniz#Mathematik
18) Informatik – Wikipedia
http://de.wikipedia.org/wiki/Informatik#Geschichte_der_Informatik
19) Static random-access memory – Wikipedia
http://de.wikipedia.org/wiki/Statisches_RAM
20) Turingmaschine – Wikipedia
http://de.wikipedia.org/wiki/Turingmaschine
21) Unärsystem – Wikipedia
http://de.wikipedia.org/wiki/Unärsystem
22) von-Neumann-Architektur – Wikipedia
http://de.wikipedia.org/wiki/Von-Neumann-Architektur

PDF-Dateien

23) Baum, Dave; Hansen, John


NQC Programmer's Guide
http://bricxcc.sourceforge.net/nqc/doc/NQC_Guide.pdf
24) Baum, Dave; übersetzt von Dr.-Ing. Fritz Mehner
NQC-Programmieranleitung
http://lug.fh-swf.de/lego/NQC-Guide.2.5.a4.German.pdf
25) Köbler, Johannes; Beyersdorff, Olaf
Von der Turingmaschine zum Quantencomputer – ein Gang durch die
Geschichte der Komplexitätstheorie
http://www.informatik.hu-
berlin.de/forschung/gebiete/algorithmenII/Publikationen/Papers/turing.pdf
S e i t e | 31

26) Lange, Prof. Steffen


Grundbegriffe
http://private.sit.fhg.de/~baumgart/ThInf/Folien%2000_2.pdf
27) Overmars, Mark
Programmieren von LegoMindstorms-Robotern mit NQC
http://www.tik.ee.ethz.ch/tik/education/lectures/PPS/mindstorms/common
/RCXCC-tutorial.pdf
28) Taminé, Dipl.-Inform. O.
Programmierung der Lego Mindstorms Roboter
http://www8.informatik.uni-
erlangen.de/IMMD8/Research/CHUCHU/Roboter_Programmierung.pdf
29) unbekannt
Die Turingmaschine
http://www.fz-juelich.de/jsc/math/matse/materials/informatics/algo-
ds/folien/turing.pdf
30) unbekannt
Geschichte der Informatik und des Computers
http://www.pri.univie.ac.at/scripts/betz/2004w/3_Geschichte.pdf

Biographie

31) Alan Turing: a short biography – 1-8


http://www.turing.org.uk/bio/part1.html
, http://www.turing.org.uk/bio/part2.html
, http://www.turing.org.uk/bio/part3.html
, http://www.turing.org.uk/bio/part4.html
, http://www.turing.org.uk/bio/part5.html
, http://www.turing.org.uk/bio/part6.html
, http://www.turing.org.uk/bio/part7.html
, http://www.turing.org.uk/bio/part8.html

Bilder und Grafiken

Alle Bilder und Grafiken in dieser Facharbeit sind von mir selbst erstellt,
ausgenommen:

• Bild von A. Turing unter 1.1


Quelle: http://www.atariarchives.org/deli/turing.jpg
• Informationsgrafik über die Speicheraufteilung des RCX unter 3.2.2
Quelle: kopiert aus http://www8.informatik.uni-
erlangen.de/IMMD8/Research/CHUCHU/Roboter_Progr
ammierung.pdf
5.3 Benutzte Software

• Bricx Command Center


die Entwicklungsumgebung für NQC
http://bricxcc.sourceforge.net/
• Excel 2007
http://office.microsoft.com/de-de/excel/default.aspx
S e i t e | 32

• 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:

/* … */ bedeutet mehrzeiliger Kommentar

// … bedeutet einzeiliger Kommentar

6.1.1 Erhöhen einer Binärzahl um 1


Hier ist der Quelltext für das Beispiel 3.3.1 Erhöhen einer Binärzahl um 1
abgedruckt.

int dunkel=110;// Minimal- und Maximalwertvariablen werden initialisiert


int hell=0; /* ihnen werden zur besseren Bearbeitung im Programm
entgegengesetzte Werte gegeben */

#define move(s) ClearSensor(SENSOR_2);if(s==1) { OnRev(OUT_C);


until((SENSOR_2 >= 39) || (SENSOR_2 <= -39));
Off(OUT_C);} if(s==2) { OnFwd(OUT_C); until((SENSOR_2 >=
39) || (SENSOR_2 <= -39)); Off(OUT_C);}

/* 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 */

#define write(r) if(r==1){OnRev(OUT_A); Wait (43) ; OnFwd(OUT_A);


Wait(43); Off (OUT_A) ;} else {OnFwd(OUT_A); Wait (43)
; OnRev(OUT_A); Wait(43); Off (OUT_A) ;}

/* write(1) klappt den Kipper vom Sensor weg, was einer 1 entspricht
write(0) bringt den Kipper an den Sensor (=0) */

#define zustand(m) if(m==0){ start Z0;}if(m==1){ start Z1;}if(m==2){


start Z2;}if(m==3){ start Z3;} if(m==4){ start Z4;}
if(m==5){ start Z5;}if(m==6){ start Z6;}if(m==7){
start Z7;}if(m==8){ start Z8;}if(m==9){ PlaySound
(SOUND_UP);Off(OUT_B);}

/* 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);
}
}

/* die folgenden Tasks sind leergelassen, da sie nicht für die


Programmierung des Beispiels benötigt werden. Sie müssen aber vorhanden
sein, da sonst die unter dem Makro zustand(m) getätigten Taskaufrufe ins
leere führen würden */

task Z2 ()
{

task Z3 ()
{

task Z4 ()
{

}
S e i t e | 35

task Z5 ()
{

task Z6 ()
{

task Z7 ()
{
}

task Z8 ()
{
}

6.1.2 Addieren zweier Zahlen in Unärdarstellung

int dunkel=110; /* Minimal- und Maximalwertsvariablen werden


initialisiert*/
int hell=0; /* ihnen werden zur besseren bearbeitung im Programm
entgegengesetzte Werte gegeben*/

#define move(s) ClearSensor(SENSOR_2);if(s==1) { OnRev(OUT_C);


until((SENSOR_2 >= 39) || (SENSOR_2 <= -39)); Off(OUT_C);} if(s==2) {
OnFwd(OUT_C); until((SENSOR_2 >= 39) || (SENSOR_2 <= -39)); Off(OUT_C);}

/* 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 */

#define write(r) if(r==1){OnRev(OUT_A); Wait (43) ; OnFwd(OUT_A);


Wait(43); Off (OUT_A) ;} else {OnFwd(OUT_A); Wait (43) ; OnRev(OUT_A);
Wait(43); Off (OUT_A) ;}

/* write(1) klappt den Kipper vom Sensor weg, was einer 1 entspricht
write(0) bringt den Kipper an den Sensor (=0) */

#define zustand(m) if(m==0){ start Z0;}if(m==1){ start Z1;}if(m==2){


start Z2;}if(m==3){ start Z3;} if(m==4){ start Z4;} if(m==5){ start
Z5;}if(m==6){ start Z6;}if(m==7){ start Z7;}if(m==8){ start Z8;}if(m==9){
PlaySound (SOUND_UP);Off(OUT_B);}

/* 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

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;
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 ()
{

6.2 CD MIT DATEIEN ZUR FACHARBEIT

Auf der CD befinden sich:

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.

………………………………… ……………………………….. ……………………………………………...


Ort Datum Unterschrift des Schülers