Kapitel 10

10 Algorithmen 477
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
10 Algorithmen
Das WAS bedenke, mehr bedenke WIE.
J.W. von Goethe, Faust II
10.1 Berechenbarkeit
10.1.1 Algorithmen und ihre prinzipielle Ausführung
In den vorausgegangenen Kapiteln wurde gezeigt, dass die durch einen Computer zu bearbeitenden
Aufgaben durch eine endliche Aneinanderreihung einfacher Anweisungen, – letztlich
in Maschinensprache – beschrieben werden müssen. Eine solche Beschreibung, wie
eine Aufgabe auszuführen ist, bezeichnet man als Algorithmus. Der Begriff Algorithmus leitet
sich vom Namen des arabischen Gelehrten Al Chwarizmi ab, der um 820 lebte.
Prozedurale Algorithmen
Unter einem Algorithmus, im engerem Sinne einem prozeduralen Algorithmus, versteht man
eine Vorschrift zur Lösung einer Klasse von Problemen in Form einer endlichen Anzahl elementarer
Aktionen, die man als Zustandsübergänge eines (technischen) Systems interpretieren
kann, wobei die Zustände durch Variablen gekennzeichnet werden. Die Klasse der Probleme
entspricht dem Definitionsbereich des Algorithmus, die Auswahl bestimmter Probleme
erfolgt durch Parameter. Der Lösungsplan soll darüber hinaus nach Möglichkeit so allgemein
formuliert werden, dass er für eine Klasse ähnlich gelagerter Probleme anwendbar ist. Die
elementaren Aktionen müssen klar, eindeutig und hinreichend einfach sein, so dass auf
Grund von vorgegebenen Definitionen ihre Ausführung immer möglich ist. Die Werte der Variablen
können nach dem Schema Eingabe-Verarbeitung-Ausgabe (EVA) als Startwerte (Parameter)
von außen vorgegeben werden (Eingabe), sie können durch die einzelnen Aktionen
des Algorithmus geändert (Verarbeitung, Wertzuweisung) und nach außen übertragen werden
(Ausgabe). Sinnvollerweise verlangt man, dass mindestens ein Ergebnis als Ausgabewert
erscheint. Wegen der endlichen Anzahl der Aktionen ist ein Algorithmus statisch finit.
Von den Aktionen fordert man, dass sie effektiv in endlicher Zeit und unter Verwendung endlicher
Ressourcen (z.B. Speicherplatz) ausführbar sein müssen. Daraus ergibt sich, dass ein
Algorithmus auch dynamisch finit sein muss, dass also alle benötigten Ressourcen zu jedem
beliebigen Zeitpunkt der Abarbeitung endlich sein müssen. Stoppt der Algorithmus für jede
gültige Eingabe nach endlich vielen Schritten, so heißt er terminierend.
Auch nicht-terminierende Algorithmen können durchaus sinnvoll sein, so etwa Prozess-
Steuerungen und Betriebssysteme. Gibt es nach jeder Aktion nur eine Folgeaktion, so heißt
der Algorithmus determiniert. Man kann die Bedingung der Determiniertheit aufgeben und
nicht-determinierte Algorithmen in Betracht ziehen, bei denen nach einer Aktion verschiedene
Folgeaktionen zur Verfügung stehen. Auch nicht-determinierte Algorithmen haben eine
praktische Bedeutung. Beispiel: Soll eine Verbindung in einem Netz von Knoten A nach Knoten
B aufgebaut werden, so können ungeachtet des detaillierten Verbindungsweges über
verschiedene andere Knoten unterschiedliche Lösungen existieren und akzeptabel sein. Die
Eindeutigkeit ist in diesem Falle also von untergeordneter Bedeutung. Erfolgt die Auswahl
alternativer Aktionen zufällig, so spricht man von einem stochastischen Algorithmus.

478 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Schritte bei der Ausführung von Algorithmen
Algorithmen sind ein grundlegendes Konzept der Informatik, denn eine der großen Hauptaufgaben
der Informatik ist ja gerade die Konstruktion von Algorithmen und deren Umsetzung
in Programme.
Dabei ist in folgenden Schritten vorzugehen:
• Zunächst muss ein Algorithmus zur prinzipiellen Lösung des anstehenden Problems gefunden
werden. Wesentlich ist dabei die Beschreibung der Ein- und Ausgabedaten sowie die
funktionale Abhängigkeit zwischen diesen. Man bezeichnet diesen Schritt als Algorithmierung.
• Im nächsten Schritt, der Programmierung, ist der Algorithmus als Programm zu formulieren.
Die dazu verwendete Programmiersprache soll als Bindeglied zwischen Mensch und Maschine
von den Maschinendetails möglichst abstrahieren und eine aus Sicht des Programmierers
möglichst einfache und vollständige Formulierung beliebiger Algorithmen unterstützen.
• Der letzte Schritt ist die Ausführung des Programms auf einem Computer. Dazu müssen
die in der gewählten Programmiersprache formulierten Anweisungen interpretiert und in
endlich viele, einfache, direkt ausführbare Einzelaktionen umgesetzt werden können. Dabei
müssen auch die benötigten Ressourcen zu jeder Zeit endlich bleiben.
Grundsätzliche Fragen bei der Ausführung von Algorithmen
Bei der Ausführung von Algorithmen stellen sich die folgenden grundsätzlichen Fragen:
• Kann jedes Problem durch einen Algorithmus beschrieben werden, also zumindest prinzipiell
bei genügend großem Bemühen gelöst werden?
• Kann jeder Algorithmus in ein Programm übertragen werden? Oder anders ausgedrückt:
Welchen Anforderungen muss eine Programmiersprache genügen, damit jeder Algorithmus
damit formuliert werden kann?
• Ist ein Computer grundsätzlich in der Lage, einen bekannten, als Programm formulierten
Algorithmus auszuführen?
• Was ist ein Computer als formales System?
Die erste dieser Fragen bezieht sich auf die Berechenbarkeit von Problemen, die zweite auf
die Theorie der Programmiersprachen und die dritte auf die Komplexität von Algorithmen
bzw. Programmen. Alle diese Fragen erfordern über die oben gegebenen Definitionen hinaus
eine mathematische Präzisierung des Begriffs Algorithmus. Eine zentrale Aufgabe der
Informatik im Zusammenhang mit der Komplexitätstheorie ist es, nicht nur irgendeinen Algorithmus
zur Lösung eines Problems zu finden, sondern einen möglichst effizienten, wobei
man die Effizienz etwa am Speicherbedarf oder an der benötigten Ausführungszeit messen
kann.
Von grundsätzlicher Bedeutung ist dabei: wie lässt sich ein Computer als abstraktes Modell,
d.h. als ein auf das Wesentliche beschränktes formales System beschreiben? Insbesondere
ist zu klären, inwieweit verschiedene formale Ansätze (Turing-Maschine, Schaltwerke, formale
Sprachen etc.) wirklich vollständige Beschreibungen des Systems Computer bieten und
inwieweit diese zueinander äquivalent sind.

10 Algorithmen 479
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
10.1.2 Entscheidungsproblem und Church-Turing-These
Lange Zeit war die Mehrzahl der Mathematiker der Ansicht, dass man von jeder Aussage
algorithmisch entscheiden könne, ob sie wahr oder falsch sei. Anders ausgedrückt, man
glaubte, dass man immer zeigen könne, jedes Problem sei entweder lösbar oder unlösbar.
Es handelt sich hier um das berühmte Entscheidungsproblem, das um 1930 in einer Konfrontation
zwischen den beiden Mathematikern David Hilbert (1862-1942) und Kurt Gödel
seinen Höhepunkt und seine Lösung fand: Gödel wies in seinem Unvollständigkeitstheorem
[Göd31] im Jahre 1931 nach, dass alle widerspruchsfreien axiomatischen Formulierungen
der Zahlentheorie unentscheidbare Aussagen enthalten. Mit der Erkenntnis, dass eben nicht
jede Aussage algorithmisch entscheidbar ist, war der Nachweis geführt, dass streng algorithmisch
arbeitende Computer prinzipiell nicht jedes Problem lösen können. Dies wurde bemerkenswerterweise
zu einer Zeit entdeckt, als es noch gar keine Computer gab. Vereinfacht
ausgedrückt bedeutet das Unvollständigkeitstheorem auch, dass Wahrheit eine höhere
Qualität besitzt als Beweisbarkeit.
Möchte man beweisen, dass zu einem bestimmten Problem kein Algorithmus zu dessen Lösung
existiert, so muss man den Begriff Algorithmus formalisieren. Hierzu gibt es verschiedene
Ansätze, die teilweise schon in vorausgehenden Kapiteln eingeführt worden sind. Verwendet
man das Konzept der Turing-Maschine als Modell zur formalen Beschreibung von
Algorithmen, dann ist jedes Problem algorithmisch lösbar, das als Turing-Maschine dargestellt
werden kann. Ein Computer ist dann äquivalent zu einer universellen Turing-Maschine
U, d.h. zu einer Turing-Maschine, die jede andere Turing-Maschine T simulieren kann. Zur
Programmierung von U muss auf dem Eingabeband von U eine Beschreibung der zu simulierenden
Turing-Maschine T gespeichert werden und außerdem die Eingabe x, die von T
verarbeitet werden soll. Die Eingabe x wird dann von U in genau derselben Weise verarbeitet,
wie dies durch T geschehen würde. In diesem Sinne ist also die universelle Turing-
Maschine U eine abstrakte Beschreibung für jeden Computer.
Es konnte ferner gezeigt werden, dass zu jeder Darstellung eines Algorithmus (der für eine
berechenbare Funktion steht) in Form einer Turing-Maschine die Formulierung desselben
Problems als formale Sprache, als Programm auf einer Registermaschine oder als Schaltwerk
äquivalent ist. Es gibt noch weitere Beschreibungsmöglichkeiten von Algorithmen, etwa
durch rekursive Funktionen, die sich aus einfachen, offensichtlich berechenbaren Funktionen
bilden lassen. Es besteht daher nach A. Church und A. Turing eine sehr starke Evidenz (ohne
dass ein strenger mathematischer Beweis möglich wäre) dafür, dass nicht nur die oben
genannten verschiedenen Möglichkeiten der Formalisierung von Algorithmen gleichwertig
sind und zu denselben Ergebnissen über die Berechenbarkeit von Problemen führen, sondern
dass dies allgemein für alle im intuitiven Sinn „vernünftigen“ Formalisierungen gilt. Dieser
Sachverhalt ist als die Church-Turing-These bekannt. Mit anderen Worten: Wenn ein
Problem nicht durch eine Turing-Maschine gelöst werden kann, so ist es überhaupt nicht
algorithmisch lösbar.
Obwohl die Church-Turing-These wegen des Bezugs auf mathematisch nicht präzisierbare
Begriffe wie „intuitiv“ und „vernünftig“ nicht beweisbar ist, werden Beweise auf der Grundlage
dieser These allgemein akzeptiert. Man definiert auf diesem Hintergrund die zentralen
Begriffe Berechenbarkeit und Entscheidbarkeit, bzw. Beweisbarkeit wie folgt:
Definition
Eine Funktion f(x) heißt berechenbar, wenn es einen Algorithmus gibt, der bei gegebenem x
das Ergebnis f(x) liefert.
Eine gegebene Menge M heißt entscheidbar, wenn es einen Algorithmus gibt, der für jedes
vorgegebene Element x die Aussage liefert, ob x in M enthalten ist oder nicht.

480 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Es muss nicht berechenbare Funktionen geben
Die Vermutung, dass in diesem Sinne nicht jede Funktion berechenbar ist, liegt eigentlich
nahe und lässt sich wie folgt erhärten:
Ein Algorithmus muss wegen der Abbildung auf eine Turing-Maschine in jedem Falle durch
ein Alphabet A mit einem endlichen Zeichenvorrat dargestellt werden können. Im Falle einer
Turing-Maschine ist dazu ja sogar das binäre Alphabet A={0, 1} ausreichend. Wie bereits
früher gezeigt, umfasst der Nachrichtenraum A* zwar unendlich viele, aber abzählbar viele
verschiedene Zeichenreihen. Es gibt daher auch nur abzählbar viele Algorithmen, d.h. alle
Algorithmen könnten unter Verwendung der natürlichen Zahlen im Prinzip durchnummeriert
werden. Außerdem kann jeder Algorithmus nach seiner Definition nur eine Funktion berechnen.
Da aber die Menge aller Funktionen sicher überabzählbar ist (wie die Menge der reellen
Zahlen), folgt, dass es in diesem Sinne nicht berechenbare Funktionen geben muss und
dass diese Menge der nicht berechenbaren Funktionen sogar überabzählbar sein muss.
10.1.3 Das Halteproblem
Wie bereits ausgeführt, gibt es Probleme, die nicht berechenbar sind, d.h. Aussagen, von
denen nicht ermittelt werden kann, ob sie wahr oder falsch sind. Hierbei wird nicht nur behauptet,
es gäbe Probleme, zu deren Lösung noch kein Algorithmus bekannt sei, sondern es
wird die viel stärkere Aussage gemacht, dass deshalb kein Algorithmus zur Lösung derartiger
Probleme gefunden werden konnte, weil ein solcher grundsätzlich nicht existiert.
Ein berühmtes Beispiel für ein nicht berechenbares Problem ist das Halteproblem. Dabei
geht es um die Frage, ob es einen Algorithmus gibt, mit dessen Hilfe man für ein beliebiges
Programm P bestimmen kann, ob es mit beliebigen Eingabedaten D jemals stoppen wird
oder nicht. Mit anderen Worten: es soll geprüft werden, ob ein Programm in eine Endlosschleife
geraten kann. In der Praxis verlangt man einfach, dass ein Programm innerhalb einer
bestimmten Zeitspanne zu einem Ende kommen muss, andernfalls wird es vom Bediener
zwangsweise abgebrochen. Für eine theoretische Überlegung ist diese Vorgehensweise
natürlich wenig tauglich.
Der Beweis, dass das Halteproblem tatsächlich nicht berechenbar ist, wird wie folgt geführt:
Man nimmt zunächst an, es existiere ein Algorithmus zur Lösung des Halteproblems. Man
kann dann ein Programm TEST schreiben, das als Eingabedaten das zu testende Programm
P erhält. Da getestet werden soll, ob ein beliebiges Programm P mit beliebigen Eingabedaten
stoppt, kann man insbesondere auch den Programmtext von P selbst als Eingabedaten für
das zu testende Programm P benützen, auch wenn das Programm P damit nicht unbedingt
eine sinnvolle Ausgabe liefert. So abwegig ist dieses Vorgehen aber durchaus nicht: ein Editor
muss beispielsweise auch in der Lage sein, seinen eigenen Programmtext zu editieren.
Das Testprogramm TEST soll nun JA ausgeben, falls P stoppt und NEIN, falls P nicht stoppt,
also in eine Endlosschleife gerät. Damit ergibt sich das folgende Flussdiagramm:
Rufe TEST mit P als Eingabedaten
Prüfe, ob P mit P als Eingabedaten stoppt
P stoppt
Gib aus: JA
P stoppt nicht
Gib aus: NEIN
Abbildung 10.1.1:
Flussdiagramm des Programms TEST zum Beweis
der Nichtberechenbarkeit des Halteproblems.

10 Algorithmen 481
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Im nächsten Schritt wird, immer noch unter der Annahme, es gäbe einen Algorithmus zur
Lösung des Halteproblems, das folgende Programm TEST1 konstruiert:
Rufe TEST1 mit P als Eingabedaten
Rufe TEST mit P als Eingabedaten
Prüfe, ob TEST JA oder NEIN ausgibt
TEST gibt JA aus
TEST gibt NEIN aus
Gehe in Endlosschlei- Stoppe
Abbildung 10.1.2:
Flussdiagramm des Programms TEST1 zum Beweis
der Nichtberechenbarkeit des Halteproblems.
Nun wird das Programm TEST1 mit dem Programmtext von TEST1 als Eingabedaten aufgerufen.
Dies ist erlaubt, da das zu testende Programm ja jedes beliebige Programm sein darf,
also auch TEST1 selbst. Damit ergibt sich aber ein Widerspruch, denn nimmt man an, TEST1
stoppt, so folgt, dass TEST1 nicht stoppt und umgekehrt. Aus diesem Widerspruch folgt
zwingend, dass die ursprüngliche Annahme, es gäbe einen Algorithmus zur Lösung des Halteproblems,
falsch war. Damit ist bewiesen, dass das Halteproblem in der Tat nicht berechenbar
ist.
Beweis durch Widerspruch und Strange Loops
Die zum Beweis der Nichtberechenbarkeit des Halteproblems verwendete Technik des Beweises
durch Widerspruch wird in ähnlichen Zusammenhängen häufig verwendet. Oft soll
die Behauptung bewiesen werden, ein bestimmtes Problem P sei nicht lösbar, d.h. nicht berechenbar.
Man nimmt nun an, es gäbe einen Algorithmus der das Problem P löst. Lässt
sich dann unter Verwendung dieser Annahme ein Programm (das z.B. auf einer Turing-
Maschine oder einer Registermaschine lauffähig wäre) konstruieren, das widersprüchlich
arbeitet, so ist die Annahme falsch und die ursprüngliche Behauptung, P sei nicht lösbar bzw.
nicht berechenbar, ist bewiesen.
Die Essenz dieser auf den ersten Blick etwas spitzfindig anmutenden Beweisführung folgt
aus sich gegenseitig widersprechenden Aussagen (sog. Strange Loops), die typisch für
diese Klasse von Problemen sind. Auch beim Beweis des Unvollständigkeitstheorems hat
Gödel diese Methode angewendet. Man kann solche widersprüchlichen Aussagen auch
sprachlich formulieren, wie folgende Kostprobe zeigt:
„Der folgende Satz ist wahr.“
„Der vorhergehende Satz ist falsch.“
Beweis durch Reduktion
Eine weitere in der Theorie der Berechenbarkeit viel verwendete Beweismethode ist die Reduktion.
Man führt dabei ein ungelöstes Problem auf ein gelöstes zurück. Man sagt, eine
Menge M⊆N ist reduzierbar auf M'⊆N, wenn es eine eindeutige, berechenbare Funktion
f(n):N→N gibt, so dass f(n)∈M' genau dann gilt, wenn n∈M ist. Es gilt dann der Satz:
Ist M auf M' reduzierbar und ist M' entscheidbar, dann ist auch M entscheidbar. Ist dagegen
M' nicht entscheidbar, so ist auch M nicht entscheidbar.

482 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Gelingt es also beispielsweise, durch eine Abbildungsvorschrift ein Problem P auf ein nicht
berechenbares Problem, z.B. das Halteproblem, zurückzuführen, so ist gezeigt, dass auch P
nicht berechenbar ist.
Das Äquivalenzproblem und partielle Berechenbarkeit
Neben dem Halteproblem gibt es eine ganze Reihe weiterer nicht berechenbarer Probleme
mit durchaus praktischer Relevanz, so beispielsweise das Äquivalenzproblem. Dabei geht es
darum, zu entscheiden, ob zwei Programme dieselbe Aufgabe lösen (d.h. in diesem Sinne
zueinander äquivalent sind) oder nicht. Ein Vergleich des Halteproblems und des Äquivalenzproblems
zeigt auch, dass es zwei Klassen der Nichtberechenbarkeit gibt: Im Falle des
Halteproblems wird das zu testende Programm in vielen Fällen stoppen, das hypothetische
Testprogramm wird dann die Antwort JA ausgeben. In diesem Fall kann man auch nachvollziehen,
warum das getestete Programm gerade mit den verwendeten Eingabedaten stoppt.
Man bezeichnet das Halteproblem daher als partiell nicht berechenbar. Das Äquivalenzproblem
ist dagegen so geartet, dass es selbst dann keine allgemein gültige Methode gibt, die
Äquivalenz zweier Programme zu beweisen, wenn diese tatsächlich äquivalent sind.
Sowohl für das Halteproblem als auch für das Äquivalenzproblem muss nochmals betont
werden, dass es um eine allgemeine Methode geht. Es können also in beiden Fällen durchaus
Algorithmen gefunden werden, die für einzelne Programme oder auch eine eingeschränkte
Menge von Programmen das Halteproblem bzw. das Äquivalenzproblem lösen.
10.1.4 Primitiv rekursive Funktionen
Für eine detailliertere Untersuchung der Berechenbarkeit von Problemen ist die hier vorgestellte
Möglichkeit der formalen Beschreibung durch rekursive Funktionen sehr nützlich.
Zunächst wird die Klasse der primitiv rekursiven Funktionen betrachtet. Diese entstehen aus
einigen einfachen Grundfunktionen über einem beliebigen Alphabet, auf welche man endlich
viele Operationen anwenden kann. Da jedes Alphabet definitionsgemäß auf die natürlichen
Zahlen mit Null N0 abbildbar ist, genügt es, nur N0 zu betrachten. Die reellen Zahlen werden
so nicht erfasst, was ja auch nicht erforderlich ist, da wegen der notwendigen Stellenzahlbeschränkung
reelle Zahlen ohnehin in diesem Sinne nicht berechenbar sind. Rationale Zahlen,
d.h. Brüche, sind dagegen als Paare von natürlichen Zahlen der Art (Zähler / Nenner)
darstellbar. Hierbei wird ausgenutzt, dass die Menge der rationalen Zahlen abzählbar ist, im
Gegensatz zu der überabzählbaren Menge der reellen Zahlen. Die Abzählbarkeit der rationalen
Zahlen sieht man sofort durch folgendes Schema:
Tabelle 10.1.1: Ordnet man die rationalen Zahlen als zweidimensionales Schema an, so kann leicht
eine eineindeutige Abbildung (Durchnummerieren) auf die natürlichen Zahlen angegeben werden.
1: 1/1 2: 1/2 6: 1/3 7: 1/4 15: 1/5 16: 1/6 28: 1/7 .....
3: 2/1 5: 2/2 8: 2/3 14: 2/4 17: 2/5 27: 2/6 .....
4: 3/1 9: 3/2 13: 3/3 18: 3/4 26: 3/5 .....
10: 4/1 12: 4/2 19: 4/3 25: 4/4 .....
11: 5/1 20: 5/2 24: 5/3 .....
21: 6/1 23: 6/2 .....
22: 7/1.....
.....

10 Algorithmen 483
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Von diesen Überlegungen ausgehend, wird die Klasse P der primitiv rekursiven Funktionen
wie folgt definiert:
Definition: Die Klasse der primitiv rekursiven Funktionen ist die kleinste Klasse P von Funktionen
über N0 für die gilt:
1. Die konstante Funktion C n ist in P:
∀n ∈N ist C : N → N mit C (x) = 0 ∀x ∈N
in
2 1 2 3 2
n n n n
0 0 0 P
Das Argument x der Funktion C ist hier also ein n-Tupel: C n (x) = C n (x1, x2, . . . xn).
Das Ergebnis ist unabhängig von x immer 0, also eine skalare Größe.
2. Die Nachfolgerfunktion N ist in P:
N: N → N mit N( x) = x +1ist
in P
0
3. Die Projektionsfunktion P ist in P:
∀n∈N und 1 ≤ i ≤ n gilt: P : N → N mit P ( x , x ,.. x ) = x ist in
n n n
i 0 0 i 1 2 n i P
Aus einer Funktion mit n Argumenten liefert also die Projektion Pi das i-te Argument als
Ergebnis. Beispielsweise gilt für n=3 und i=2:
3
P ( x , x , x ) = x
4. Die Substitutionsfunktion ist in P:
Sind h1, h , … h beliebige Funktionen in P und ist g: 2 n 0 0 in P, so gilt:
n
f: N 0 → N 0 mit f(x) = g(h1, h , … h ) ist in P
2 n n
n
0 0
N → N
Die Funktion f entsteht also durch Ersetzen (Substituieren) der Argumente xi der Funktion
g durch die Funktionen hi.
5. Die primitive Rekursion ist in P:
n n+ 2
1
Sind g: N 0 → N 0 und h: N 0 → N 0 in P, so ist auch jede Funktion f: N 0 → N 0 in P,
welche folgende Bedingung erfüllt:
0
+ n
n
f(0,y) = g(y) ∀y
∈ N
f(x+1,y) = h(x,y,f(x,y)) ∀x ∈ N und ∀y
∈ N
Man sagt, f entsteht aus g und h durch primitive Rekursion.
Die Beschränkung auf die natürlichen Zahlen kann ohne weiteres durch Ersetzen von N0
durch A * über einem beliebigen Alphabet A aufgehoben werden. Reelle Zahlen können offenbar
nicht verarbeitet werden, da die Menge der reellen Zahlen nicht abzählbar (überabzählbar)
ist. Reelle Zahlen müssen durch rationale Zahlen, also durch Brüche, angenähert
werden. Brüche können dabei als Paare von natürlichen Zahlen dargestellt werden.
Beispiel: Addition und Multiplikation
Die Additionsfunktion plus(x,y)=x+y soll als primitiv rekursive Funktion dargestellt werden.
Man erhält plus durch primitive Rekursion aus g und h:
plus(0,y) = g(y) = P2 2 (0,y) = y
plus(x+1,y) = h(x,y,plus(x,y)) = N[P3 3 (x,y,plus(x,y))]
Die Multiplikation mul(x,y)=xy lässt sich dann durch die Addition ausdrücken:

484 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
mul(0,y) = C 2 (0,y) = 0
mul(x+1,y) = plus1(x,y,mul(x,y))
mit plus1(x,y,z) = plus[P2 3 (plus1(x,y,z), P3 3 (plus1(x,y,z))]
Weitere Beispiele für primitiv rekursive Funktionen sind die Fakultät, die Bestimmung des
größten gemeinsamen Teilers zweier natürlicher Zahlen etc.
Für primitiv rekursive Funktionen gelten einige wichtige Sätze, die hier ohne Beweis aufgeführt
werden:
• Jede primitiv rekursive Funktion ist berechenbar.
• Jede primitiv rekursive Funktion ist durch eine Turing-Maschine darstellbar, die Umkehrung
gilt jedoch nicht. Es gibt also Turing-Maschinen, die keiner primitiv rekursiver Funktion entsprechen.
• Primitiv rekursive Funktionen sind durch sehr rudimentäre Programmiersprachen (Loop
Programs) mit folgenden Eigenschaften darstellbar [Mey67]:
- Es gibt die Konstante 0.
- Es gibt Zuweisungen der Art Y=X.
- Es gibt die Inkrementierung X=X++.
- Es gibt Verzweigungen (z.B. durch IF).
- Es gibt die Hintereinanderausführung beliebig vieler Anweisungen.
- Es gibt FOR-Schleifen, die eine beliebig lange Sequenz von Anweisungen umfassen, wobei
der Schleifenindex innerhalb der Schleife nicht verändert werden darf (Bounded
Loops).
Man könnte der Sprache sogar noch weitere Einschränkungen auferlegen; dies würde jedoch
zu einer unbequemen Handhabung führen. Jedes in einer derartigen Programmiersprache
geschriebene Programm entspricht einer primitiv rekursiven Funktion. Da nur FOR-
Schleifen mit einer vorab bekannten Anzahl von Schritten aber weder WHILE-Schleifen noch
Sprünge (GOTO) zugelassen sind, kann es in einem solchen Programm keine Endlosschleifen
geben, das Halteproblem spielt hier also keine Rolle.
Es ist offensichtlich, dass die primitiv rekursiven Funktionen eine sehr wichtige Klasse von
Funktionen beschreiben, aber eben nicht alle durch eine Turing-Maschine darstellbaren, also
nicht alle berechenbaren Funktionen. Es ist daher eine Erweiterung dieses Konzepts nötig.
10.1.5 µ-rekursive Funktionen und die Ackermann-Funktion
Im Jahre 1928 zeigte Ackermann, dass nicht jede berechenbare Funktion primitiv rekursiv
ist, indem er eine berechenbare, aber nicht primitiv rekursive Funktion angab: die Ackermann-Funktion.
Es ist dies die einfachste bekannte Funktion, die schneller wächst als jede
primitiv rekursive Funktion, also insbesondere auch schneller als die Fakultät und jede Exponentialfunktion.
Die Ackermann-Funktion A(x,y) ist wie folgt definiert:
A(0,y) = y+1
A(x+1,0) = A(x,1)
A(x+1,y+1) = A[x,A(x+1,y)]
Beispiel:
Man erkennt leicht, wie schnell A wächst, wenn man einige Werte berechnet:
A(1,1)=3 A(1,2)=4 A(2,2)=7 A(3,3)=61 A(4,4)>10 10102100

10 Algorithmen 485
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Explizite berechnet man A(1,2)=4 wie folgt:
A(1,2) = A(0,A(1,1)) = A(0,A(0,A(1,0))) = A(0,A(0,A(0,1))) = A(0,A(0,2)) = A(0,3) = 4
Die Behauptung, dass A schneller wächst als jede andere primitiv rekursive Funktion lässt
sich folgendermaßen ausdrücken:
∀f( n) ∈P: ∃m∈ N0 : A( n, n) > f( n) ∀ n > m
Möchte man die Ackermann-Funktion programmieren, so ist das durch Ausnutzung der Rekursivität
z.B. in Java oder C sehr einfach. Wie schon früher erwähnt, kann aber grundsätzlich
jede Rekursion auch durch eine Iteration ausgedrückt werden. Im Falle der Ackermann-
Funktion gelingt die iterative Programmierung aber mit der im vorigen Abschnitt kurz skizzierten
einfachen Programmiersprache als Loop-Programm nicht. Man benötigt hier unbedingt
eine Sprache die über WHILE-Schleifen oder wenigstens über Sprungbefehle (GOTO) verfügt.
Die Besonderheit dieser Konstrukte ist, dass im Gegensatz zu FOR-Schleifen der Laufindex
innerhalb der Schleife in Abhängigkeit von Bedingungen jederzeit beliebig geändert werden
kann. Dies hat notwendigerweise zur Folge, dass Endlosschleifen prinzipiell nicht ausgeschlossen
werden können.
Es ist allerdings nicht einfach zu beweisen, dass die Ackermann-Funktion tatsächlich nicht
primitiv rekursiv ist [Her65]. Außerdem findet diese Funktion kaum praktische Anwendungen.
Es gibt jedoch eine ganze Klasse von Funktionen für den täglichen Gebrauch, die nicht primitiv
rekursiv sein können: nämlich Compiler und Interpreter, und zwar auch solche für so
einfache Konstrukte wie Loop-Programme. Der Beweis dafür ist relativ einfach aus dem Beweis
des Halteproblems herleitbar [Abe85].
WHILE-Programme und der µ-Operator
Man kann ferner zeigen, dass man mit einer um WHILE-Schleifen und/oder Sprungbefehle
erweiterten Programmiersprache (WHILE-Programs) alle berechenbaren Funktionen programmieren
kann, so dass hier im Sinne der Church-Turing-These eine Übereinstimmung
mit dem Konzept der Turing-Maschinen besteht. Derartige auf das Wesentliche reduzierte
Sprachen sind ferner zu Registermaschinen äquivalent. Eine solche Äquivalenz lässt sich
aber auch durch eine Erweiterung des Begriffs der Rekursion erreichen. Man ergänzt dazu
die fünf Axiome der primitiv rekursiven Funktionen um ein sechstes Axiom zur Definition der
µ-rekursiven oder unbeschränkt rekursiven Funktionen, die dann alle tatsächlich berechenbaren
Funktionen umfassen:
y0 wenn f(x,y0)=c ist und f(x,y)≠c für alle y

486 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
10.1.6 Die bb-Funktion
Definition der bb-Funktion
Als Weiterführung der Ackermann-Funktion gab T. Radò 1961 die bb-Funktion bb(n) an, die
schneller wächst als jede µ-rekursive Funktion [Mor95]. Schreibt man µ für die Klasse der µrekursiven
Funktionen, so lautet diese Behauptung als Formel ausgedrückt:
μ
∀f ( n)
∈ : ∃m
∈ N 0 : bb(
n)
> f ( n)
∀n
> m
Daraus folgt bereits, dass bb(n) selbst keine µ-rekursive Funktion sein kann und daher auch
nicht berechenbar ist. Dennoch lässt sich bb(n) auf einfache Weise definieren:
bb(0) = 0
bb(n) = die maximale Anzahl von aufeinander folgenden Strichen (Einsen), die eine
Turing-Maschine mit n Anweisungen auf ein leeres Band schreibt.
Bekannte bb-Zahlen
bb steht abkürzend für busy beaver und ist von der anschaulichen Vorstellung abgeleitet,
dass jeder Strich für einen Holzstamm steht, den ein eifriger Biber zum Dammbau heranschleppt.
Die Tabelle listet die bislang bekannten bb-Zahlen auf.
Tabelle 10.1.2: Die bislang bekannten bb-Zahlen
n 0 1 2 3 4 5 >5
bb(n) 0 1 4 6 13 >1915 ?
Vorschrift zur Bestimmung von bb-Zahlen
Offensichtlich ist bb(n) mathematisch korrekt, eindeutig und auf ganz N o definiert, da für jedes
n∈N o auch bb(n) eine ganz bestimmte natürliche Zahl mit endlich vielen Stellen ist. Dazu
folgende Vorschrift zur Bestimmung von bb(n):
1. Man schreibe alle Turing-Maschinen mit T={0,1} der oben beschriebenen Art mit n Anweisungen
auf. Jede Anweisung besteht aus zwei Teilanweisungen, so dass sich insgesamt
2n Teilanweisungen ergeben. In jeder dieser Teilanweisungen gibt es nun zwei Möglichkeiten
für das zu schreibende Zeichen (0 oder 1), zwei Möglichkeiten für den nächsten
Schritt (Rechts oder Links) und n+1 Anweisungsnummern (einschließlich der Anweisungsnummer
0 für HALT) für den folgenden Schritt. Daraus folgt, dass es bei n gegebenen
Anweisungen genau [4(n+1)] 2n verschiedene Turing-Maschinen gibt. Für n=5 sind das
bereits ca. 6.3 * 10 13 Möglichkeiten.
2. Man suche alle haltenden Turing-Maschinen aus, die auf ein mit Nullen vorbesetztes
Band eine Anzahl von aufeinander folgenden Strichen schreibt. Solche gibt es für jedes n
auf jeden Fall, wie weiter unten gezeigt wird. Es wird dabei übrigens nicht vorausgesetzt,
dass ein allgemeines Verfahren existieren muss, welches in der Lage ist, von jeder beliebigen
Turing-Maschine zu entscheiden, ob diese mit jeder beliebigen Eingabe anhalten
wird oder nicht. Der Fall liegt hier einfacher: erstens ist die Eingabe nicht beliebig, es ist
vielmehr vorausgesetzt, dass das Eingabeband immer mit Nullen vorbesetzt ist; zweitens
ist bei der Berechnung eines bestimmten bb(n) die Anzahl der zu prüfenden Turing-
Maschinen immer endlich, man könnte also für jede dieser Maschinen ein speziell angepasstes
Verfahren entwickeln, um zu entscheiden, ob gerade diese anhält oder nicht.
3. Man prüfe für jede der nach 2. ausgewählten Turing-Maschinen, wie viele Striche sie auf
das Band schreibt, bevor sie anhält. Die größte Anzahl geschriebener Striche ist bb(n).

10 Algorithmen 487
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
Trotz dieser recht einfach klingenden Vorschrift zur Bestimmung von bb-Zahlen kann man
zeigen, dass bb(n) keine µ-rekursive Funktion sein kann und daher nicht berechenbar ist.
Dies bedeutet nicht, dass nicht einzelne bb-Zahlen bestimmt werden könnten. Vielmehr wird
dadurch ausgesagt, dass kein allgemeiner Algorithmus existiert, der bb(n) für jede beliebige
natürliche Zahl n berechnen kann.
Beweis der Nichtberechenbarkeit der bb-Funktion
Diese Aussage soll nun bewiesen werden. Dazu wird wieder die Technik „Beweis durch Widerspruch“
angewendet. Man geht also von der Annahme aus, es gäbe ein allgemeines Verfahren
(C-Programm, Turing-Maschine, µ-rekursive Funktion, ...), mit dessen Hilfe für jede
natürliche Zahl n der Wert bb(n) bestimmt werden könnte und zeigt, dass sich daraus ein
logischer Widerspruch ergibt. Aus dem Widerspruch folgt, dass die Annahme falsch war, so
dass ihre logische Negation richtig sein muss. Dazu geht man in folgenden Schritten vor:
1. Schritt:
Gegeben seien zwei Turing-Maschinen T1 mit n Anweisungen und T2 mit m Anweisungen.
T1T2 sei die Turing-Maschine, die man erhält, wenn T2 hinten an T1 angehängt wird. Man
muss dazu in T2 jede Anweisungsnummer i>0 durch n+i ersetzen und in T1 jede 0 (also
HALT) durch n+1 ersetzen. T1T2 führt also in allen Fällen, in denen T1 anhält, unmittelbar
danach T2 aus.
2. Schritt
Es gibt eine Turing-Maschine T4 mit 4 Anweisungen, die 12 Striche auf ein zunächst leeres
Band schreibt, und zwar 2 davon rechts vom Startfeld. Der Schreib/Lese-Kopf bleibt nach 96
Schritten 3 Felder links von den geschriebenen Strichen stehen:
T4: 1
0 1 L 2 0 1 R 1 0 0 R 0 0 1 R 4
2 3 4
1 0 L 3 1 1 L 1 1 1 L 4 1 0 R 2
Startposition
. . . 0 0 0 0 111111111111 0 0 0 0 . . .
Endposition
Abbildung 10.1.3:
Die angegebene Turing-Maschine schreibt
12 Striche auf ein anfangs leeres Band.
T4 lässt sich gemäß Schritt 1 beliebig oft hintereinander ausführen: T4T4 schreibt 24 aufeinander
folgende Striche, (T4) n schreibt 12n Striche. Durch Ersetzen der Zeile 0 0 L 0 in Anweisung
3 durch 0 0 R 0 modifiziert man T4 in T4'. Auch T4' schreibt 12 Striche, hält aber auf
dem ersten leeren Feld links neben den Strichen. Für jede natürliche Zahl n ist dann Dn =
(T4) n-1 T4' eine Turing-Maschine mit 4n Anweisungen, die 12n Striche auf ein zunächst leeres
Speicherband schreibt und dann gleich links vom zuletzt geschriebenen Strich hält.
3. Schritt
Offenbar ist bb(n) streng monoton wachsend, d.h. es gilt bb(n+1)>bb(n) für alle n: Hat man
nämlich eine Turing-Maschine T mit n Anweisungen, die bb(n) entspricht, so kann man daraus
eine Turing-Maschine T' mit n+1 Anweisungen machen, die einen Strich mehr schreibt
als T. Man ersetzt dazu lediglich alle 0-Anweisungsnummern (d.h. HALT) durch n+1 und fügt
folgende Anweisung an, die einen zusätzlichen Strich auf das Band schreibt.
n+1
0 1 L 0
1 1 L n+1

488 10 Algorithmen
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
4. Schritt
Nun wird angenommen, es existiere eine Turing-Maschine Tn mit k Anweisungen, die bb(n)
für jede natürliche Zahl n berechne. Man kann o.B.d.A. voraussetzen, dass sowohl die Eingabe
n als auch das Ergebnis bb(n) durch direkt aufeinander folgende Striche auf einem anfangs
leeren Band dargestellt werden. Tn soll nun auf dem ersten leeren Feld links von den
als Eingabe dienenden n Strichen starten, diese lesen, bb(n) berechnen, das Ergebnis in
Form von Strichen links anschließend an die n schon vorhandenen Striche auf das Band
schreiben und schließlich gleich links neben dem letzten Strich halten. Man betrachtet nun
die Turing-Maschine DnTn. Startet man DnTn auf einem leeren Band, so werden zunächst
durch Dn 12n aufeinander folgende Striche geschrieben, die von Tn als Eingabe gelesen
werden, so dass nun bb(12n) berechnet wird. Das Ergebnis wird in Form von Strichen an die
schon vorhandenen 12n Striche angehängt, so dass nun bb(12n)+12n Striche auf dem Band
stehen. In diesem Sinne ist DnTn selbst ein Kandidat für eine Biber-Turing-Maschine. Da Dn
aus 4n und Tn aus k Anweisungen besteht, hat DnTn 4n+k Anweisungen. Eine Turing-
Maschine, die bb(4n+k) berechnet, schreibt also mindestens so viele Striche wie DnTn, das ja
bb(12n)+12n Striche schreibt. Es gilt also:
bb(4n+k) > bb(12n)+12n
Da k eine feste Zahl ist, muss es eine Zahl m geben, so dass 12m > 4m+k gilt. Weil aber nur
k fest vorgegeben ist, nicht aber n, kann an Stelle von n auch m eingesetzt werden. Daraus
folgt jedoch bb(4m+k) > bb(12m) + 12m was wegen der strengen Monotonie der bb-Funktion
ein Widerspruch ist. Man macht sich dies leicht an einem Beispiel klar: Wurde k=7 gewählt,
so zeigt sich bereits für m=5 der Widerspruch in Form einer offensichtlich nicht erfüllten Ungleichung:
bb(27) > bb(60) + 60
Die Annahme, es gebe ein Tn, das bb(n) für jede natürliche Zahl n berechnet, muss also
falsch sein.
1985 wurde die unten dargestellte Turing-Maschine gefunden, die 1915 Striche auf ein anfangs
leeres Band schreibt. Es ist dies ein aussichtsreicher Kandidat für bb(5).
0 1 R 2 0 0 L 1 0 1 L 1 0 1 L 2 0 0 R 4
bb(5)?: 1 2 3 4 5
1 1 L 3 1 0 L 4 1 1 L 0 1 1 R 5 1 0 R 2