Über Komplexitätsklassen, die mit Hilfe von k-wertigen Funktionen definiert werden

Habilitationsschrift

der Fakultät für Mathematik und Informatik der Bayerischen Julius-Maximilians-Universität Würzburg

für das Fach Informatik vorgelegt von

Ulrich Hertrampf Würzburg, Juli 1994 Viele Menschen aus meiner privaten und wissenschaftlichen Umgebung haben durch ihre Unterstützung zum Abschluß dieser Arbeit beigetragen. Ich möchte mich bei ihnen allen sehr herzlich bedanken.

Besonders herausgreifen will ich im privaten Bereich meine Familie, Gabi, Lukas und Isabel, die mit dem Schicksal, einen Wissenschaftler zum Mann und Vater zu haben, sehr geduldig zu leben gelernt haben.

Im wissenschaftlichen Umfeld gilt mein Dank zu allererst Klaus Wagner, dessen allgegenwärtige Kompetenz und Sympathie ein jederzeit freundliches und fruchtbares Klima erzeugt. Enorme fachliche, logistische und moralische Unterstützung habe ich darüberhinaus von Heribert Vollmer und Gerhard Buntrock erhalten, wofür ich beiden zu größtem Dank verpflichtet bin.

Schließlich möchte ich nicht Christoph Meinel vergessen, durch dessen Engagement mir die Gelegenheit gegeben wurde, in einem Jahr an der Universität Trier große Fortschritte auf dem Weg zur Fertigstellung dieser Arbeit zu machen und gleichzeitig die erlebenswerte Stadt Trier kennenzulernen.

Inhalt

1. Einleitung 5

2. Grundlagen 9

2.1. Definitionen und Bezeichnungsweisen . . . . . . . . . . . . . . . . 9 2.1.1. Turing-Maschinen und Orakel . . . . . . . . . . . . . . . . 9 2.1.2. Mathematische Bezeichnungen . . . . . . . . . . . . . . . 10 2.1.3. Worte über einem Alphabet . . . . . . . . . . . . . . . . . 11

2.2. Komplexitätsklassen . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.1. Die grundlegenden Klassen P, NP, coNP, UP und PSPACE 11 2.2.2. Die Polynomialzeithierarchie und die Klasse MOD-PH . . 13 2.2.3. Die booleschen Hierarchien . . . . . . . . . . . . . . . . . 13 2.2.4. MOD-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 14 2.2.5. Klassen von endlichem Akzeptanztyp . . . . . . . . . . . . 15 2.2.6. Anzahlklassen . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.2.7. Die Klassen ∇P und co-∇P . . . . . . . . . . . . . . . . . 16 2.2.8. Die Klasse #P . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3. Operatoren zwischen Komplexitätsklassen . . . . . . . . . . . . . 17 2.3.1. Boolesche Operatoren, Join, P-trennbare Vereinigung . . 17 2.3.2. Projektions- und Anzahloperatoren . . . . . . . . . . . . . 18 2.3.3. Reduktionsoperatoren . . . . . . . . . . . . . . . . . . . . 20

3. Lokal definierbare Akzeptanztypen 21

3.1. Das Modell der LDA-Typen . . . . . . . . . . . . . . . . . . . . . 21 3.1.1. Definition des Modells . . . . . . . . . . . . . . . . . . . . 21 3.1.2. Der zweiwertige Fall . . . . . . . . . . . . . . . . . . . . . 25 3.1.3. Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.1.4. Normalform . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.1.5. Abschlußeigenschaften . . . . . . . . . . . . . . . . . . . . 33 3.1.6. Folgerungen . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.2. Der dreiwertige Fall . . . . . . . . . . . . . . . . . . . . . . . . . 41 3.2.1. Zwei einfache Beobachtungen . . . . . . . . . . . . . . . . 41 3.2.2. Reduktion der zu betrachtenden Fälle . . . . . . . . . . . 43 3.2.3. Ergebnis für den dreiwertigen Fall . . . . . . . . . . . . . 48

3.3. Der zweistufige Abschluß . . . . . . . . . . . . . . . . . . . . . . . 50 3.3.1. Das zweistufige Akzeptierungsmodell . . . . . . . . . . . . 50 3.3.2. Folgerungen für tt- und reguläre Reduktionen . . . . . . . 53 3.3.3. Turing-Abschluß . . . . . . . . . . . . . . . . . . . . . . . 56

3.4. Blattsprachen und LDA-Typen . . . . . . . . . . . . . . . . . . . 57 3.4.1. Das Blattsprachen-Modell . . . . . . . . . . . . . . . . . . 58 3.4.2. Vergleich mit dem LDA-Modell . . . . . . . . . . . . . . . 60

4. Akzeptierung durch endliche Halbgruppen 63

4.1. Das Halbgruppen-Modell . . . . . . . . . . . . . . . . . . . . . . 63 4.1.1. Algebraische Grundbegriffe . . . . . . . . . . . . . . . . . 63 4.1.2. Akzeptierung durch endliche Halbgruppen . . . . . . . . . 65 4.1.3. HG-Akzeptanztypen . . . . . . . . . . . . . . . . . . . . . 66 4.1.4. HG-Akzeptierung und balancierte Bäume . . . . . . . . . 67

4.2. Klassen von endlichen Halbgruppen . . . . . . . . . . . . . . . . 68 4.2.1. Kommutative Halbgruppen . . . . . . . . . . . . . . . . . 69 4.2.2. Kommutative aperiodische Halbgruppen . . . . . . . . . . 73 4.2.3. Kommutative idempotente Halbgruppen . . . . . . . . . . 74 4.2.4. Gruppen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 4.2.5. Auflösbare und nichtauflösbare Halbgruppen . . . . . . . 81

5. Orakelseparationen 85

5.1. Der Satz von Bovet, Crescenzi und Silvestri . . . . . . . . . . . . 85 5.1.1. Das BCS-Theorem . . . . . . . . . . . . . . . . . . . . . . 85 5.1.2. Ein Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . 86

5.2. Die Hypergraphenmethode . . . . . . . . . . . . . . . . . . . . . 87 5.2.1. Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . 87 5.2.2. Die Monotonie-Bedingung . . . . . . . . . . . . . . . . . . 89 5.2.3. plt-Reduktionen in Normalform . . . . . . . . . . . . . . . 90 5.2.4. Erste Anwendung der Hypergraphenmethode . . . . . . . 92

5.3. Separation von beschränkten Anzahlklassen . . . . . . . . . . . . 95 5.3.1. Anwendbarkeit der Hypergraphenmethode . . . . . . . . . 96 5.3.2. Das Ramsey-Theorem . . . . . . . . . . . . . . . . . . . . 98 5.3.3. Lösung des Separationsproblems . . . . . . . . . . . . . . 100 5.3.4. Die Klassen {a, b}P . . . . . . . . . . . . . . . . . . . . . 101

5.4. Weitere Anzahlklassen . . . . . . . . . . . . . . . . . . . . . . . . 104 5.4.1. Die Klasse C_{>0,≡0(2)}P . . . . . . . . . . . . . . . . . . . . 104 5.4.2. MOD-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 106 5.4.3. Die Klassen NP und C_{=}P . . . . . . . . . . . . . . . . . . 108

6. Abschlußeigenschaften der Klasse #P 111 6.1. Einfache Abschlußeigenschaften . . . . . . . . . . . . . . . . . . . 111 6.2. Verallgemeinerung des Hypergraphenansatzes . . . . . . . . . . . 112 6.3. Abschlußeigenschaften der Form f: IN → IN . . . . . . . . . . . . 113 6.4. Abschlußeigenschaften der Form f: IN^{r} → IN . . . . . . . . . . . . 116

7. Zusammenfassung der Ergebnisse 119 4 Inhalt

Einleitung

Eines der Hauptziele der strukturellen Komplexitätstheorie ist die Klassifizierung und Beschreibung von Problemklassen, um dadurch die Möglichkeit des Vergleichs der Probleme in diesen Klassen zu geben. Dabei ist es in vielen Fällen so, daß eine Inklusion der Form C_{1} ⊆ C_{2} leicht zu beweisen ist, aber für die Umkehrung (C_{2} ⊆ C_{1} ?) gibt es weder einen Beweis noch einen Gegenbeweis. Auf diese Weise wurde eine reiche Struktur von möglicherweise verschiedenen Komplexitätsklassen eingeführt. Ein Paradebeispiel hierfür ist der Bereich zwischen den Klassen P (deterministisch in Polynomialzeit lösbare Probleme) und PSPACE (mit polynomiell beschränktem Speicherplatz lösbare Probleme), obwohl bis heute unbekannt ist, ob tatsächlich PSPACE eine echte Obermenge von P darstellt, d.h. ob P ≠ PSPACE gilt.

Da es nun offensichtlich ernsthafte Probleme beim Beweis solcher Ungleichheiten zwischen Komplexitätsklassen gibt, hat man sich seit geraumer Zeit darauf verlegt, gute Gründe zu produzieren (sogenannte ”Evidenz“) dafür, daß zwei Komplexitätsklassen verschieden sind. Die klassische Methode bestand (und besteht) hier darin, trennende Orakel zu finden. Das bedeutet, man bereichert die beiden zu vergleichenden Berechnungsparadigmen noch um ein (beiden gleichermaßen zur Verfügung stehendes) Orakel und vergleicht dann die durch dieses erweiterte Modell jeweils charakterisierten Komplexitätsklassen. Damit war es oft möglich, für zwei Berechnungsparadigmen nachzuweisen, daß sie nicht gleichmächtig sind, und eine solche Trennung wurde als Hinweis gewertet, daß die ursprünglichen Klassen (ohne Orakel) auch verschieden sind. Allerdings wurde durch Shamirs Resultat [67] (in diesem Zusammenhang muß auch die Vorarbeit von Lund, Fortnow, Karloff und Nisan [52] erwähnt werden) die Aussagekraft von Orakelseparationen in Frage gestellt, denn in [67] wurde gezeigt, daß die über interaktive Beweissysteme definierte Klasse IP mit der Klasse PSPACE zusammenfällt. Es war aber schon vorher gezeigt worden, daß es ein Orakel gibt, das diese beiden Klassen trennt.

Wir glauben nicht, daß dieser Fall jeden Sinn von dem Mechanismus der Orakelseparation nimmt. Man muß bei der Beurteilung des Falles IP vs.

PSPACE berücksichtigen, daß diese beiden Klassen durch zwei verschiedene Modelle definiert sind. Die Mächtigkeit der Klasse IP beruht wesentlich auf der möglichen Interaktion. Diese Interaktion ist aber offenbar nicht in der Lage, das separierende Orakel angemessen auszunutzen. Wir führen also die Diskrepanz zwischen der absoluten Welt (ohne Orakel) und der konstruierten Welt (mit trennendem Orakel) auf die Unsymmetrie beim Zugriff auf das Orakel zurück. Unter fairen Bedingungen, d.h. wenn zwei Modelle in genau der gleichen Weise auf ein gegebenes Orakel zugreifen können, halten wir immer noch die Hypothese für vernünftig, daß es eine Orakelseparation nur dann geben kann, wenn die beteiligten Klassen auch absolut verschieden sind.

Damit sind die folgenden zwei Fragestellungen motiviert:

A) Wie kann man eine große Vielfalt von Komplexitätsklassen mit einem einheitlichen Modell charakterisieren, wobei die verschiedenen Klassen nur durch Variation eines Parameters des Modells entstehen? Wenn ein solches Modell gegeben ist: Welche Klassen können durch das Modell beschrieben werden – kann man einen vollständigen Überblick über diese Klassen geben?

B) Unter welchen Umständen kann man für zwei gegebene Klassen ein trennendes Orakel finden? Im Idealfall: Kann man einen Algorithmus angeben, der zu zwei gegebenen Klassen (aus einer möglichst großen Menge von Komplexitätsklassen) die Frage nach einem trennenden Orakel entscheidet?

Nachdem wir im Kapitel 2 einige grundlegende Begriffe eingeführt haben, die wir in dieser Arbeit benutzen wollen, beschäftigt uns in den Kapiteln 3 und 4 Frage A), im Kapitel 5 werden wir uns dann der Frage B) zuwenden. Dabei betrachten wir die folgenden Modelle:

Lokal definierbare Akzeptanztypen

Das Grundmodell, mit dem wir uns beschäftigen, ist das Modell der lokal definierbaren Akzeptanztypen. Hierbei wird das übliche Modell der nichtdeterministischen Turing-Maschine erweitert, indem wir annehmen, daß jeder Turing-Maschine eine Zuordnung von der Menge ihrer inneren Zustände in eine vorgegebene endliche Menge von Funktionen auf einem endlichen Wertebereich assoziiert wird. Diese Zuordnung muß so aussehen, daß in jedem von der Maschine erzeugten Berechnungsbaum jede Konfiguration mit einer Funktion versehen wird, deren Stelligkeit genau der Anzahl Nachfolgekonfigurationen entspricht. Damit muß den Blättern des Berechnungsbaumes jeweils eine konstante Funktion zugeordnet werden, und wir können den Wert dieser Funktion als Wert des Blattknotens ansehen. Nun kann man induktiv von den Blättern zur Wurzel hin jedem Knoten des Berechnungsbaumes einen Wert zuordnen, sobald seine sämtlichen Nachfolgeknoten schon je einen Wert haben, indem wir die zugeordnete Funktion auf den Werten der Nachfolgeknoten auswerten. Schließlich ziehen wir den Wert des Wurzelknotens heran, um die von der Maschine akzeptierte Menge zu definieren. Dabei vereinbaren wir einen Wert (meist der Wert 1), der genau bei den zu akzeptierenden Eingaben als Wurzelwert entstehen soll. Zu jeder Menge von Funktionen auf k Werten (k ≥ 2) wird damit eine Komplexitätsklasse definiert durch die Festlegung, daß die Sprache A zu dieser Klasse gehört, falls es eine Maschine gibt, mit der eine Zuordnung von ihren Zuständen in die gegebene Menge von Funktionen assoziiert ist und die mit dem Akzeptierungswert 1 genau alle Eingaben aus A akzeptiert.

Wir werden zeigen, daß eine sehr große Menge von Komplexitätsklassen im Bereich zwischen den Klassen P und PSPACE mit diesem Modell charakterisierbar sind. Allerdings sind wir von einem kompletten Überblick über alle so charakterisierbaren Klassen noch weit entfernt. Ebenso ist es für dieses Modell kaum möglich, systematisch alle möglichen Orakelseparationen zu entwickeln.

Blattsprachen

Das Modell der Blattsprachen ist dem Modell der lokal definierbaren Akzeptanztypen ähnlich, es unterscheidet sich aber in erster Linie von diesem dadurch, daß die Frage der Akzeptanz einer Eingabe nur von in den Blättern des Berechnungsbaumes angenommenen Werten abhängt. Hier wird also jede Maschine mit einer Zuordnung von den möglichen Endzuständen in einen endlichen Vorrat von Werten ausgestattet. Die Werte in den Blattknoten werden dann von links nach rechts konkateniert als ein sogenanntes Blattwort betrachtet. Aufgrund des Blattwortes soll dann entschieden werden, ob die Eingabe akzeptiert ist. Die Menge der Blattworte, die zu Akzeptierung führen, nennen wir die Blattsprache. Mit jeder Blattsprache wird also eine Klasse identifiziert durch die Festlegung, daß die Sprache A zu dieser Klasse gehört, wenn es eine Maschine gibt, deren Blattwort in der Blattsprache ist, falls die Eingabe zu A gehört, und deren Blattwort nicht in der Blattsprache ist, falls die Eingabe nicht zu A gehört.

Eine Modifikation dieses Modells ergibt sich, wenn man verlangt, daß die von den Maschinen erzeugten Berechnungsbäume grundsätzlich eine Form von Regelmäßigkeit haben, d.h. entweder volle binäre Bäume oder ”linke Abschnitte“ von vollen binären Bäumen sind.

Auch mit diesen Modellen ist jeweils eine große Menge von Komplexitätsklassen charakterisierbar. Aber auch hier ist es zur Zeit nicht realistisch, einen kompletten Überblick zu erhalten oder eine systematische Behandlung trennender Orakel zu bekommen.

Reguläre Blattsprachen und assoziative Akzeptanztypen

Beschränkt man das Modell der lokal definierbaren Akzeptanztypen auf den Fall, in dem außer den Konstanten und der Identitätsfunktion nur eine binäre assoziative Funktion zur Verfügung steht, um den Knoten des Berechnungsbaumes zugeordnet zu werden, dann erhält man ein Modell, das äquivalent auch durch reguläre Blattsprachen auf regelmäßigen Bäumen beschreibbar ist. Ein drittes ebenfalls diesen Modellen äquivalentes Schema ist der Fall der durch Halbgruppen definierten Blattsprachen auf beliebigen (oder auf regelmäßigen) Bäumen. Die durch dieses Modell beschreibbaren Klassen bilden immer noch eine recht große Menge von Klassen. Hier gibt es schon viele Ansätze, die beschreibbaren Komplexitätsklassen zu charakterisieren.

Im Fall der beschränkten Anzahlklassen, d.h. Klassen, die über eine durch eine endliche kommutative aperiodische Halbgruppe definierbare Blattsprache charakterisiert werden, können wir auch das Problem B) lösen und einen Algorithmus angeben, der die Frage, ob ein trennendes Orakel für zwei gegebene solche Klassen existiert, korrekt mit ”Ja“ oder ”Nein“ beantwortet (Kapitel 5).

Abschlußeigenschaften von #P

Die Ergebnisse aus Kapitel 5 ermöglichen eine weitere interessante Folge von Resultaten, die in Kapitel 6 entwickelt werden. Es läßt sich nämlich zeigen, daß unter den direkt auf den Funktionswerten arbeitenden möglichen Abschlußeigenschaften (wie etwa Abschluß gegen Addition, modifizierte Subtraktion, Multiplikation, Inkrement, Verdoppelung, ...) nur solche wirklich Abschlußeigenschaften von #P sind, die in einer ganz bestimmten Form darstellbar sind. Allerdings können wir das natürlich nicht absolut zeigen; stattdessen werden wir zeigen, daß es zu jeder anderen möglichen Abschlußeigenschaft ein Orakel gibt, relativ zu welchem sie nicht gilt. Auf der anderen Seite ist durch die angegebene spezielle Form klar, daß alle Abschlußeigenschaften, die in dieser Form darstellbar sind, tatsächlich gegeben sind. Da es im Einzelfall bei explizit gegebenen Funktionen möglich ist, zu testen, ob sie in dieser speziellen Form darstellbar sind, haben wir also ein Kriterium zur Entscheidung der Frage, ob eine gegebene Funktion eine Abschlußeigenschaft von #P ist oder nicht.

Grundlagen

In diesem Kapitel sollen zuerst einige grundlegende Definitionen und Bezeichnungsweisen eingeführt werden (Abschnitt 2.1), dann geben wir einen Überblick über die in dieser Arbeit behandelten Komplexitätsklassen (Abschnitt 2.2), und schließlich erläutern wir einige Operatoren, mit deren Hilfe aus gegebenen Komplexitätsklassen neue definiert werden (Abschnitt 2.3).

2.1. Definitionen und Bezeichnungsweisen

2.1.1. Turing-Maschinen und Orakel

Wir setzen einige Grundkenntnisse aus der Komplexitätstheorie voraus. Insbesondere sollte das Modell einer Turing-Maschine bekannt sein. Hier unterscheiden wir zwischen deterministischen Turing-Maschinen, bei denen in jeder Konfiguration, deren Zustand kein Endzustand ist, genau eine Nachfolgekonfiguration möglich ist, und den nichtdeterministischen Turing-Maschinen, bei denen es auch vorkommen darf, daß in einer gegebenen Konfiguration mehrere verschiedene Nachfolgekonfigurationen möglich sind. Insbesondere kann es auch vorkommen, daß bei einer nichtdeterministischen Maschine zu einer gegebenen Konfiguration keine Nachfolgekonfiguration existiert, obwohl der Zustand kein Endzustand ist. Ist die Rechenzeit einer Turing-Maschine durch ein Polynom beschränkt, so sprechen wir von einer Polynomialzeit-Turing-Maschine. Abkürzend werden wir auch Polynomialzeit-DTM (für eine deterministische Polynomialzeit-Turing-Maschine) bzw. Polynomialzeit-NTM (für eine nichtdeterministische Maschine) schreiben. Zu einer nichtdeterministischen Maschine kann man für jede Eingabe einen Berechnungsbaum in kanonischer Weise definieren. Dieser Baum hat eine Wurzel, die der Anfangskonfiguration der Maschine bei der gegebenen Eingabe entspricht. Sodann wird induktiv zu jeder Konfiguration, die im Laufe der Berechnung entstehen kann, ein Knoten definiert, dessen Nachfolgeknoten jeweils genau so viele sind, wie es in der gegebenen Konfiguration mögliche Nachfolgekonfigurationen gibt. Dabei wird jedem Nachfolgeknoten auch eineindeutig eine der möglichen Nachfolgekonfigurationen zugeordnet. Auf diese Weise erhält man einen Baum, der die gesamte nichtdeterministische Berechnung widerspiegelt. Die Tiefe des Baumes entspricht dabei der Rechenzeit, seine Größe kann exponentiell in der Rechenzeit wachsen.

Im allgemeinen gibt der Berechnungsbaum einer solchen nichtdeterministischen Berechnung den Nachfolgeknoten eines bestimmten Knoten keine Reihenfolge. Man kann aber immer voraussetzen, daß eine Reihenfolge durch die Zustandsübergangstafel der Turing-Maschine gegeben ist: die Konfigurationen werden in der Reihenfolge angenommen, in der sie durch die möglichen Zustandsübergänge (in der Reihenfolge der Übergangstafel) entstehen. Diese Anordnungsmöglichkeit werden wir im Kapitel 3 generell ausnutzen.

In vielen Fällen werden die möglichen Berechnungen einer nichtdeterministischen Maschine in zwei Klassen eingeteilt, die akzeptierenden und die ablehnenden Berechnungen. Oft kommt es einem dann darauf an, wieviele solche Berechnungen es gibt. Um mit diesen Anzahlen rechnen zu können, ohne sie jeweils in Worten zu beschreiben, definieren wir zu einer gegebenen Maschine M, deren Eingabealphabet Σ sei, die Funktionen acc_{M}: Σ^{∗} → IN und rej_{M}: Σ^{∗} → IN, wobei acc_{M}(x) definiert ist als die Anzahl akzeptierender Pfade von M bei Eingabe x, und entsprechend rej_{M}(x) als die Anzahl ablehnender Pfade von M bei Eingabe x. Dabei gehen wir jeweils davon aus, daß alle Berechnungen beschränkt sind, und zwar im allgemeinen durch ein Polynom in der Länge der Eingabe.

Alle Arten von Turing-Maschinen können auch mit einem Orakel A ausgestattet sein. Das bedeutet, während der Berechnung der Maschine kann eine Frage w auf ein Band geschrieben werden. Dann kann die Maschine in einen speziellen Orakel-Fragezustand übergehen, aus dem sie automatisch in einen ”Ja“-Zustand übergeht, wenn w ∈ A gilt, und in einen ”Nein“-Zustand, wenn w ∉ A gilt. Falls eine Komplexitätsklasse C durch einen bestimmten Typ von Turing-Maschinen definiert worden ist, nennen wir die Klasse, die aus C entsteht, wenn man allen Maschinen zusätzlich das Orakel A gibt, C^{A}. Für Klassen C_{1} und C_{2} ist die Klasse C_{1}C^{2} definiert als die Vereinigung aller C_{1}^{A} mit A ∈ C_{2}.

2.1.2. Mathematische Bezeichnungen

Das Symbol IN soll die Menge der natürlichen Zahlen bezeichnen. Dabei rechnen wir die 0 auch zu den natürlichen Zahlen.

Der Binomialkoeffizient \binom{n}{m} für zwei natürliche Zahlen m und n ist definiert als die Anzahl Möglichkeiten, m Individuen aus einer Menge von n Individuen auszuwählen. Das ergibt die Formel

\binom{n}{m} = ∏_{i=1}^{m} \frac{n − i + 1}{i}.

Für m = 0 entsteht hier ein leeres Produkt, der Wert soll dann nach Vereinbarung 1 sein.

Entsprechend wird der Multinomialkoeffizient \binom{(n_{1},...,n_{r})}{(m_{1},...,m_{r})} definiert als die Anzahl Möglichkeiten, gleichzeitig m_{1} von n_{1} Individuen und m_{2} von n_{2} Individuen und … und m_{r} von n_{r} Individuen auszuwählen. Damit erhalten wir für den Multinomialkoeffizient \binom{(n_{1},...,n_{r})}{(m_{1},...,m_{r})} das Produkt der Binomialkoeffizienten \binom{n_{i}}{m_{i}} über i = 1, …, r.

Ist A eine Teilmenge der Grundmenge X, so bezeichnen wir mit c_{A} die Abbildung c_{A}: X → {0, 1} mit c_{A}(x) = 1 für alle x ∈ A und c_{A}(x) = 0 für alle x ∉ A. Die Abbildung c_{A} heißt die charakteristische Funktion von A.

2.1.3. Worte über einem Alphabet

Ein Alphabet ist irgendeine endliche Menge Σ. Ein Wort über dem Alphabet Σ ist eine endliche Folge von Elementen von Σ. Insbesondere kann die Folge aus 0 Elementen bestehen. In diesem Fall nennen wir dieses Wort das leere Wort.

Falls w ein Wort über dem Alphabet Σ ist und aus n Elementen besteht, dann nennen wir die Zahl n auch die Länge des Wortes w. Wir schreiben dafür |w|, es gilt also in diesem Fall |w| = n. Für ein Element σ ∈ Σ schreiben wir |w|_{σ} für die Anzahl der Vorkommen des Symbols σ im Wort w. Offensichtlich gilt

∑_{σ∈Σ} |w|_{σ} = |w|.

2.2. Komplexitätsklassen

Unsere Notation in diesem und den nachfolgenden Abschnitten orientiert sich an der heute üblichen Notation in der Komplexitätstheorie, wie sie etwa in [65, 2, 3] verwendet wird.

2.2.1. Die grundlegenden Klassen P, NP, coNP, UP und PSPACE

Die Klasse P ist definiert als die Klasse aller Probleme, die von einer deterministischen (Turing-) Maschine in polynomieller Zeit gelöst werden können. Das heißt, daß P aus Mengen besteht, wobei eine Menge A genau dann zu P gehört, wenn es eine deterministische Maschine M und ein Polynom p gibt, so daß für alle Eingaben x die Laufzeit der Maschine M bei Eingabe x durch p(|x|) beschränkt ist und x zu A gehört genau dann, wenn die Maschine M bei Eingabe x schließlich in einem akzeptierenden Zustand stoppt.

Die Klasse NP ist definiert als die Klasse aller Probleme, die von einer nichtdeterministischen (Turing-) Maschine in polynomieller Zeit gelöst werden können. Dabei können wir davon ausgehen, daß alle Rechenwege einer Maschine M bei Eingabe x durch p(|x|) in ihrer Länge beschränkt sind (für ein festes Polynom p). Es gilt dann

x ∈ A ⟺ acc_{M}(x) > 0.

Eine schöne Einführung in die Klasse NP und ihre zentrale Rolle in der Informatik bietet nach wie vor das Buch von Garey und Johnson [32].

Die Klasse coNP ist definiert als die Klasse aller Probleme, deren Komplemente zur Klasse NP gehören.

Die Klasse UP ist die Teilklasse von NP, die sich ergibt, wenn man nur Maschinen zuläßt, die auf allen Eingaben höchstens einen akzeptierenden Pfad haben. Diese Klasse ist eine sogenannte Promise-Klasse, da wir von den benutzten Maschinen eine Eigenschaft verlangen, die wir nicht überprüfen können; man stellt sich also vor, die Maschine hat versprochen, daß sie eine zulässige Maschine ist, und wenn sie ”gelogen“ hat, sind wir für nichts verantwortlich. Eine Menge ist per Defininition nur dann in UP, wenn es eine Maschine gibt, die ihr Versprechen hält und die vorliegende Menge korrekt akzeptiert. UP wurde von Valiant eingeführt [77] (vergleiche auch [9]).

Schließlich definieren wir die Klasse PSPACE als die Klasse aller Probleme, die von einer deterministischen (Turing-) Maschine gelöst werden können, wobei bei Eingabe x nicht mehr als p(|x|) viele Speicherzellen genutzt werden (p ein festes Polynom). Es gelten die folgenden Charakterisierungen:

i) Man erhält auch PSPACE, wenn man nichtdeterministische (Turing-) Maschinen zuläßt, die auf keinem ihrer Rechenwege mehr als p(|x|) Speicherzellen nutzen (für gegebenes Polynom p).

ii) PSPACE kann auch charakterisiert werden über Maschinen, die in polynomieller Zeit alternierend arbeiten [28]. Das bedeutet, man geht aus von nichtdeterministischen Maschinen, in deren Berechnungsbäumen jedem Knoten eines der Attribute ”universell“ oder ”existentiell“ zugeordnet wird (in Abhängigkeit vom inneren Zustand der Maschine). Die Eingabe soll dann zur erkannten Menge gehören, wenn es einen akzeptierenden Teilbaum gibt, d.h. einen Teilbaum, der in jedem existentiellen Knoten genau einen seiner möglichen Nachfolger enthält, in jedem universellen Knoten alle möglichen Nachfolger und dessen sämtliche Berechnungswege mit einem akzeptierenden Zustand stoppen.

Weitere wichtige Fakten über diese Klassen entnehme man Standardwerken über Komplexitätstheorie [2, 3, 45, 64, 86, 16].

2.2.2. Die Polynomialzeithierarchie und die Klasse MOD-PH

Die Polynomialzeithierarchie wurde eingeführt von Stockmeyer [69]. Sie besteht aus den Klassen Σ_{k}^{p}, Π_{k}^{p}, Δ_{k}^{p} und Θ_{k}^{p}. (Θ_{k}^{p} gehörte bei Stockmeyer noch nicht zu dieser Hierarchie. Diese Klasse wurde erst von Wagner [84] eingeführt.) Die Klassen der Polynomialzeithierarchie sind für alle k ≥ 0 induktiv definiert:

i) Σ_{0}^{p} = Π_{0}^{p} = Δ_{0}^{p} = Θ_{0}^{p} = P.

ii) Für k ≥ 1:

Σ_{k}^{p} = NP^{Σ_{k−1}^{p}}, Π_{k}^{p} = coNP^{Σ_{k−1}^{p}}, Δ_{k}^{p} = P^{Σ_{k−1}^{p}}, Θ_{k}^{p} = P_{||}^{Σ_{k−1}^{p}}.

Dabei bedeutet das Subscript _{||}, daß alle Fragen an das Orakel parallel gestellt werden müssen, d.h. es darf nicht von vorherigen Antworten abhängen, welche Frage als nächstes gestellt wird.

Die Vereinigung aller Klassen der Polynomialzeithierarchie wird mit PH bezeichnet.

Ein wichtiges relativ junges Ergebnis von Toda zeigt, daß die probabilistische Klasse PP schon (bis auf Turing-Reduktion) ebenso mächtig ist wie die Polynomialzeithierarchie [73]. Als Nebenergebnis erhielt Toda, daß die Hierarchie kollabiert, wenn sie eine MOD-Klasse (Definition siehe unten) enthält.

Es gibt mehrere häufig verwendete Verallgemeinerungen bzw. Erweiterungen dieser Hierarchie, so etwa die Hierarchie, die man erhält, wenn man die Darstellung der Polynomialzeithierarchie mit existentiellen und universellen Operatoren (analog zur arithmetischen Hierarchie der Rekursionstheorie) durch MOD-Operatoren (siehe unten) ergänzt. Diese Klasse, d.h. die Vereinigung aller so definierten Klassen, nennt man MOD-PH. Eine andere Ergänzung ist die Vermischung solcher Operatoren mit einem Counting-Operator [82, 75]. Die entstehende Vereinigungs-Klasse wird mit CH bezeichnet.

2.2.3. Die booleschen Hierarchien

Es sei eine Klasse C und ein boolescher Ausdruck f(x_{1}, …, x_{r}) gegeben. Dann bezeichnet man mit f(C, …, C) die Klasse aller Mengen A, für die es Mengen B_{1}, …, B_{r} gibt, so daß B_{i} ∈ C (i = 1, …, r) und daß x zu A gehört genau dann, wenn der Ausdruck f(c_{B_{1}}(x), …, c_{B_{r}}(x)) den Wert true annimmt. Die Menge aller Klassen C′, die sich schreiben lassen als C′ = f(C, …, C) für einen geeigneten booleschen Ausdruck f(x_{1}, …, x_{r}) bezeichnet man als die boolesche Hierarchie über C. Die Vereinigung dieser Klassen nennt man auch BH(C).

Insbesondere werden wir die boolesche Hierarchie über NP betrachten. In [87] wurde diese Hierarchie eingeführt und gezeigt, daß sich alle Klassen dieser Hierarchie in der Form

(… ((NP ∧ coNP) ∨ NP) ∧ …)

oder

(… ((NP ∨ coNP) ∧ NP) ∨ …)

darstellen lassen. (Die Operatoren ∧ und ∨ werden in Definition 2.2 eingeführt.)

Induktiv definiert man diese Klassen wie folgt:

Induktionsanfang: NP(1) = NP  NP(2) = NP ∧ coNP
Induktionsschritt: NP(2k + 1) = NP(2k) ∨ NP

NP(2k + 2) = NP(2k + 1) ∧ coNP

In [59, 58, 27] wurde die Klasse NP ∧ coNP untersucht, die dort auch D^{P} heißt. In [23, 24, 25, 51, 83] wurde eine Vielzahl von Resultaten über die Klassen der booleschen Hierarchie erzielt. Eine Verbindung zwischen der Polynomialzeithierarchie und der booleschen Hierarchie wurde von Kadin [48] hergestellt: Wenn die boolesche Hierarchie über NP kollabiert, dann kollabiert auch die Polynomialzeithierarchie.

2.2.4. MOD-Klassen

Es sei k ≥ 2. Dann ist die Klasse MOD_{k}P definiert als die Klasse der Mengen L, für die es eine nichtdeterministische Turing-Maschine M gibt mit der Eigenschaft

x ∈ L ⟺ acc_{M}(x) ≢ 0 mod k.

Die Klasse coMOD_{k}P besteht aus allen Mengen, deren Komplemente in MOD_{k}P liegen.

Diese Klassen wurden in [26] als Verallgemeinerung der Klasse ⊕P [60] eingeführt. Die Klasse ⊕P ist gemäß der eben gegebenen Definition gleich der Klasse MOD_{2}P. In [38] (vergleiche auch [12, 13, 21, 49]) wurde bewiesen, daß für zwei Zahlen k und k′ mit derselben Menge von Primfaktoren (die aber eventuell in unterschiedlicher Potenz vorkommenen dürfen) die Gleichheit MOD_{k}P = MOD_{k′}P gilt. Als Nebenergebnis wurde dort gezeigt, daß die Klassen MOD_{k}P gegen Vereinigung abgeschlossen sind. Damit ist unmittelbar klar, daß die Klassen coMOD_{k}P gegen Durchschnitt abgeschlossen sind. Im Falle einer Primzahl (oder Primzahlpotenz) gilt sogar die Gleichheit von MOD_{k}P und coMOD_{k}P, und damit sind diese Klassen gegen alle booleschen Kombinationen abgeschlossen. Im Fall einer zusammengesetzten Zahl k ist dagegen nicht bekannt, ob MOD_{k}P gegen Komplement bzw. Durchschnitt abgeschlossen ist.

2.2.5. Klassen von endlichem Akzeptanztyp

Es sei A eine endliche Menge natürlicher Zahlen. Die Klasse A-P ist die Klasse der Mengen L, für die es eine nichtdeterministische Turing-Maschine M gibt mit der Eigenschaft

x ∈ L ⟺ acc_{M}(x) ∈ A.

Einige Klassen dieser Sorte wurden bereits von Gundermann und Wechsung [36, 37] bzw. Gundermann, Nasser und Wechsung [35] untersucht.

Spezielle Klassen dieser Art sind {0}-P oder allgemeiner {0, …, k}-P für eine Zahl k ≥ 0 (man sieht leicht, daß damit unabhängig vom Wert von k die Klasse coNP beschrieben wird), {1}-P oder allgemeiner {k}-P für k > 0 (diese Klasse ist unabhängig vom speziellen k immer gleich und wird in der Literatur meist mit 1-NP bezeichnet) und {2, 3}-P. Dieses letzte Beispielklasse enthält sowohl coNP als auch 1-NP, und wir werden im Kapitel 5 lernen, daß sie mit hoher Wahrscheinlichkeit eine echte Oberklasse dieser Klassen ist.

2.2.6. Anzahlklassen

Anzahlklassen stellen eine Verallgemeinerung der eben beschriebenen Klassen von endlichem Akzeptanztyp dar. Dabei geht es darum, daß wir uns bei einer gegebenen Berechnung einer nichtdeterministischen Maschine nur für die jeweiligen Anzahlen der Berechnungswege interessieren, die das gleiche Resultat liefern. Das Resultat ist der am Ende einer Berechnung gelieferte Wert, also bei den Klassen von endlichem Akzeptanztyp immer die Anzahl akzeptierender Pfade bzw. die Anzahl ablehnender Pfade. Allgemein lassen wir Resultate aus der Menge {0, …, r} für eine feste Zahl r zu und interessieren uns für die Anzahlen, wie oft die Ergebnisse 1, 2, …, r vorkommen; die Anzahl der Nullen soll sich nicht auf die Frage der Akzeptierung auswirken.

Anzahlklassen werden also durch eine Abbildung definiert, die jedem Vektor aus IN^{r} einen der Werte {0, 1} zuordnet. Diese Zuordnung entscheidet dann für eine gegebene Berechnung, angewendet auf die Anzahlen der Werte 1, 2, …, r, ob die Eingabe akzeptiert oder abgelehnt ist.

Ein Spezialfall der Anzahlklassen sind die beschränkten Anzahlklassen. Hier ist die obige Zuordnung von der Art, daß es einen Wert t > 0 gibt, so daß die Zuordnung auf IN^{r} angewendet auf (v_{1}, …, v_{r}) denselben Wert liefert wie angewendet auf (max(v_{1}, t),…,max(v_{r}, t)).

Klassen von endlichem Akzeptanztyp sind also beschränkte Anzahlklassen, bei denen r = 1 gilt.

Weiterhin werden wir die schließlich periodischen Anzahlklassen betrachten, bei denen es zwei Werte t und m gibt, so daß die Anzahlen, wenn sie größer als t sind, nur modulo m signifikant sind. Spezialfälle hiervon sind die MOD-Klassen, bei denen r = 1 und t = 0 gilt.

Ein weiterer Spezialfall, den wir mehrfach betrachten werden, ist die Klasse C_{>0,≡0(2)}P. Diese Klasse besteht aus allen Mengen L, für die es eine nichtdeterministische Turing-Maschine M gibt mit der Eigenschaft

x ∈ L ⟺ [acc_{M}(x) > 0 ∧ acc_{M}(x) ≡ 0 mod 2]

2.2.7. Die Klassen ∇P und co-∇P

In [85] wurde die Klasse ∇P definiert: Eine Menge L gehört zu ∇P, wenn es eine empfindliche alternierende Maschine M gibt, die x genau dann (im üblichen alternierenden Sinne) akzeptiert, wenn x zu L gehört. Dabei wird eine alternierende Maschine empfindlich genannt, wenn sie nur unter folgender Bedingung akzeptieren kann:

In jedem universellen Zustand gibt es höchstens einen nicht akzeptierenden Teilbaum, und in jedem existentiellen Zustand gibt es höchstens einen akzeptierenden Teilbaum.

Ist diese Bedingung nicht erfüllt, so wird die Berechnung als nicht akzeptierend angesehen, unabhängig davon, ob sie im normalen alternierenden Sinn akzeptierend ist.

Die Klasse co-∇P besteht aus allen Sprachen, deren Komplement in ∇P liegt.

2.2.8. Die Klasse #P

Neben den oben eingeführten Mengenklassen wollen wir in dieser Arbeit auch die folgende Funktionenklasse, die von besonderer Wichtigkeit ist, betrachten:

#P=_{def}{acc_{M}(x) | M ist eine Polynomialzeit-NTM}.

Diese Klasse wurde von Valiant [78] eingeführt und sehr ausführlich von vielen Autoren untersucht (z.B. [74, 57]). Sie bildet die Grundlage für die Definition des Begriffes ”Zählklassen“ (Counting classes), da diese normalerweise über die Anzahl akzeptierender Pfade einer nichtdeterministischen Turing-Maschine definiert werden. Viele der oben definierten Klassen sind in diesem Sinne Zählklassen.

Eine Verallgemeinerung der Klasse #P ist die Klasse GapP der Funktionen, die als Differenzen zweier Funktionen aus #P darstellbar sind [31].

2.3. Operatoren zwischen Komplexitätsklassen

2.3.1. Boolesche Operatoren, Join, P-trennbare Vereinigung

Eine Standardoperation auf Komplexitätsklassen ist der Übergang zu den Komplementen:

2.1 Definition. C sei eine Komplexitätsklasse. Dann ist die Klasse co-C definiert durch die Festlegung: L gehört zu co-C genau dann, wenn \overline{L} zu C gehört.

Die am häufigsten verwendeten zweistelligen Operatoren zwischen Komplexitätsklassen sind die Operatoren ∧ und ∨:

2.2 Definition. Es seien C_{1} und C_{2} zwei Komplexitätsklassen. Dann wird die Klasse C_{1} ∧ C_{2} definiert wie folgt:

A ∈ C_{1} ∧ C_{2} ⟺ ∃B_{1} ∈ C_{1}, B_{2} ∈ C_{2}: A = B_{1} ∩ B_{2}.

Entsprechend wird die Klasse C_{1} ∨ C_{2} definiert wie folgt:

A ∈ C_{1} ∨ C_{2} ⟺ ∃B_{1} ∈ C_{1}, B_{2} ∈ C_{2}: A = B_{1} ∪ B_{2}.

Ein andernorts ebenfalls häufig benutztes Konstruktionselement ist das folgende:

2.3 Definition. Es seien C_{1} und C_{2} zwei Komplexitätsklassen, die über einem Alphabet Σ definiert sind, wobei {0, 1} ⊆ Σ. Dann wird die Klasse C_{1} ⊕ C_{2} definiert wie folgt:

A ∈ C_{1} ⊕ C_{2} ⟺ ∃B_{1} ∈ C_{1}, B_{2} ∈ C_{2}: A = {0w | w ∈ B_{1}} ∪ {1w | w ∈ B_{2}}.

Die Menge A wird auch der Join von B_{1} und B_{2} genannt.

Unglücklicherweise wird hier dasselbe Symbol verwendet wie bei der Definition der Klasse ⊕P. Da aber beide Bezeichnungsweisen sehr weit verbreitet sind, wollen wir keine davon hier durch eine Neuschöpfung ersetzen. Man muß folglich jeweils aus dem Zusammenhang (insbesondere aus der Stelligkeit des Operators) ersehen, welche der beiden Möglichkeiten gemeint ist.

Ein weiterer Nachteil der Join-Operation ist die Inflexibilität, die darin liegt, daß das erste Symbol eine Sonderrolle spielen muß. In vielen Fällen ist aber der einzig interessante Aspekt der, daß man einfach (d.h. insbesondere deterministisch in polynomieller Zeit) feststellen kann, welche der Mengen B_{1} und B_{2} für die Mitgliedschaft eines Wortes in A ”verantwortlich“ ist. Wenn man sich auf diesen Aspekt beschränkt, erhält man folgende Konstruktion:

2.4 Definition. Es seien C_{1} und C_{2} zwei Komplexitätsklassen. Die P-trennbare Vereinigung der beiden Klassen, C_{1}∨^{·} C_{2}, wird definiert wie folgt:

\begin{aligned}A ∈ C_{1}∨^{·} C_{2} & ⟺ & ∃B_{1} ∈ C_{1}, B_{2} ∈ C_{2}, C ∈ P: \\ & & (A = B_{1} ∪ B_{2}) ∧ (B_{1} ⊆ C) ∧ (B_{2} ⊆ \overline{C}). \end{aligned}

Die letzte Definition kann man verallgemeinern auf k Klassen C_{1}, …, C_{k}, indem man statt der Menge C ∈ P eine deterministisch in Polynomialzeit berechenbare Funktion f mit Werten in {1, …, k} annimmt, so daß B_{i} ⊆ {w | f(w) = i} und A = B_{1} ∪ … ∪ B_{k}. Wir schreiben dann A ∈ C_{1}∨^{·} … ∨^{·} C_{k}.

2.3.2. Projektions- und Anzahloperatoren

Die folgenden einstelligen Operatoren auf der Menge der Komplexitätsklassen sind von zentraler Bedeutung in der strukturellen Komplexitätstheorie:

2.5 Definition. Es sei C eine Komplexitätsklasse. Die Klassen ∃C, ∀C, Δ′C, Θ′C, MOD_{m}C (m ≥ 2) und A-C (A eine nichtleere endliche Menge natürlicher Zahlen) sind wie folgt definiert:

(i) Eine Menge A gehört zu ∃C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ ∃y: [|y| ≤ p(|x|) ∧ ⟨x, y⟩ ∈ B] .

(ii) Eine Menge A gehört zu ∀C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ ∀y: [|y| ≤ p(|x|) ⟹ ⟨x, y⟩ ∈ B] .

(iii) Eine Menge A gehört zu Δ′C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ max{i: i ≤ 2^{p(|x|)} ∧ ⟨x, i⟩ ∈ B} ≡ 1 mod 2.

(iv) Eine Menge A gehört zu Θ′C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ max{i: i ≤ p(|x|) ∧ ⟨x, i⟩ ∈ B} ≡ 1 mod 2.

(v) Eine Menge A gehört zu MOD_{m}C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ #{y: |y| ≤ p(|x|) ∧ ⟨x, y⟩ ∈ B} ≢ 0 mod m.

(vi) Eine Menge A gehört zu A-C, falls es eine Menge B ∈ C und ein Polynom p gibt, so daß für alle Wörter x gilt:

x ∈ A ⟺ #{y: |y| ≤ p(|x|) ∧ ⟨x, y⟩ ∈ B} ∈ A.

Die folgenden Tatsachen sind leicht zu zeigen:

2.6 Fakt.

(i) Für die Operatoren Δ′ und Θ′ gilt:

Δ′Σ_{k}^{p} = Δ′Π_{k}^{p} = Δ_{k+1}^{p} und Θ′Σ_{k}^{p} = Θ′Π_{k}^{p} = Θ_{k+1}^{p}

für alle k ≥ 1.

(ii) Für den Operator ∃ gilt:

∃Σ_{k}^{p} = Σ_{k}^{p} und ∃Π_{k}^{p} = Σ_{k+1}^{p}

für alle k ≥ 1.

(iii) Für den Operator ∀ gilt:

∀Σ_{k}^{p} = Π_{k+1}^{p} und ∀Π_{k}^{p} = Π_{k}^{p}

für alle k ≥ 1.

Beweis. Zu (i): Der übliche Delta-Operator unterscheidet sich von dem Operator Δ′ dadurch, daß zusätzlich folgende Monotonie vorausgesetzt wird: ⟨x, i⟩ ∈ B ⇒ ⟨x, i − 1⟩ ∈ B für alle i > 0. Nun gilt offensichtlich für alle Klassen C die folgende Inklusionsreihe:

ΔC ⊆ Δ′C ⊆ Δ∃C

Da aber Σ_{k}^{p} = ∃Σ_{k}^{p} gilt, folgt

ΔΣ_{k}^{p} ⊆ Δ′Σ_{k}^{p} ⊆ Δ∃ Σ_{k}^{p} = ΔΣ_{k}^{p},

und folglich

Δ_{k+1}^{p} = ΔΣ_{k}^{p} = Δ′Σ_{k}^{p}.

Ganz analog schließt man für den Θ′-Operator. Zu (ii) und (iii): Das sind Standardbeweise (vgl. [2]). □

2.3.3. Reduktionsoperatoren

Der Begriff der Turing-Reduktion ist im einfachsten Fall wie folgt definiert:

2.7 Definition. Die Sprache A ist auf B Polynomialzeit-Turing-reduzierbar, in Zeichen: A ≤_{T}^{P} B, falls es eine Polynomialzeit-Turing-Maschine gibt, die mit Orakel B die Menge A entscheidet. Die Klasse P^{B} ist definiert als die Klasse aller Sprachen A, die auf B Polynomialzeit-Turing-reduzierbar sind.

Ist C eine Komplexitätsklasse, die über ein festes Modell definiert ist, so wird analog zur obigen Definition die Klasse C^{B} für eine Menge B definiert als die Klasse aller Sprachen, die von einer ”C-Maschine“ mit Orakel B akzeptiert werden können. Wir sagen dann auch, daß diese Mengen C-Turing-reduzierbar auf B sind. Eine Einschränkung der Turing-Reduktion kann man definieren, indem man die Anzahl der Fragen, die im Laufe einer Berechnung gestellt werden dürfen beschränkt. Man deutet das durch diese Maximalanzahl in eckigen Klammern an. So ist P^{NP}[1] die Klasse der Mengen, die von einer deterministischen Polynomialzeitmaschine mit einer Frage an ein NP-Orakel entscheidbar sind. Ähnlich werden viele weitere Reduktionsoperatoren definiert, wie etwa truthtable Reduktionen (das sind im wesentlichen Turing-Reduktionen, in denen alle Fragen parallel gestellt werden müssen, also ohne die Antworten auf die ersten k Fragen zu kennen, wenn man die (k + 1)-te Frage stellt), konjunktive Reduktionen (entspricht im wesentlichen einer Anwendung eines ∀-Operators, der auf einen polynomiellen Bereich beschränkt ist), disjunktive Reduktionen (ähnlich, aber mit einem eingeschränkten ∃-Operator), und andere. (Man vergleiche hierzu die Standardliteratur.)

Lokal definierbare Akzeptanztypen

In diesem Kapitel führen wir im Abschnitt 3.1 das Modell der lokal definierbaren Akzeptanztypen ein und beweisen einige Eigenschaften. Insbesondere wird in diesem Abschnitt von einer großen Vielfalt bekannter Komplexitätsklassen gezeigt, daß sie mit diesem Modell erfaßt werden können. Um solche Aussagen zu erleichtern, wird eine Normalform für LDA-Typen erarbeitet: Man benötigt nur eine einzige binäre Funktion. Der Inhalt dieses Abschnitts ist im wesentlichen der Arbeit [39] entnommen. Im Abschnitt 3.2 werden wir den Spezialfall eines LDA-Typs untersuchen, der nur aus einer einzigen binären dreiwertigen Funktion besteht. Wir werden für diesen Fall alle Klassen explizit angeben, die so charakterisierbar sind. Diese Ergebnisse sind in [40] erschienen. Abschnitt 3.3 führt die Untersuchung des allgemeinen Falls fort. Es wird hier bewiesen, daß man mehrstufige Berechnungen (wie etwa im klassischen Modell einer Σ_{k}^{p}- Maschine) mit einem LDA-Typ in Normalform charakterisieren kann. Hierbei handelt es sich um bisher unveröffentlichte Ergebnisse. Schließlich vergleichen wir im Abschnitt 3.4 das Konzept der lokal definierbaren Akzeptanztypen mit dem Blattsprachenmodell von Bovet, Crescenzi und Silvestri [17, 18].

3.1. Das Modell der LDA-Typen

3.1.1. Definition des Modells

Die übliche Art zu definieren, daß eine nichtdeterministische Maschine ihre Eingabe akzeptiert, ist zu verlangen, daß mindestens eine Berechnung der Maschine auf dieser Eingabe akzeptiert. In anderen Worten: wenn die Maschine bei Eingabe x den Berechnungsbaum T (x) erzeugt, so gilt die Eingabe als akzeptiert, wenn im Baum T (x) mindestens ein akzeptierender Pfad existiert. Diese Situation ist im folgenden Bild veranschaulicht:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; Eingabe x; accept ?; reject ?]

Man kann das auch so interpretieren: bei Eingabe x wird der Berechnungsbaum T (x) erzeugt. Jeder innere Knoten in T (x) bekommt als zusätzliches Attribut die logische ODER-Funktion zugeordnet. Die Blätter des Baumes erhalten als Attribut den Wert true, falls die hier endende Berechnung akzeptierend ist, und den Wert false, falls die Berechnung ablehnend ist. In einer zweiten Berechnungsphase, die wir die Baumauswertungsphase nennen wollen, wird nun der Baum von den Blättern zur Wurzel hin ausgewertet, wobei jeder Knoten dann ausgewertet werden kann, wenn alle seine Nachfolger bereits ausgewertet sind; nämlich so, daß sein Wert durch die ODER-Funktion, angewendet auf die Werte seiner Nachfolgeknoten, berechnet wird. Induktiv sieht man leicht, daß damit eine eindeutige Vorschrift gegeben ist, die letztlich der Wurzel des Berechnungsbaums den Wert true genau dann zuweist, wenn die Maschine im üblichen Sinn nichtdeterministisch die Eingabe akzeptiert. Betrachtet man nur Maschinen, deren Rechenzeit polynomiell beschränkt ist, so erhält man nur Bäume polynomieller Tiefe und kann damit genau alle Sprachen der Klasse NP mit einer solchen nichtdeterministischen Maschine erkennen.

Dieses Vorgehen kann leicht modifiziert werden: gibt man den inneren Knoten als Attribut die logische UND-Funktion, läßt aber alle anderen Details des beschriebenen Mechanismus unverändert, so wird der Wurzel des Baums T (x) genau dann der Wert true zugeordnet werden, wenn alle Berechnungen der Maschine akzeptierend sind. Die entsprechende Polynomialzeitklasse ist die Klasse coNP.

Eine weitere Modifikation ergibt sich, wenn man zuläßt, daß die inneren Knoten entweder ODER-Knoten oder UND-Knoten sind, je nachdem welchen inneren Zustand die betreffende Maschine in diesem Punkt der Berechnung annimmt. Das entspricht genau den existentiellen und universellen Zuständen der alternierenden Maschinen. Daher ist die entsprechende Polynomialzeitklasse identisch mit der Klasse ATIME[poly], die bekanntlich gleich PSPACE ist [28].

Hier sei noch eine weitere ähnlich definierte Komplexitätsklasse angeführt, die Klasse coMOD_{k}P für eine feste ganze Zahl k > 1. Diese Klasse ergibt sich, wenn man als Akzeptierungsbedingung einer nichtdeterministischen Maschine verlangt, daß die Anzahl akzeptierender Berechnungen durch k teilbar ist. Nun geben wir im Berechnungsbaum T (x) bei Eingabe x jedem Blatt, das eine akzeptierende Berechnung abschließt, den Wert 1 (für: eine akzeptierende Berechnung), und jedem Blatt, das eine ablehnende Berechnung abschließt, den Wert 0 (für: null akzeptierende Berechnungen). Jeder innere Knoten bekommt dann als Attribut die Sum_{k}-Funktion, die die Summe ihrer Eingabewerte modulo k berechnet. In der Baumauswertungsphase erhält nun die Wurzel den Wert 0 genau dann, wenn die Eingabe zu akzeptieren ist. Man prüft leicht nach, daß die Berechnungskraft dieses Modells nicht verändert wird, wenn man zuläßt, daß die Blattwerte nicht nur 0 oder 1, sondern jeweils eine beliebige Zahl aus dem Bereich 0, …, k − 1 sein dürfen.

Damit haben wir im letzten Beispiel einen Fall konstruiert, in dem die Funktion, die den inneren Knoten zugeordnet wird, auf Werten aus dem Bereich 0, …, k−1 definiert ist und als Ergebnis auch wieder einen solchen Wert liefert. Solche Funktionen nennen wir k-wertige Funktionen.

Die folgende Definition soll die diesen Mechanismen gemeinsame Technik formalisieren:

3.1 Definition. Ein k-wertiger lokal definierbarer Akzeptanztyp ist eine endliche Menge F von Funktionen von {0, …, k − 1}^{r} nach {0, …, k − 1}, wobei r (r ∈ IN, r > 0) von der jeweiligen Funktion abhängen darf. Jeder lokal definierbare Akzeptanztyp F definiert eine Komplexitätsklasse (F)P durch folgende Festlegung: die Sprache L gehört zu (F)P genau dann, wenn eine nichtdeterministische Polynomialzeit-Turingmaschine M existiert, so daß folgendes gilt:

• (Erzeugung des Berechnungsbaums) M ordnet bei der Berechnung auf Eingabe x jedem inneren Knoten des Berechnungsbaums eine Funktion aus F ∪{id} zu, deren Stelligkeit mit der Anzahl der Nachfolgeknoten übereinstimmt. M ordnet jedem Blatt des Berechnungsbaums einen Wert aus dem Bereich {0, …, k − 1} zu.

• (Baumauswertungsphase) Die Blätter des Baums haben nach der Erzeugungsphase bereits einen Wert im Bereich {0, …, k − 1}. Sukzessive wird zur Wurzel hin für jeden Knoten, dessen Nachfolger alle bereits ausgewertet sind, ein Wert berechnet: wenn dem Knoten die r-stellige Funktion f zugeordnet war und seine Nachfolger der Reihenfolge nach die Werte a_{1}, …, a_{r} angenommen haben, erhält dieser Knoten den Wert f(a_{1}, …, a_{r}).

• (Akzeptierung) x gehört zur Sprache L genau dann, wenn die Wurzel den Wert 1 erhält.

Im Gegensatz zu den vorher gegebenen Beispielen muß man in dieser Definition im allgemeinen eine durch die Maschine definierte Ordnung auf den Nachfolgeknoten des Berechnungsbaums voraussetzen, da sonst bei nichtkommutativen Funktionen der Wert nicht eindeutig bestimmt wäre. Wir nehmen daher an, daß die Nachfolgeknoten immer in der Reihenfolge vorliegen, die durch die Reihenfolge der verwendeten Regeln in der Zustandsübergangstafel der Maschine festgelegt ist. Die Bevorzugung des Wertes 1 in dieser Definition beschränkt die Allgemeinheit nicht, da man durch Umbenennung (und entsprechende Anpassung der Funktionen in F) jedem beliebigen Wert den ”Namen“ 1 geben kann. Ebenfalls keine Einschränkung ist es, daß wir genau einen akzeptierenden Wert vorschreiben. Nimmt man nämlich an, die Definition sei so, daß zu einem kwertigen lokal definierbaren Akzeptanztyp eine Teilmenge (nichtleer und echt) von {0, …, k − 1} als Menge von Akzeptierungswerten gegeben sei, so kann man einen k + 2-wertigen Akzeptanztyp angeben, der mit Akzeptierungswert 1 dieselbe Klasse definiert. Wir werden auf diesen Fakt im Beweis des Lemmas 3.10 noch einmal eingehen. Es sei hier noch angemerkt, daß eine Verallgemeinerung unseres Modells in [55] entwickelt wurde, um auch Promise-Klassen (speziell UP) erfassen zu können. In den vorhergehenden Beispielen hat man gesehen, daß man mit der Menge F = {f_{∨}} die Klasse NP definiert, wobei nur true durch den Wert 1, false durch den Wert 0 ersetzt werden muß, und f_{∨} als die Funktion von {0, 1}^{2} nach {0, 1} definiert wird mit f_{∨}(0, 0) = 0 und f_{∨}(a, b) = 1 in allen anderen Fällen. Entsprechend sieht man, daß F = {f_{∧}} die Klasse coNP definiert und F = {f_{∧}, f_{∨}} die Klasse PSPACE. Im nächsten Teilabschnitt wird die Frage beantwortet, welche Klassen überhaupt mit 2-wertigen lokal definierbaren Akzeptanztypen charakterisiert werden können. Vorher wollen wir aber noch vier generelle Eigenschaften so definierter Komplexitätsklassen bemerken:

3.2 Fakt. Es sei F ein k-wertiger lokal definierbarer Akzeptanztyp. Dann hat die Klasse (F)P folgende Eigenschaften:

(i) P ⊆ (F)P ⊆ PSPACE.

(ii) (F)P ist abgeschlossen gegen ≤_{m}^{p}-Reduktion.

(iii) (F)P ist abgeschlossen gegen die Operationen ⊕ (Join) und ∨^{·} (Ptrennbare Vereinigung).

(iv) (F)P hat ≤_{m}^{p}-vollständige Probleme.

Beweis. (i): Die erste Inklusion folgt daraus, daß wir in der Definition die id-Funktion als einstellige Funktion immer zulassen. Damit kann offenbar eine deterministische Berechnung durchgeführt werden. Die zweite Inklusion erhält man leicht, indem man einen geeigneten Baumtraversierungs-Algorithmus anwendet.

(ii)-(iv): Diese Eigenschaften haben alle Klassen, die durch Prädikate auf der Menge der Berechnungsbäume definiert werden können [20]. Offensichtlich ist die Tatsache, ein akzeptierender F -Baum zu sein, ein Prädikat auf der Menge der Berechnungsbäume in diesem Sinne. □

3.1.2. Der zweiwertige Fall

Um den zweiwertigen Fall, d.h. Mengen F von booleschen Funktionen, genau zu klären, bemerken wir zunächst, daß wir von F zum Abschluß ⟨F ⟩ übergehen können:

3.3 Definition. Es sei F eine Menge k-wertiger Funktionen (k ≥ 2). Der Abschluß ⟨F ⟩ von F wird wie folgt induktiv definiert:

• ⟨F ⟩ enthält die nullstelligen Konstanten 0, …, k−1, die Identitätsfunktion id und alle Funktionen aus F.

• Geht die Funktion f aus Funktionen in ⟨F ⟩ durch Vertauschung von Variablen, Identifizierung von Variablen, Einführung zusätzlicher Variablen oder Substitution hervor, so gehört auch f zu ⟨F ⟩.

• Keine andere Funktion gehört zu ⟨F ⟩.

3.4 Lemma. Es sei F ein k-wertiger lokal definierbarer Akzeptanztyp. Dann gilt für alle k-wertigen lokal definierbaren Akzeptanztypen F′ mit ⟨F ⟩ = ⟨F′⟩:

(F)P = (F′)P.

Beweis. Aus Symmetriegründen genügt es zu zeigen, daß (F)P ⊆ (F′)P. Jede Funktion in F′ gehört zu ⟨F ⟩, d.h. sie geht aus den Funktionen von F (einschließlich id und den Konstanten) in einer feststehenden minimalen Anzahl von Schritten der Art Vertauschung, Identifikation oder Hinzufügen von Variablen oder Substitution hervor. Ein einfacher Induktionsbeweis zeigt, daß also jede Funktion von F′, etwa f(x_{1}, …, x_{r}), durch einen festen Baum, dessen inneren Knoten Funktionen aus F zugeordnet sind und dessen Blättern entweder Konstanten oder Variablen aus der Menge {x_{1}, …, x_{n}} zugeordnet werden, repräsentiert werden kann. Es sei c die größte Tiefe eines solchen Baums und p das Polynom, das die Rechenzeit der (F′)P-Maschine für L beschränkt. Dann kann man L offenbar in Zeit c · p durch eine (F)P-Maschine akzeptieren, indem man jeden Schritt der (F′)P-Maschine durch einen entsprechenden Teilbaum mit Funktionen aus F ersetzt. □

Um alle möglicherweise verschiedenen Klassen der Form (F)P mit Mengen boolescher Funktionen F identifizieren zu können, brauchen wir also nur Mengen boolescher Funktionen anzusehen, die im obigen Sinn abgeschlossen und von einer endlichen Menge erzeugbar sind. Der in der Literatur verwendete Begriff abgeschlossener Mengen von booleschen Funktionen unterscheidet sich von unserem darin, daß dort nicht das Vorhandensein der Identitätsfunktion und der konstanten Funktionen gefordert wird. Wir müssen also alle abgeschlossenen Mengen boolescher Funktionen (im gewöhnlichen Sinn) mit endlicher Basis hernehmen, die die Funktion id und die nullstelligen konstanten Funktionen 0 und 1 enthalten. In [46] wird eine Liste aller abgeschlossenen Mengen boolescher Funktionen angegeben. Sie beruht auf den Arbeiten von Post [61, 62] und enthält 49 Mengen. Alle diese 49 Mengen haben eine endliche Basis, es scheiden allerdings 42 aus, da sie mindestens eine der Funktionen id, 0 oder 1 nicht enthalten. Damit verbleiben die Mengen mit den Nummern 8, 9, 13, 17, 18, 26 und 30, die durch die Basen {id, 0, 1}, {non, 0}, {vel, 0, 1}, {et, 0, 1}, {aut, 1}, {et, vel, 0, 1}, {nand} gegeben sind. Wir folgern (vergleiche auch [33]):

3.5 Satz. Es sei F ein boolescher lokal definierbarer Akzeptanztyp. Dann ist (F)P eine der Klassen P, NP, coNP, ⊕P oder PSPACE. Alle diese Klassen kommen als (F)P tatsächlich vor.

Beweis. Die Mengen {id, 0, 1} und {non, 0} ermöglichen nur deterministische Berechnungen, da keine Aufspaltung möglich ist. Es gilt daher für beide, daß die charakterisierte Komplexitätsklasse P ist.

Die Menge {vel, 0, 1} hat außer den ohnehin immer gegebenen Konstanten nur die Möglichkeit, eine ODER-Funktion zu berechnen. Das bedeutet, daß wir genau die Klasse NP erhalten. Ebenso erhalten wir durch {et, 0, 1} genau coNP und durch {aut, 1} genau ⊕P.

Mit den Funktionen aus {et, vel, 0, 1} bzw. {nand} kann man alternierende Maschinen simulieren. Beide repräsentieren also die Klasse PSPACE. □

3.1.3. Beispiele

Wir haben bereits gesehen, daß die Klassen P, NP, coNP, PSPACE, ⊕P und coMOD_{k}P durch lokal definierbare Akzeptanztypen charakterisierbar sind. Welche weiteren Klassen sind charakterisierbar?

Wir wollen jetzt einige Beispiele angeben, bei denen die Akzeptierungsfunktionen etwas komplizierter sind:

Beispiel 1.

f 0 1 2 3 0 2 2 2 2 1 2 2 2 2 2 2 2 2 2 3 2 2 2 3  g 0 0 1 0 2 0 3 1  h 0 1 2 3 0 0 1 0 0 1 1 1 0 0 2 0 0 0 0 3 0 0 0 0

Behauptung: ({f, g, h})P = Σ_{2}^{p}

Beweis. Wir zeigen zunächst die Inklusion von rechts nach links: es sei L ∈ Σ_{2}^{p}, dann existiert eine alternierende Maschine für L, die zunächst existentiell und in gewissen Teilbäumen nur noch universell rechnet. Die Maschine sei o.B.d.A. so normiert, daß jeder innere Knoten des Baumes genau zwei Nachfolger hat. Eine ({f, g, h})P-Maschine M′ kann M wie folgt simulieren:

Simulation: Jeder existentielle Schritt von M wird ein Schritt von M′, dem die Funktion h zugeordnet ist. Ein universeller Schritt von M, der auf dem betreffenden Berechnungspfad der erste solche ist, wird in M′ durch einen Zwischenschritt mit Funktion g (ohne weitere Änderung der Konfiguration) und einen Schritt mit Funktion f ersetzt. Jeder andere universelle Schritt von M wird durch einen Schritt mit Funktion f ersetzt. Akzeptierende Konfigurationen werden durch Endkonfigurationen mit Wert 3 ersetzt, ablehnende durch Endkonfigurationen mit Wert 2. Man prüft leicht nach, daß M′ genau dann akzeptiert, wenn auch M akzeptiert.

Für die Inklusion von links nach rechts kehrt man die Simulation um: h-Schritte werden durch existentielle Schritte ersetzt, g-Schritte durch deterministische und f-Schritte durch universelle. Endkonfigurationen mit Wert 3 (als Nachfolger zu f-Konfigurationen) werden zu akzeptierenden Konfigurationen, sonstige Endkonfigurationen als Nachfolger zu f-Konfigurationen werden zu ablehnenden Konfigurationen. Es ergibt sich allerdings das Problem, daß es sehr wohl vorkommen kann, daß nach einem f-Schritt später noch einmal ein h-Schritt durchgeführt wird. Diesen kann dann die Σ_{2}^{p}-Maschine nicht mehr als existentiellen Schritt simulieren. Durch einen genauen Blick auf die Verknüpfungstafeln stellt man allerdings fest, daß der Wert eines f-Knotens, dessen Nachfolgeknoten nicht beide f-Knoten oder Blätter mit Wert 2 oder 3 sind, unabhängig von sonstigen Eigenschaften des betreffenden Teilbaums immer vorbestimmt ist: es ist der Wert 2. In der Simulation kann also einfach der Wert false angenommen werden. □

Dieses Beispiel ist leicht zu verallgemeinern. Für i ∈ {1, …, k} seien die folgenden Funktionen definiert: Beispiel 2.

\begin{aligned}& f_{i} & ≤ 4i − 2 & 4i − 1 & ≥ 4i \\ ≤ & 4i − 2 & 4i − 2 & 4i − 2 & 4i − 2 \\ & 4i − 1 & 4i − 2 & 4i − 1 & 4i − 2 \\ ≥ & 4i & 4i − 2 & 4i − 2 & 4i − 2 \end{aligned}  \begin{aligned}& & g_{i} \\ ≤ & 4i − 2 & 4i − 4 \\ & 4i − 1 & 4i − 3 \\ ≥ & 4i & 4i − 4 \end{aligned}
\begin{aligned}& h_{i} & ≤ 4i − 5 & 4i − 4 & 4i − 3 & ≥ 4i − 2 \\ ≤ & 4i − 5 & 4i − 4 & 4i − 4 & 4i − 4 & 4i − 4 \\ & 4i − 4 & 4i − 4 & 4i − 4 & 4i − 3 & 4i − 4 \\ & 4i − 3 & 4i − 4 & 4i − 3 & 4i − 3 & 4i − 4 \\ ≥ & 4i − 2 & 4i − 4 & 4i − 4 & 4i − 4 & 4i − 4 \end{aligned}  \begin{aligned}& & l_{i} \\ ≤ & 4i & 4i − 2 \\ & 4i + 1 & 4i − 1 \\ ≥ & 4i + 2 & 4i − 2 \end{aligned}

Behauptung: Es gilt für k ≥ 2: ({f_{1}, g_{1}, h_{1}, l_{1}, …, f_{k−1}, g_{k−1}, h_{k−1}, l_{k−1}, f_{k}, g_{k}, h_{k}})P = Σ_{2k}^{p} und ({f_{1}, g_{1}, h_{1}, l_{1}, …, f_{k−1}, g_{k−1}, h_{k−1}, l_{k−1}, f_{k}})P = Σ_{2k−1}^{p}.

Beweis. Analog zum Beispiel Σ_{2}^{p}. □

Das vorangegangene Beispiel läßt sich ganz genauso auch für die Klassen Π_{2k}^{p} und Π_{2k−1}^{p} durchführen. Im Abschnitt 3.1.4 wird man sehen, daß die Klassen der Polynomialzeithierarchie sogar schon durch jeweils eine zweistellige Funktion definierbar sind. Als nächstes Beispiel geben wir einen LDA-Typ für die Klasse NP ∧ coNP an, die zur zweiten Stufe der booleschen Hierarchie über NP gehört: Beispiel 3.

f 0 1 2 3 4 5 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 3 2 2 2 3 2 2 4 2 2 2 2 2 2 5 2 2 2 2 2 2  g 0 1 2 3 4 5 0 4 4 4 4 4 4 1 4 4 4 4 4 4 2 4 4 4 4 4 4 3 4 4 4 4 4 4 4 4 4 4 4 4 5 5 4 4 4 4 5 5

h 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 0 0 0 0 0
2 0 0 0 0 0 0
3 0 0 0 0 0 1
4 0 0 0 0 0 0
5 0 0 0 0 0 0

Behauptung: ({f, g, h})P = NP ∧ coNP

Beweis. Man sieht sofort, daß man in ({f, g, h})P eine NP ∧ coNP-Berechnung simulieren kann (simuliere die NP-Berechnung mit den Werten 4 und 5 und der Funktion g, die coNP-Berechnung mit den Werten 2 und 3 und der Funktion f, und zu Beginn ein h-Schritt, um die Aufgaben auf die beiden Berechnungen aufzuteilen). Umgekehrt ist es so, daß ein f-Knoten, dessen Nachfolger nicht beide f-Knoten oder Blätter mit Wert 3 sind, ohnehin den Wert 2 annimmt, d.h. wenn erst einmal ein f-Knoten auf einem Berechnungsweg vorkommt, kann man den Rest der Berechnung auf jeden Fall als coNP-Berechnung durchführen. Desgleichen kann man die von einem g-Knoten ausgehende Berechnung auf jeden Fall als NP-Berechnung durchführen. Schließlich ist klar, daß jede Berechnung, die nicht mit einem h-Knoten, gefolgt von einem f-Knoten und einem g-Knoten (in dieser Reihenfolge), beginnt, ohnehin eine ablehnende Berechnung ist. Also können wir folgende beiden Algorithmen definieren:

A) Überprüfe, ob die ({f, g, h})-Berechnung mit einem h-Knoten beginnt und im ersten Nachfolger einen f-Knoten hat. Wenn nein, lehne ab, sonst simuliere die Berechnung des linken Teilbaums und akzeptiere dann, wenn der linke Teilbaum zum Wert 3 ausgewertet wird.

B) Überprüfe, ob die ({f, g, h})-Berechnung mit einem h-Knoten beginnt und im zweiten Nachfolger einen g-Knoten hat. Wenn nein, lehne ab, sonst simuliere die Berechnung des rechten Teilbaums und akzeptiere dann, wenn der rechte Teilbaum zum Wert 5 ausgewertet wird.

Algorithmus A) ist ein coNP-Algorithmus, Algorithmus B) ein NP-Algorithmus, und offenbar gilt: Wenn beide Algorithmen akzeptieren, dann akzeptiert die ursprüngliche ({f, g, h})-Berechnung auch, und umgekehrt. □

Als letztes Beispiel wollen wir die Klasse 1-NP beschreiben. Diese Klasse ist wie folgt definiert: Eine Sprache L gehört zu 1-NP, wenn es eine nichtdeterministische Polynomialzeitmaschine gibt, die bei Eingabe x ∈ L genau einen akzeptierenden Pfad, bei Eingabe x ∉ L dagegen entweder gar keinen oder mindestens zwei akzeptierende Pfade hat. Manche Autoren nennen diese Klasse auch US (für unique solution). Man überprüft leicht, daß mit der nachfolgenden Funktion f die Gleichung ({f})P = 1-NP erfüllt ist:

Beispiel 4.

\begin{matrix}f & 0 & 1 & 2 \\ 0 & 0 & 1 & 2 \\ 1 & 1 & 2 & 2 \\ 2 & 2 & 2 & 2 \end{matrix}

3.1.4. Normalform

Wir wollen nun beweisen, daß ein lokal definierbarer Akzeptanztyp immer äquivalent ist zu einem solchen, der nur aus einer einzigen binären Funktion besteht. Das erreichen wir schrittweise in den folgenden drei Lemmata:

3.6 Lemma. Es sei F ein k-wertiger lokal definierbarer Akzeptanztyp. Dann existiert ein k-wertiger lokal definierbarer Akzeptanztyp G mit der Eigenschaft, daß (F)P = (G)P und daß in G alle Funktionen die gleiche Stelligkeit haben.

Beweis. Wenn die Funktion g aus f durch Hinzunahme zusätzlicher Variablen hervorgeht, dann gilt offenbar f ∈ ⟨{g}⟩ und g ∈ ⟨{f}⟩. Da in F nur endlich viele Funktionen vorliegen, gibt es eine solche mit maximaler Stelligkeit. Diese Stelligkeit können wir durch Hinzunahme zusätzlicher Variablen bei allen anderen Funktionen in F auch erreichen, ohne die erzeugte Menge von Funktionen zu verändern. Nach Lemma 3.4 wird dadurch auch die erzeugte Polynomialzeitklasse nicht verändert.

□

3.7 Lemma. Es sei F ein k-wertiger lokal definierbarer Akzeptanztyp. Dann gibt es eine Zahl k′ und eine k′-wertige Funktion g mit (F)P = ({g})P.

Beweis. Nach dem vorhergehenden Lemma können wir annehmen, daß in F alle Funktionen die gleiche Stelligkeit haben. Die Funktionen in F seien f_{0}, …, f_{r−1}, wobei für alle i, f_{i}: {0, …, k−1}^{m} → {0, …, k−1}. Wir definieren eine Funktion g: {0, …, k + r − 1}^{m+1} → {0, …, k + r − 1} wie folgt:

g(a_{1}, …, a_{m}, j) = f_{j−k}(a_{1}, …, a_{m})

falls k ≤ j < k + r und a_{i} < k (i = 1, …, m). In allen anderen Fällen sei g(x_{1}, …, x_{m+1}) = 0.

Offensichtlich kann eine (F)P Berechnung durch eine ({g})P Berechnung simuliert werden, indem man anstelle eines Knotens mit der Funktion f_{i} und den Nachfolgekonfigurationen c_{1}, …, c_{m} einen Knoten mit der Funktion g und den Nachfolgekonfigurationen c_{1}, …, c_{m}, d^{(i+k)} erzeugt, wobei d^{(α)} die Endkonfiguration ist, die den Wert α ausgibt.

Wir müssen weiterhin zeigen, daß jede ({g})P Berechnung durch eine (F)P Berechnung simuliert werden kann. Es sei also eine ({g})P Berechnung gegeben. Eine (F)P Maschine kann zunächst deterministisch feststellen, ob der Beginn der Berechnung folgende Form hat:

[figure: .; .; .; .; .; .; .; g; g; g; g; g; (i+k)]

Hierbei muß 0 ≤ i < r gelten; die g-Nachfolgeknoten dürfen auch Blätter mit Werten kleiner als k sein.

Hat der Beginn der Berechnung nicht diese Form und besteht die Berechnung auch nicht aus einer direkten Akzeptierung durch ein Blatt mit Wert 1 direkt an der Wurzel, so kann die simulierende Maschine sofort mit dem Blattwert 0 abbrechen. Hat aber die Berechnung die angegebene Form, so wird ein f_{i}- Schritt ausgeführt, wobei die nachfolgenden Konfigurationen in den ersten m Nachfolgern rekursiv ebenso behandelt werden; der letzte Nachfolger entfällt, er stellt ohnehin eine Endkonfiguration dar. Auf diese Weise kann offenbar die (F)P Berechnung direkt simuliert werden.

Damit haben wir bewiesen, daß mit k′ =_{def} k+r die Aussage des Lemmas erfüllt werden kann. □

3.8 Lemma. Es sei f eine r-stellige k-wertige Funktion. Dann gibt es eine Zahl k′ und eine zweistellige k′-wertige Funktion g mit ({f})P = ({g})P.

Beweis. Wir setzen k′ =_{def} 2 + ∑_{i=1}^{r} k^{i} und codieren mit den Zahlen 0, …, k′ − 1

alle bis zu r-dimensionalen Vektoren über 0, …, k−1 und zwei Sonderwerte, denen wir die ”Namen“ ∗ und ♯ geben. Offenbar haben wir damit insgesamt genau k′ viele verschiedene Werte definiert. Die Funktion g geben wir auf diesen Werten an, eine Rückcodierung in die Zahlen 0, …, k′ − 1 kann in beliebiger Weise vorgenommen werden, wobei nur darauf zu achten ist, daß der 1-dimensionale Vektor mit dem Wert 1 auf die Zahl 1 abgebildet wird, um die Frage der Akzeptanz nicht zu ändern. Vektoren stellen wir in der Form [x_{1}, …, x_{d}] (Dimension d) dar, bei eindimensionalen Vektoren lassen wir die eckigen Klammern weg. Die Funktion g sei also wie folgt definiert:

g(a_{1}, a_{2}) = [a_{1}, a_{2}]
g([a_{1}, …, a_{s}], b) = [a_{1}, …, a_{s}, b] (s < r)
g([a_{1}, …, a_{r}], ∗) = f(a_{1}, …, a_{r})
g(x, ∗) = 0  falls x kein r-dimensionaler Vektor ist
g(y, z) = ♯  in allen anderen Fällen

Man sieht sofort, daß ({f})P ⊆ ({g})P. Dazu muß man nämlich nur bemerken, daß ein f-Schritt mit den Nachfolgekonfigurationen c_{1}, …, c_{r} durch die im folgenden Bild dargestellte Berechnung simuliert werden kann:

[figure: .; .; .; .; .; .; g; g; g; g; g; c_{1}; c_{2}; c_{3}; c_{r−1}; c_{r}; ∗]

Nun müssen wir noch zeigen, daß eine ({g})P Berechnung durch eine ({f})P Berechnung simuliert werden kann. Dazu stellen wir fest, daß durch die Funktion g ein Wert aus dem Bereich 0, …, k −1 dann und nur dann berechnet wird, wenn der rechte Eingabewert ein ∗ ist. Das aber wiederum kann nur durch ein Blatt im Baum erreicht werden, da niemals ∗ als Ergebnis einer Auswertung der Funktion g vorkommt. Ist nun der rechte Eingabewert tatsächlich ∗, so muß der linke Eingabewert ein r-Tupel sein, wenn ein Wert ungleich 0 berechnet werden soll. Ein r-Tupel kann aber nur entstehen, wenn ein (r − 1)-Tupel auf einen Wert aus dem Bereich 0, …, k − 1 trifft; ein (r − 1)-Tupel kann wiederum nur dann entstehen, wenn ein (r − 2)-Tupel auf einen Wert aus dem Bereich 0, …, k − 1 trifft, etc. Schließlich stellt man fest, daß ausgehend von einer bestimmten Konfiguration in konstanter Zeit festgestellt werden kann, ob sie einen Wert aus dem Bereich 0, …, k − 1 berechnet. Also können wir nachprüfen, ob eine Situation wie die im obigen Bild angegebene vorliegt, und wenn ja, dann wird diese Situation durch einen f-Schritt mit den Nachfolgekonfigurationen c_{1}, …, c_{r} simuliert. Liegt nicht die obige Situation vor, so wird (da wir vom vorherigen Schritt annehmen können, daß jedenfalls als rechter Nachfolgerknoten ein Blatt mit Wert ∗ erscheint) auf jeden Fall der Wert 0 berechnet, was die simulierende Maschine dann durch Übergang zu einer Endkonfiguration mit Wert 0 korrekt nachvollziehen kann. □

Aus diesen Lemmata ergibt sich sofort der folgende Satz über die Existenz einer Normalform für lokal definierbare Akzeptanztypen:

3.9 Satz. Es sei F ein k-wertiger lokal definierbarer Akzeptanztyp. Dann gibt es eine Zahl k′ und eine zweistellige k′-wertige Funktion g, so daß gilt:

(F)P = ({g})P

3.1.5. Abschlußeigenschaften

In diesem Teilabschnitt geben wir direkte Konstruktionen an, die es uns erlauben, aus der Existenz eines LDA-Typs, der die Klasse C charakterisiert, auch die Existenz eines LDA-Typs zu folgern, der eine gewisse aus C zu gewinnende Klasse charakterisiert. Als erstes Beispiel betrachten wir den Abschluß unter dem Operator co-:

3.10 Lemma. Es sei F ein lokal definierbarer Akzeptanztyp. Dann existiert ein LDA-Typ G mit co−(F)P = (G)P.

Beweis. Wir beweisen allgemeiner, daß für eine beliebige echte nichtleere Teilmenge α von {0, …, k−1} und einen k-wertigen LDA-Typ F die Klasse (F^{(α)})P, die wie (F)P definiert ist, jedoch mit der Akzeptierungsbedingung ”Wurzelwert ist in α“ anstelle von ”Wurzelwert ist 1“, durch einen anderen LDA-Typ G mit der normalen Akzeptierungsbedingung darstellbar ist, d.h. (F^{(α)})P = (G)P. Ohne Beschränkung der Allgemeinheit nehmen wir hierfür an, daß F nur aus einer Funktion, etwa f, besteht. Nun definieren wir die Funktionen g: {0, …, k + 1}^{2} → {0, …, k + 1} und h: {0, …, k + 1} → {0, …, k + 1} wie folgt:

g(x, y) = f(x − 2, y − 2) + 2 falls x, y > 1
g(x, y) = f(x − 2, 0) + 2  falls x > 1, y ≤ 1
g(x, y) = f(0, y − 2) + 2  falls y > 1, x ≤ 1
g(x, y) = f(0, 0) + 2  falls x, y ≤ 1
h(x) = 1  falls x > 1 und (x − 2) ∈ α
h(x) = 0  falls x ≤ 1 oder (x − 2) ∉ α

Die Funktionen sind so definiert, daß man mit Funktion g praktisch eine Berechnung von Funktion f, verschoben um zwei, nachvollziehen kann. Da man mit h von einem von g erzeugten Wert genau dann zum Wert 1 kommt, wenn dieser Wert (um zwei verschoben) in der Akzeptierungsmenge ist, können wir also ({f}^{(α)})P ⊆ ({g, h})P schließen. Für die Umkehrung stellen wir zunächst fest, daß eine akzeptierende Berechnung einer ({g, h})P Maschine nur so aussehen kann, daß von einem h-Knoten ausgehend ein g-Knoten erzeugt wird. Als Nachfolgeknoten dieses und weiterer g-Knoten sind wieder nur g-Knoten bzw. Blätter relevant, da ein h-Knoten als Nachfolger eines g-Knotens immer denselben Effekt hat wie ein Blatt mit Wert 2. (Die Werte 0, 1 und 2 werden ja von g immer gleich behandelt!) Folglich können wir die Berechnung simulieren, indem wir den h-Schritt zu Beginn zur Kenntnis nehmen (andernfalls ablehnen), und dann die anschließende g-Berechnung Schritt für Schritt durch eine f-Berechnung nachvollziehen.

Aus der damit bewiesenen Aussage, daß ({f}^{(α)})P = ({g, h})P gilt, schließen wir die Aussage des Lemmas, indem wir für α die Menge {0, 2, 3, …, k − 1} nehmen, so daß (F^{(α)})P = co−(F)P gilt. □

Wir wollen nun zeigen, daß das System der durch lokal definierbare Akzeptanztypen gegen die Operatoren aus Definition 2.5 abgeschlossen ist.

3.11 Lemma. Es sei F ein lokal definierbarer Akzeptanztyp, und sei C = (F)P. Dann existieren LDA-Typen für jede der Klassen ∃C, ∀C, Δ′C, Θ′C, MOD_{m}C (m ≥ 2) und A-C (A eine nichtleere endliche Menge natürlicher Zahlen).

Beweis. Es sei F = {f} mit einer binären k-wertigen Funktion f gemäß Satz 3.9. Wir geben jeweils die Akzeptanztypen für die zu konstruierenden Klassen an und skizzieren den Beweis der jeweiligen Aussage, indem wir die Form der sinnvollen Berechnungsbäume angeben. Sinnvoll ist dabei wie folgt zu verstehen: Im ersten Fall ist z.B. eine Folge von zwei direkt hintereinander ausgeführten Schritte mit Funktion g nicht sinnvoll, da der Knotenwert des ersten Knotens in jedem Fall 0 wäre, denn der Knotenwert des zweiten ist entweder 0 oder 1 und wird als Eingabe für den ersten Knoten verwendet. Es gilt aber g(0) = g(1) = 0, eine Simulation kann also diese beiden Knoten zusammen mit dem gesamten daran hängenden Teilbaum wie ein Blatt mit Wert 0 behandeln.

(i) Wir arbeiten mit den Werten 0, …, k + 1 und definieren drei Funktionen:

f′(x, y) = f(x − 2, y − 2) + 2 falls x, y ≥ 2
f′(x, y) = 2  sonst

g(3) = 1

g(x) = 0  sonst
h(x, y) = max(x, y)  falls x, y ≤ 1
h(x, y) = 0  sonst

Man kann leicht überprüfen, daß sinnvolle Berechnungsbäume von der folgenden Form sind:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; f′-Berechnung; f′-Berechnung; g; g; h-Berechnung]

Es muß also eine Anfangsphase der Berechnung geben, in der nur h-Knoten verwendet werden, dann muß einmal ein g-Knoten auftauchen, anschließend dürfen nur noch f′-Knoten verwendet werden. (Alle Knoten können in diesem wie in alle anderen nachfolgend behandelten Fällen natürlich auch durch Blätter mit ”passendem“ Wert sinnvoll ersetzt werden.)

Mit solchen Bäumen kann man eine ∃C-Berechnung simulieren und umgekehrt.

(ii) Es genügt die Beobachtung, daß ∀C = co−∃C.

(iii) Wir arbeiten mit den Werten 0, …, k + 2 und definieren vier Funktionen:

f′(x, y) = f(x − 3, y − 3) + 3 falls x, y ≥ 3
f′(x, y) = 3  sonst

g(4) = 0

g(x) = 2  sonst

h(4) = 1

h(x) = 2  sonst
l(x, y) = y  falls x ≤ 2, y ≤ 1
l(x, y) = x  falls x ≤ 2, y = 2
l(x, y) = 2  sonst

Wieder überprüft man leicht, daß sinnvolle Berechnungsbäume von der folgenden Form sind:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; f′-Berechnung; f′-Berechnung; l-Berechnung; g/h; g/h]

Hier wird also eine l-Phase auf jedem Pfad entweder von einem g-Knoten oder einem h-Knoten abgeschlossen, woran sich eine f′-Phase anschließt.

Mit solchen Bäumen kann man eine Δ′C-Berechnung simulieren und umgekehrt.

(iv) Wir arbeiten mit den Werten 0, …, k + 5 und definieren vier Funktionen:

f′(x, y) = f(x − 6, y − 6) + 6 falls x, y ≥ 6
f′(x, y) = 6  sonst

g(7) = 3

g(x) = 5  sonst

h(7) = 4

h(x) = 5  sonst
l(x, y) = y − 3  falls x ≤ 2, 3 ≤ y ≤ 4
l(x, y) = x  falls x ≤ 2, y = 5
l(x, y) = 2  sonst

Hier überprüft man leicht, daß sinnvolle Berechnungsbäume von der folgenden Form sind:

[figure: f′-Berechnung; g/h; .; .; .; .; .; f′-Berechnung; g/h; l; l]

Es muß also eigentlich wie im vorigen Fall eine l-Phase geben, die durch einen g- oder h-Knoten abgeschlossen wird, gefolgt von einer f′- Berechnung. Allerdings darf hier die l-Phase nur in eine Richtung wachsen, also nur einen polynomiell großen Teil des Baums erzeugen. Das liegt daran, daß der in einem l-Knoten produzierte Wert aus der Menge {0, 1, 2} kommt und deshalb nicht sinnvoll ist als rechter Eingabewert zu einem weiteren l-Knoten, denn der hätte dann in jedem Fall den Wert 2, könnte also wie ein Blatt vom Wert 2 behandelt werden.

Mit solchen Bäumen kann man eine Θ′C-Berechnung simulieren und umgekehrt.

(v) Wir arbeiten mit den Werten 0, …, k + m + 1 und definieren vier Funk-

tionen:

f′(x, y) = f(x − m − 2, y − m − 2) + m + 2 falls x, y ≥ m + 2
f′(x, y) = m + 2  sonst
g(m + 3) = 3
g(x) = 2  sonst
h(x, y) = (x + y − 4 mod m) + 2  falls 2 ≤ x, y ≤ m + 1
h(x, y) = 2  sonst
l(x) = 1  falls 3 ≤ x ≤ m + 1
l(x) = 0  sonst

Hier sind sinnvolle Berechnungsbäume von der folgenden Form:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; f′-Berechnung; f′-Berechnung; g; h-Berechnung; g; l]

Sinnvolle Berechnungen starten also mit einem l-Schritt, gefolgt von einer h-Berechnung, die wiederum durch einen g-Schritt abgeschlossen wird, gefolgt von einer f′-Berechnung.

Mit solchen Bäumen kann man eine MOD_{m}C-Berechnung simulieren und umgekehrt.

(vi) Es sei m die größte Zahl in A. Wir arbeiten mit den Werten 0, …, k+m+3

und definieren vier Funktionen:

f′(x, y) = f(x − m − 4, y − m − 4) + m + 4 falls x, y ≥ m + 4
f′(x, y) = m + 4  sonst
g(m + 5) = 3
g(x) = 2  sonst
h(x, y) = max(x + y − 4, m + 1) + 2  falls 2 ≤ x, y ≤ m + 3
h(x, y) = 2  sonst
l(x) = 1  falls 2 ≤ x ≤ m + 3
und x − 2 ∈ A
l(x) = 0  sonst

Hier haben sinnvolle Berechnungsbäume dieselbe Form wie im vorherigen Fall, allerdings sind die genauen Ausgabewerte verschieden. Speziell wird mit h-Knoten eine Summe berechnet, die durch den Maximalwert m + 1 beschränkt ist, während vorher eine Summe modulo m berechnet wurde.

Mit solchen Bäumen kann man eine A-C-Berechnung simulieren und umgekehrt.

Der Nachweis, daß diese Simulationen alle möglich sind, verläuft jeweils ganz analog zum Beweis von Lemma 3.10. □

3.12 Lemma. Es seien F_{1} und F_{2} lokal definierbare Akzeptanztypen und C_{i} = (F_{i})P (i = 1, 2). Dann existieren LDA-Typen für die Klassen C_{1}∧C_{2} und C_{1}∨C_{2}.

Beweis. Es genügt, die Behauptung für C_{1} ∧ C_{2} zu beweisen; die Existenz eines LDA-Typs für C_{1} ∨C_{2} folgt dann aus den de-Morganschen Gesetzen und Lemma 3.10.

Es seien F_{i} = {f_{i}} mit k_{i}-wertigen zweistelligen Funktionen f_{i} (i = 1, 2). Wir benutzen die Werte 0, …, k_{1} + k_{2} + 1 und definieren die folgenden drei Funktionen:

g_{1}(x, y) = f_{1}(x − 2, y − 2) + 2  falls 2 ≤ x, y ≤ k_{1} + 1
g_{1}(x, y) = 2  sonst
g_{2}(x, y) = f_{2}(x − k_{1} − 2, y − k_{1} − 2) + k_{1} + 2 falls k_{1} + 2 ≤ x, y
≤ k_{1} + k_{2} + 1
g_{2}(x, y) = k_{1} + 2  sonst
h(3, k_{1} + 3) = 1
h(x, y) = 0  sonst

Es gilt C_{1}∧C_{2} ⊆ ({g_{1}, g_{2}, h})P: eine Berechnung in ({f_{1}})P kann auf den Werten 2, …, k_{1} + 1 unter Verwendung der Funktion g_{1} direkt simuliert werden (wenn auch um den Wert 2 verschoben), wobei der Akzeptierungswert 3 ist. Entsprechend kann eine Berechnung in ({f_{2}})P auf den Werten k_{1} + 2, …, k_{1} + k_{2} + 1 unter Verwendung der Funktion g_{2} (um den Wert k_{1}+2 verschoben) mit Akzeptierungswert k_{1} + 3 simuliert werden. Durch einen h-Schritt zu Beginn, an den die simulierten Berechnungen in ({f_{1}})P und ({f_{2}})P anschließen, erreicht man offenbar, daß der Wurzelwert 1 genau dann entsteht, wenn beide simulierten Berechnungen akzeptierend sind.

Nun wollen wir zeigen, daß man auch jede ({g_{1}, g_{2}, h})P Berechnung durch Berechnungen in ({f_{1}})P und ({f_{2}})P so simulieren kann, daß die ({g_{1}, g_{2}, h})P Berechnung genau dann akzeptiert, wenn beide simulierenden Berechnungen akzeptieren. Wir stellen dazu fest, daß eine akzeptierende Berechnung nur dadurch entstehen kann, daß entweder sofort der Blattwert 1 angenommen wird oder daß zu Beginn der Berechnung ein h-Schritt steht, dessen linker Nachfolgeknoten zu 3 ausgewertet wird und dessen rechter Nachfolgeknoten zu k_{1} + 3 ausgewertet wird. Der Wert 3 kann aber nur durch ein Blatt oder durch einen g_{1}-Schritt erzeugt werden. Entsprechend kann der Wert k_{1} + 3 nur durch ein Blatt oder durch einen g_{2}-Schritt erzeugt werden. In jedem Fall sieht man, daß man den linken Teilbaum sinngemäß durch eine f_{1}-Berechnung simulieren kann, die den Wert 1 erzeugt genau dann, wenn der linke Teilbaum zum Wert 3 ausgewertet wird. (Man beachte, daß die Funktion g_{1} nur auf Werten sinnvoll arbeitet, die wieder durch die Funktion g_{1} erzeugt worden oder Blätter aus dem Bereich 2, …, k_{1} + 1 sind.) Entsprechend können wir den rechten Teilbaum sinngemäß durch eine f_{2}-Berechnung simulieren, die den Wert 1 genau dann erzeugt, wenn der rechte Teilbaum zum Wert k_{1} + 3 ausgewertet wird. Damit wird die Eingabe dann und nur dann akzeptiert, wenn beide Simulationen akzeptieren. □

3.1.6. Folgerungen

Die Lemmata aus Abschnitt 3.1.5 erlauben uns, wichtige Abschlußeigenschaften zu folgern:

3.13 Satz. Das System der durch LDA-Typen charakterisierbaren Komplexitätsklassen ist abgeschlossen gegen die einstelligen Operationen co-, ∃, ∀, Δ′, Θ′, MOD_{m} (m ≥ 2), A- (A eine nichtleere endliche Menge natürlicher Zahlen) und die zweistelligen Operationen ∧ und ∨.

Daraus ergeben sich insbesondere folgende Aussagen:

3.14 Korollar.

• Alle Stufen der Polynomialzeithierarchie, bestehend aus den Klassen Σ_{k}^{p}, Π_{k}^{p}, Δ_{k}^{p}, Θ_{k}^{p} (k ≥ 0) können durch LDA-Typen charakterisiert werden.

• Alle Stufen der booleschen Hierarchien über Σ_{k}^{p}, speziell alle Stufen der booleschen Hierarchie über NP, sind durch LDA-Typen charakterisierbar.

3.2. Der dreiwertige Fall

Wir wollen uns nun dem dreiwertigen Fall widmen, allerdings können wir nicht (wie im zweiwertigen Fall) über alle möglichen abgeschlossenen Mengen dreiwertiger Funktionen sprechen. Wir beschränken uns auf den Fall, daß ein dreiwertiger Akzeptanztyp nur aus einer zweistelligen Funktion besteht. Eine gewisse Rechtfertigung für diese Beschränkung liefert uns Satz 3.9, obwohl er natürlich nicht besagt, daß alle dreiwertigen Akzeptanztypen mit einer dreiwertigen zweistelligen Funktion realisierbar sind.

3.2.1. Zwei einfache Beobachtungen

3.15 Lemma. Es sei g: {0, 1, 2}^{2} → {0, 1, 2} eine Funktion, bei der nicht alle der Werte 0, 1 und 2 wirklich vorkommen. Dann ist ({g})P eine der Klassen P, NP, coNP, ⊕P, PSPACE.

Beweis. Kommt der Wert 1 nicht vor, so haben wir trivialerweise ({g})P = P. Wir werden uns nun den Fall, daß der Wert 2 nicht vorkommt, genauer ansehen; der andere Fall ist ganz analog zu behandeln.

Sei also in Wahrheit g: {0, 1, 2}^{2} → {0, 1}. Wir definieren die folgenden drei Funktionen auf den Werten 0, 1:

f_{1}(x, y) = g(x, y) für alle x, y ∈ {0, 1}
f_{2}(x) = g(x, 2)  für alle x ∈ {0, 1}
f_{3}(y) = g(2, y)  für alle y ∈ {0, 1}

Mit dieser Definition gilt ({g})P = ({f_{1}, f_{2}, f_{3}})P. Da aber die Funktionen f_{i} (i = 1, 2, 3) boolesche Funktionen sind, folgt aus Satz 3.5 die Behauptung. □

3.16 Lemma. Es sei g: {0, 1, 2}^{2} → {0, 1, 2} eine Funktion mit der Eigenschaft, daß für alle einstelligen Funktionen h: {0, 1, 2} → {0, 1, 2} gilt h ∈ ⟨{g}⟩. Dann ist ({g})P = PSPACE.

Beweis. Wir nennen eine zweistellige dreiwertige Funktion arm, wenn sie in Wirklichkeit nur von einem ihrer Argumente abhängt. Wir werden durch einige kleine Fallunterscheidungen zeigen, daß eine zweistellige Funktion, die alle drei möglichen Werte annimmt und nicht arm ist, die folgende Eigenschaft hat:

(∗) Es existieren Werte a_{1}, a_{2}, b_{1}, b_{2} mit g(a_{1}, b_{1}) ≠ g(a_{i}, b_{j}), falls ⟨i, j⟩ ≠ ⟨1, 1⟩ (i, j ∈ {1, 2}).

Da eine arme Funktion niemals alle einstelligen Funktionen erzeugt, genügt es, für jede zweistellige dreiwertige Funktion g aus der Bedingung (∗) zu folgern, daß ({g})P = PSPACE gilt. Das folgt aber daraus, daß für die Funktion f(x, y) =_{def} h_{0}(g(h_{1}(x), h_{2}(y)) gilt: f(0, 1) = f(1, 0) = f(0, 0) = 0, f(1, 1) = 1. Dabei sind die einstelligen Funktionen h_{0}, h_{1}, h_{2} wie folgt definiert:

h_{1}(0) = h_{1}(2) = a_{2}  h_{1}(1) = a_{1}
h_{2}(0) = h_{2}(2) = b_{2}  h_{2}(1) = b_{1}
h_{0}(g(a_{1}, b_{1})) = 1  h_{0}(x) = 0 in den anderen Fällen

Mit f haben wir also eine Simulation der UND-Verknüpfung zur Verfügung, und da alle einstelligen Funktionen vorhanden sind, können wir auch eine Negation bewerkstelligen. Also können wir beliebige alternierende Maschinen simulieren.

Es bleibt also noch, die Eigenschaft (∗) zu beweisen. Nehmen wir an, daß die Verknüpfungstafel folgendes Aussehen hat:

\begin{matrix}g & 0 & 1 & 2 \\ 0 & c_{1} & c_{2} & c_{3} \\ 1 & c_{4} & c_{5} & c_{6} \\ 2 & c_{7} & c_{8} & c_{9} \end{matrix}

Falls unter den c_{i} (i = 1, …, 9) einer der Werte 0, 1, 2 genau einmal vorkommt, so ist die Bedingung (∗) schon erfüllt, da wir nur a_{1} und b_{1} so wählen müssen, daß der Eintrag in Zeile a_{1} und Spalte b_{1} gerade dieser nur einmal vorkommende Wert ist. Dasselbe gilt, wenn einer der Werte genau zweimal vorkommt, da man dann nur darauf achten muß, daß man mit den Werten a_{2} und b_{2} nicht gerade das zweite Vorkommen desselben Wertes trifft.

Nun sei also jeder Wert genau dreimal in der Tafel. Es gibt sicher einen Wert, der in zwei verschiedenen Zeilen und zwei verschiedenen Spalten vorkommt (sonst wäre die Funktion g arm). Wir unterscheiden hier noch einmal zwei Fälle: Wenn der Wert in allen Zeilen und allen Spalten vorkommt (z.B. als c_{1}, c_{6} und c_{8}), dann kann man offenbar immer die Bedingung (∗) erfüllen (da die Fälle sich alle nur von dem Beispielfall durch Umordnen der Zeilen und Spalten unterscheiden). Ansonsten kommt der Wert also in einer Zeile (oder Spalte) gar nicht, aber in den beiden anderen jeweils mindestens einmal vor. Damit haben wir also eine Zeile (Spalte), in der der Wert genau einmal vorkommt, und eine weitere, in der er gar nicht vorkommt. Damit kann man offenbar auch wieder die gewünschte Bedingung erfüllen. □

3.2.2. Reduktion der zu betrachtenden Fälle

Für den nachfolgend beschriebenen Algorithmus, der die Anzahl der zu untersuchenden dreiwertigen Funktionen von der ursprünglichen Zahl (19 683) auf eine handhabbare Zahl reduziert, wollen wir außer den oben bewiesenen Lemmata auch die Tatsache benutzen, daß zwei Funktionen dieselbe Klasse charakterisieren, wenn jede der Funktionen im Abschluß ⟨{.}⟩ der anderen enthalten ist. Um das zu untersuchen, benötigen wir einen Algorithmus, der uns zu einer gegebenen Funktion alle zweistelligen Funktionen in diesem Abschluß berechnet.

Um das Lemma 3.16 anwenden zu können, müssen wir auch alle einstelligen Funktionen im Abschluß einer gegebenen zweistelligen Funktion berechnen können.

3.17 Lemma. Die folgende Prozedur berechnet korrekt die Menge aller einstelligen Funktionen im Abschluß der Funktion f:

    procedure unaryclosure(f);

liste := {c_{0}^{1},c_{1}^{1},c_{2}^{1},id};

                (* alle einstelligen Konstanten und Identität *)
        repeat
            vorher := |liste|;
            for f_{1} in liste do
                for f_{2} in liste do
                    liste := liste ∪ {g};

(* dabei ist g(x) = f(f_{1}(x), f_{2}(x)) *)

            nachher := |liste|
        until vorher = nachher;
        output := liste
    end of procedure

Beweis. Sicherlich ist jede Funktion, die durch den Algorithmus in die Liste aufgenommen wird, im Abschluß von f und einstellig. Wir müssen zeigen, daß alle einstelligen Funktionen in diesem Abschluß auch erfaßt werden. Wir führen eine Induktion über die Anzahl aller Erzeugungsschritte einer Funktion im Abschluß von f durch und beweisen, daß für Funktionen g aus diesem Abschluß gilt, daß die Funktion g′, die aus g durch Identifikation sämtlicher Variablen hervorgeht, von dem Algorithmus in die Liste eingefügt wird.

Induktionsanfang: Eine Funktion, die in 0 Erzeugungsschritten im Abschluß von {f} liegt, kann nur eine der Funktionen f, id, c_{0}^{1}, c_{1}^{1}, c_{2}^{1} sein. Da id und die Konstanten von Anfang an in der Liste sind, müssen wir nur zeigen, daß auch f′ in die Liste eingeführt wird. Das geschieht aber bereits im ersten Durchlauf der repeat-Schleife, da f′(x) = f(id(x), id(x)).

Induktionsschritt: Die Funktion g_{1} gehe aus einer Funktion g_{0} aus dem Abschluß von f durch eine der Operationen Vertauschen, Identifizieren oder Hinzufügen von Variablen hervor. Dann ist g′_{1} = g′_{0} und wegen g′_{0} ∈ Liste (nach Induktionsvoraussetzung) ist auch g′_{1} in der Liste. Nun gehe also g_{1} aus bereits erzeugten Funktionen durch Einsetzen in eine ebenfalls schon früher erzeugte Funktion hervor. O.B.d.A. können wir davon ausgehen, daß die Funktion, in die eingesetzt wird, eine der Funktionen id, c_{0}^{1}, c_{1}^{1}, c_{2}^{1}, f ist. Wenn es id ist, ist die neue Funktion gleich der eingesetzten, also erhalten wir gar keine neue Funktion. Ist es eine Konstante, so ist die neue Funktion eine eventuell mehrstellige Konstante. Die dadurch definierte einstellige Funktion ist wieder die entsprechende einstellige Konstante, die bereits von Anfang an in der Liste vorhanden ist. Es bleibt also nur die Funktion f. Die Erzeugung sieht dann wie folgt aus:

[figure: .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; .; f; y_{1}; x_{r}; x_{1}; Funktion g; erzeugte; Bereits; Funktion h; erzeugte; Bereits; y_{s}]

Die Funktion f′(x) ist dann gleich der Funktion f(g′(x), h′(x)) und da g′ und h′ bereits erzeugte einstellige Funktionen sind, wird diese Funktion spätestens im nächsten Durchlauf der repeat-Schleife nach der Erzeugung der Funktionen g′ und h′ erzeugt. □

Nun wenden wir uns der Erzeugung aller zweistelligen Funktionen im Abschluß einer gegebenen zweistelligen Funktion zu.

3.18 Lemma. Die folgende Prozedur berechnet korrekt die Menge aller zweistelligen Funktionen im Abschluß der Funktion f:

    procedure binaryclosure(f);
        liste := {f};
        unary := unaryclosure(f);
        for g in unary do
            liste := liste ∪ {g_{1}};
                (* dabei ist g_{1}(x, y) = g(x) *)
        for g in unary do
            liste := liste ∪ {g_{2}};
                (* dabei ist g_{2}(x, y) = g(y) *)
        repeat
            vorher := |liste|;
            for f_{1} in liste do
                for f_{2} in liste do
                    liste := liste ∪ {g};

(* dabei ist g(x, y) = f(f_{1}(x, y), f_{2}(x, y)) *)

            for f_{1} in liste do
                liste := liste ∪ {g};

(* dabei ist g(x, y) = f_{1}(y, x) *)

            nachher := |liste|
        until vorher = nachher;
        output := liste
    end of procedure

Beweis. Die Argumentation ist ähnlich wie im Beweis zu Lemma 3.17 und soll hier nicht noch einmal wiederholt werden. □

Mit den angegebenen Algorithmen haben wir leicht die Möglichkeit, die Lemmata 3.15 und 3.16 anzuwenden und die Tatsache auszunutzen, daß f und g zur selben Komplexitätsklasse führen, wenn sie im gegenseitigen Abschluß liegen. Wir wollen außerdem noch ausnutzen, daß wir im allgemeinen 6 verschiedene Funktionen haben, die durch reines Umbenennen der Werte 0, 1 und 2 ineinander überführt werden können. Eine Prozedur, die zu einer gegebenen Funktion in einer beliebigen festen Anordnung der Funktionen die minimale mit ihr auf diese Weise verwandte Funktion ermittelt, ist trivial zu programmieren. Wir setzen ihre Existenz unter dem Namen minimalrepresentative(f) voraus.

Damit können wir nun den folgenden Satz zur drastischen Reduktion der zu betrachtenden Fälle nutzen:

3.19 Satz. Das folgende Programm erstellt eine Liste von zweistelligen dreiwertigen Funktionen mit der Eigenschaft, daß für jede zweistellige dreiwertige Funktion f eine Funktion g in der Liste existiert, die entweder direkt oder nach Umbenennung der Werte dieselbe Klasse wie f erzeugt:

    program casereduction;
    liste := ∅;

for all f: {0, 1, 2}^{2} → {0, 1, 2} do

        if all values appear under f then
            if minimalrepresentative(f) = f then
                if |unaryclosure(f)| < 27 then
                    liste := liste ∪ {f};
    for f_{1} in liste do
        for f_{2} in liste do
            if f_{1} < f_{2} then
                if f_{1} in binaryclosure(f_{2}) and
                    f_{2} in binaryclosure(f_{1}) then
                        liste := liste \ {f_{2}};

3.2. Der dreiwertige Fall 47

 i := 0;
 for f in liste do
     i := i+1; output (``i:  '',f);
 end of program

Beweis. Prinzipiell werden alle zweiwertigen Funktionen in die Liste eingetragen, nur solche nicht, die aufgrund von Lemma 3.15 oder Lemma 3.16 oder des Vorhandenseins eines kleineren Repräsentanten derselben Funktion verzichtbar sind. Im zweiten Teil des Algorithmus werden nur solche Funktionen gestrichen, die nachweislich gleichwertig mit einer anderen Funktion sind, da sie den gleichen Abschluß haben. Damit ist der Satz bewiesen. □

Im folgenden Bild wird der Output dieses Algorithmus abgebildet:

000  000  000  000  000  000  000  000  000  000
1:000  2:000  3:000  4:000  5:000  6:000  7:001  8:001  9:001  10:001
012  021  102  112  122  221  012  020  021  022
000  000  000  000  000  000  000  000  000  000
11:001  12:001  13:001  14:001 15:001 16:001 17:001 18:001 19:002  20:002
102  112  122  200  202  220  221  222  021  100
000  000  000  000  000  000  000  000  000  000
21:002  22:010  23:010  24:010 25:010 26:010 27:010 28:010 29:010  30:010
111  002  012  102  112  200  202  220  221  222
000  000  000  000  000  000  000  000  000  000
31:011  32:011  33:011  34:011 35:011 36:011 37:012 38:012 39:012  40:012
012  021  022  112  220  222  021  100  111  200
000  000  000  000  000  000  000  000  000  000
41:012  42:012  43:020  44:021 45:022 46:100 47:100 48:100 49:100  50:101
202  222  001  021  111  200  220  221  222  220
000  000  000  000  000  000  000  000  000  000
51:101  52:102  53:110  54:110 55:110 56:110 57:110 58:111 59:111  60:112
222  202  102  112  202  211  222  102  222  111
000  000  000  000  000  000  000  000  000  000
61:112  62:112  63:112  64:112 65:121 66:121 67:122 68:122 69:122  70:200
112  121  122  212  121  221  111  122  211  100
000  000  001  001  001  001  001  001  002  002
71:211  72:222  73:000  74:000 75:001 76:110 77:110 78:110 79:002  80:010
111  111  112  220  112  002  012  220  221  200
002  002  002  002  002  002  002  002  002  002
81:012  82:012  83:101  84:101 85:101 86:102 87:112 88:112 89:112  90:210
220  221  002  022  200  220  001  100  220  200
002  011  011  011  012  012  012  012  100  100
91:210  92:121  93:200  94:222 95:100 96:101 97:120 98:200 99:100 100:100
220  121  100  111  200  210  201  100  200  220
100  100  100  111
101:200 102:200 103:222 104:222
100  200  111  000

Mit Hilfe dieser Tabelle können wir das Hauptergebnis dieses Abschnitts beweisen, indem wir die noch verbleibenden 104 Funktion (d.h. 312 Komplexitätsklassen) einzeln untersuchen.

3.2.3. Ergebnis für den dreiwertigen Fall

3.20 Satz. Es sei g: {0, 1, 2}^{2} → {0, 1, 2}. Dann ist die Klasse ({g})P eine der zwanzig Klassen aus der folgenden Liste, und für alle Klassen aus der Liste gibt es eine solche Funktion g:

P  NP  coNP  ⊕P  PSPACE
Σ_{2}^{p}  Π_{2}^{p}  Δ_{2}^{p}  Θ_{2}^{p}  P^{NP}[1]
1-NP  NP ∧ coNP coNP ∧ ⊕P ∇P  co-∇P
⊕NP  ∃⊕P  ∀⊕P  MOD_{3}P  C_{>0,≡0(2)}P

Beweis. Eine genaue Untersuchung aller Fälle findet sich in [41]. Wir beschränken uns hier auf die Untersuchung der Funktion 34. Die betrachtete Funktion nennen wir f, sie hat die folgende Funktionstafel:

\begin{matrix}f & 0 & 1 & 2 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 1 & 1 \\ 2 & 1 & 1 & 2 \end{matrix}

Wir behaupten, daß mit F =_{def} {f} gilt:

a) (F^{({2})})P = coNP

b) (F^{({0})})P = NP

c) (F^{({1})})P = (F)P = NP ∧ coNP

Der Teil a) der Behauptung ist klar, da eine 2 dann und nur dann erzeugt wird, wenn beide Nachfolgeknoten zu einer 2 ausgewertet werden. Damit haben wir eine direkte UND-Verknüpfung.

Teil b) folgt daraus, daß ein Knoten zu 0 ausgewertet wird genau dann, wenn der linke Teilbaum zu einem Wert aus der Menge {0, 1} ausgewertet wird (ein NP-Problem, da es komplementär zur 2-Auswertung ist!) und darüberhinaus mindestens einer der beiden Teilbäume zu 0 ausgewertet wird. Eine NP Simulation arbeitet also wie folgt:

Simulation: Falls kein echter Baum vorliegt, erzeuge Wert true genau dann, wenn Blattwert 0 angenommen wird. Sonst: Erzeuge linken Teilbaum als NP Baum, d.h. mit Ergebnis true, wenn ursprünglich 0 oder 1 ausgegeben wird, und mit Ausgabe false, wenn ursprünglich 2 ausgegeben wird. Bei Ergebnis true, arbeite nichtdeterministisch mit dem linken und dem rechten Teilbaum weiter.

Damit sehen wir, daß (F^{({0})})P ⊆ NP. Andererseits ist klar, daß man allein auf den Werten 0 für true und 1 für false eine NP-Berechnung nachvollziehen kann.

Für Teil c) stellen wir zunächst fest, daß aus den Teilen a) und b) bereits folgt, daß (F^{({1})})P = (F)P ⊆ NP ∧ coNP. Für die Umkehrung betrachten wir zunächst die folgende Funktion g:

\begin{matrix}g & 0 & 1 & 2 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 1 & 1 \\ 2 & 0 & 1 & 2 \end{matrix}

Wegen g(x, y) = f(f(x, y), y) gilt g ∈ ⟨{f}⟩ und daher ({g})P ⊆ ({f})P. Wir müssen also nur noch zeigen, daß NP ∧ coNP ⊆ ({g})P ist. Sei also L ∈ NP ∧ coNP, d.h. es existieren zwei NP-Mengen A und B mit L = A ∩ \overline{B}. Man betrachte eine ({g})P-Maschine, die wie folgt arbeitet:

    Simuliere NP-Algorithmus für A.
    Bei reject, gib 2 aus.
    Bei accept:
        Simuliere NP-Algorithmus für B.
        Bei reject, gib 1 aus.
        Bei accept, gib 0 aus.

Man überprüft leicht, daß dieser Algorithmus in seinen Blättern dann und nur dann mindestens eine 1 aber nie eine 0 ausgibt, wenn die Eingabe in A, aber nicht in B ist. Genau dann akzeptiert die simulierende Maschine gemäß der Funktionstafel für g mit Wurzelwert 1. Damit ist NP ∧ coNP ⊆ ({g})P ⊆ ({f})P. □

3.3. Der zweistufige Abschluß

Ein typischer Fall für eine zweistufige Berechnung ist die Σ_{2}^{p} Berechnung. Hier wird nichtdeterministisch ein Berechnungsbaum erzeugt, in dessen Knoten die logischen UND- und ODER-Funktionen stehen dürfen, aber niemals darf ein ODER-Knoten im Baum nach einem UND-Knoten auftreten. Wir wollen solche zweistufigen Berechnungen auch allgemeiner definieren und untersuchen, ob sie mehr leisten als die einstufigen LDA-Typen.

Für die formale Definition ist es günstig, wenn man davon ausgehen kann, daß zumindest in der oberen Stufe der LDA-Typ mindestens vierwertig ist. Wir wollen hier bemerken, daß man jederzeit einen k-wertigen Akzeptanztyp F zu einem (k + 1)-wertigen Akzeptanztyp F′ mit (F)P = (F′)P abändern kann, indem man definiert, daß der Wert k als Eingabe zu jeder der Funktionen aus F dieselbe Wirkung hat wie der Wert 0, also F′ =_{def} {f′ | f ∈ F }, wobei für f ∈ F die Funktion f′ definiert ist wie folgt:

f′(x_{1}, …, x_{r})=_{def}f(x̃_{1}, …, x̃_{r})

Dabei ist k̃ = 0 und x̃ = x für alle x ≠ k.

3.3.1. Das zweistufige Akzeptierungsmodell

3.21 Definition. Es seien F und G (F ∩ G = ∅) zwei Akzeptanztypen und o.B.d.A. F mindestens vierwertig. Dann definieren wir das zweistufige Akzeptierungsmodell F ∘ G wie den LDA-Typ F ∪ G mit folgenden Unterschieden:

• Bei der Baumerzeugung werden nur solche Bäume zugelassen, in denen gilt, daß niemals Teilbäume, deren Wurzel eine Funktion aus G zugeordnet ist, einen inneren Knoten haben dürfen, dem eine Funktion aus F zugeordnet ist. Außerdem darf der Baumwurzel keine Funktion aus G zugeordnet werden.

• Bei der Baumauswertung werden Knotenwerte, die von einer Funktion aus G erzeugt wurden, die aber als Eingabe für eine Funktion aus F (im Vorgängerknoten) dienen, wie folgt übersetzt: 1 ↦ 3, x ↦ 2 (x ≠ 1).

• Die Klasse (F ∘ G)P wird definiert durch die Festlegung, daß eine Menge L zu (F ∘ G)P gehört, wenn es eine Maschine gibt, die sich an die obige Baumerzeugungsregel hält und deren Wurzelwert sich zu 1 genau dann berechnet, wenn die Eingabe in L ist.

Wir wollen ein Beispiel beschreiben. Es seien die folgenden zwei Funktionen f und g gegeben:

\begin{matrix}f & 0 & 1 & 2 & 3 \\ 0 & 0 & 1 & 0 & 1 \\ 1 & 1 & 1 & 1 & 1 \\ 2 & 0 & 1 & 0 & 1 \\ 3 & 1 & 1 & 1 & 1 \end{matrix}  \begin{matrix}g & 0 & 1 & 2 & 3 \\ 0 & 0 & 1 & 2 & 0 \\ 1 & 1 & 2 & 0 & 1 \\ 2 & 2 & 0 & 1 & 2 \\ 3 & 0 & 1 & 2 & 0 \end{matrix}

Es sei F =_{def}{f} und G=_{def}{g}.

Behauptung: (F ∘ G)P = ∃MOD_{3}P.

Wir zeigen zunächst, daß ∃MOD_{3}P ⊆ (F ∘ G)P: Es sei A ∈ MOD_{3}P, p ein Polynom und B = {x | ∃y: |y| ≤ p(|x|) ∧ ⟨x, y⟩ ∈ A}. M_{0} sei eine nichtdeterministische Maschine mit der Eigenschaft x ∈ A ⟺ acc_{M_{0}}(x) ≡ 1 mod 3. Dabei bezeichnen wir allgemein für eine Maschine M und ein Wort x mit acc_{M}(x) die Anzahl der akzeptierenden Pfade von M bei Eingabe x. (Eine solche Maschine existiert für alle Mengen in MOD_{3}P, vgl. [12]). Wir müssen zeigen, daß B zu (F ∘ G)P gehört. Dazu definieren wir die Maschine M, die wie folgt arbeitet: Auf Eingabe x rät M ein Wort y mit |y| ≤ p(|x|); dabei wird jedem nichtdeterministischen Schritt die Funktion f zugeordnet. Dann simuliert M die Maschine M_{0} auf der Eingabe ⟨x, y⟩, wobei allen nichtdeterministischen Schritten die Funktion g zugeordnet wird. Akzeptierende Pfade nehmen Blattwert 1, ablehnende Blattwert 0 an.

Offenbar ist M eine (F ∘ G)P-Maschine, die genau die Menge B akzeptiert.

Nun beweisen wir noch, daß (F ∘ G)P ⊆ ∃MOD_{3}P. Sei B eine Menge in (F ∘ G)P, M eine (F ∘ G)P-Maschine für B. M akzeptiert die Eingabe x offenbar genau dann, wenn entweder der gesamte Baum nur aus einem einzigen Blatt mit Blattwert 1 besteht oder wenn es einen Knoten im Berechnungsbaum T_{M}(x) gibt, dessen Vorgängerknoten ein f-Knoten ist und der entweder ein Blatt mit Wert 1 oder ein g-Knoten, der den Wert 1 annimmt, ist. Da es in MOD_{3}P feststellbar ist, ob ein g-Knoten den Wert 1 annimmt, gehört also B zu ∃MOD_{3}P: Man rät den Knoten in T_{M}(x), der die oben genannte Bedingung erfüllt (∃) und verifiziert dann die Bedingung (MOD_{3}P).

Der folgende Satz gibt uns eine neue Beweistechnik für die Abschlußeigenschaften von Satz 3.13 und gleichzeitig eine Reihe weiterer wichtiger Abschlußeigenschaften des Systems der durch LDA-Typen charakterisierbaren Komplexitätsklassen.

3.22 Satz. F ∘ G sei ein zweistufiges Akzeptierungsmodell. Dann existiert ein LDA-Typ H mit (F ∘ G)P = (H)P.

Beweis. Es sei F ein k-wertiger (k ≥ 4) und G ein k′-wertiger Akzeptanztyp. Wir verwenden für H die Werte 0, …, k + k′ − 1 und definieren folgende |F | + |G| + 1 Funktionen:

Für jede Funktion f ∈ F (r-stellig):

f′(x_{1}, …, x_{r}) = f(x_{1}, …, x_{r})  falls 0 ≤ x_{i} ≤ k − 1 ∀i
f′(x_{1}, …, x_{r}) = 0  sonst

Für jede Funktion g ∈ G (s-stellig):

g′(x_{1}, …, x_{s}) = g(x_{1} − k, …, x_{s} − k) + k falls k ≤ x_{i} ≤ k′ + k − 1 ∀i
g′(x_{1}, …, x_{s}) = k  sonst

h(k + 1) = 3

h(x) = 2  sonst

Offenbar gilt mit H = {f′ | f ∈ F } ∪ {g′ | g ∈ G} ∪ {h}, daß (F ∘ G)P ⊆ (H)P: ersetze f-Schritte durch f′-Schritte, g-Schritte, deren Vorgängerschritte f-Schritte sind, durch einen h-Schritt gefolgt von einem g′-Schritt, weitere g-Schritte durch g′-Schritte. Offensichtlich wird damit die (F ∘ G)P-Berechnung als (H)P-Berechnung exakt nachvollzogen.

Umgekehrt gilt aber auch (H)P ⊆ (F ∘ G)P, denn eine (H)P-Maschine M kann von einer (F ∘ G)P-Maschine simuliert werden:

Die simulierende Maschine untersucht bei einer f′-Konfiguration immer, ob alle Nachfolger auch nicht vom Typ g′ sind (und auch nicht Konstanten mit Wert ≥ k). Trifft das zu, so kann der f′-Schritt durch einen f-Schritt simuliert werden. Anderenfalls kann die simulierende Maschine direkt den Blattwert 0 annehmen. (Ein Blick in die Funktionsdefinitionen zeigt, daß damit der entsprechende Teilbaum der simulierten Berechnung in jedem Fall korrekt simuliert wird!)

Bei einer h-Konfiguration testet die simulierende Maschine, ob die nachfolgende Konfiguration eine g′-Konfiguration ist. Wenn ja, so simuliert sie den Schritt deterministisch, anderenfalls nimmt sie den Blattwert 2 an, es sei denn, M nimmt an dieser Stelle den Blattwert k + 1 an – in diesem Fall erzeugt die Simulation ein Blatt mit Wert 3.

Bei einer g′-Konfiguration testet die simulierende Maschine, ob die Nachfolger alle keine f′- oder h-Konfigurationen sind (und auch nicht Konstanten mit Wert < k). Trifft das zu, so kann wieder direkt mit einem g-Schritt simuliert werden. Anderenfalls wird der Blattwert k erzeugt.

Mit diesem Schema wird offenbar die (H)P-Berechnung korrekt simuliert. □

Die folgende Verallgemeinerung von Satz 3.22 ist auch sehr nützlich:

3.23 Definition. Es seien F, G_{1}, …, G_{r} LDA-Typen. Dabei sei F k-wertig mit einem k ≥ 2r + 2. Es sei F ∘ (G_{1}, …, G_{r}) das Akzeptierungsmodell, das wie F ∘ G definiert ist mit dem Unterschied, daß in Teilbäumen, deren Wurzel eine Funktion aus G_{i} zugeordnet ist, keinem inneren Knoten mehr eine Funktion aus den anderen G_{j} oder aus F zugeordnet sein darf. In der Auswertung werden die Werte von G_{i} beim Übergang zu einem F -Knoten dann wie folgt übersetzt: 1 ↦ 2i, x ↦ 2i + 1 (x ≠ 1). Die entsprechend definierte Komplexitätsklasse nennen wir (F ∘ (G_{1}, …, G_{r}))P.

3.24 Satz. Es seien F, G_{1}, …, G_{r} LDA-Typen, dann gibt es einen LDA-Typ H mit (F ∘ (G_{1}, …, G_{r}))P = (H)P.

Beweis. Analog zu dem Beweis von Satz 3.22. □

Mit diesen beiden Sätzen kann man direkt die Aussagen des Satzes 3.13 beweisen. Wir führen das exemplarisch für den Fall C_{1} ∧ C_{2} durch:

Es seien F_{1} und F_{2} zwei LDA-Typen, die die Klassen C_{1} und C_{2} charakterisieren. Wir definieren die Funktion h: {0, 1, 2, 3, 4, 5}^{2} → {0, 1, 2, 3, 4, 5}:

\begin{matrix}h & 0 & 1 & 2 & 3 & 4 & 5 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 2 & 0 & 0 & 0 & 0 & 0 & 0 \\ 3 & 0 & 0 & 0 & 0 & 0 & 1 \\ 4 & 0 & 0 & 0 & 0 & 0 & 0 \\ 5 & 0 & 0 & 0 & 0 & 0 & 0 \end{matrix}

Man sieht sofort, daß eine ({h} ∘ (F_{1}, F_{2}))P-Berechnung nur dann akzeptierend sein kann, wenn der Berechnungsbaum aus einem h-Schritt, gefolgt von einer akzeptierenden F_{1}-Berechnung im linken Teilbaum und einer akeptierenden F_{2}- Berechnung im rechten Teilbaum besteht. Also gilt ({h} ∘ (F_{1}, F_{2}))P ⊆ (F_{1})P ∧ (F_{2})P. Andererseits kann man aber auf ebendiese Weise eine (F_{1})P ∧ (F_{2})P-Berechnung immer als ({h}∘(F_{1}, F_{2}))P-Berechnung realisieren. Damit folgt die Gleichheit der beiden Klassen.

3.3.2. Folgerungen für tt- und reguläre Reduktionen

Bei einer truth-table-Reduktion von A auf B werden durch einen Polynomialzeit-Algorithmus aus einer Eingabe x zunächst beliebig viele (aber natürlich höchstens polynomiell viele) Wörter z_{1}, …, z_{r} und ein Schaltkreis h berechnet. Die Eingabe x muß genau dann zu A gehören, wenn der Schaltkreis h, angewendet auf die Werte c_{B}(z_{1}), …, c_{B}(z_{r}) den Wert 1 produziert.

Wir wollen uns zunächst überlegen, daß es nicht sehr wahrscheinlich ist, den Abschluß der durch LDA-Typen charakterisierbaren Klassen gegen allgemeine truth-table-Reduktion beweisen zu können. Nehmen wir nämlich an, es gäbe einen entsprechenden LDA-Typ, dann müßte der so beschaffen sein, daß sinnvolle Bäume, die durch diesen Akzeptanztyp erzeugt werden, in der Größe polynomiell beschränkt sind, denn der Abschluß von P unter tt-Reduktion ist P. Polynomiell beschränkbare Bäume können aber immer so normiert werden, daß sie nur einseitig wachsen, d.h. man könnte den Schaltkreis h immer durch denselben regulären Ausdruck ersetzen. Das ist aber so direkt nicht möglich.

Daher werden wir uns im folgenden auf Spezialfälle der allgemeinen tt-Reduktionen beschränken.

3.25 Definition. Eine k-beschränkte truth-table-Reduktion ist eine Reduktion der folgenden Form: A ist auf B reduzierbar, wenn es eine in polynomieller Zeit berechenbare Funktion z gibt, die bei Eingabe x ein Wort z(x) = z_{1}#z_{2}# … #z_{r}#h berechnet (r ≤ k), so daß h eine r-stellige boolesche Funktion ist mit

x ∈ A ⟺ h(c_{B}(z_{1}), c_{B}(z_{2}), …, c_{B}(z_{r})) = 1.

Dabei darf die Menge der für h in Frage kommenden booleschen Funktionen eingeschränkt sein. Für festes k und eine Menge H von in Frage kommenden booleschen Funktionen mit bis zu k Variablen bezeichnen wir diesen Reduktionstyp mit ≤k-tt^{H}.

3.26 Satz. Das System der durch LDA-Typen charakterisierbaren Klassen ist abgeschlossen gegen ≤k-tt^{H} für jedes k und jede Menge von booleschen Funktionen H.

Beweis. Für ein gegebenes k und eine gegebene Menge von booleschen Funktionen H kann man leicht einen Akzeptanztyp F angeben, der die gewünschte Reduktion in einer ersten Stufe eines zweistufigen Berechnungsmodells leistet, d.h. daß (F ∘ G)P = ≤k-tt^{H}((G)P) ist für alle LDA-Typen G.

Wir wollen das am Beispiel k = 3 mit der Funktionenmenge H = {h_{1}, h_{2}} durchführen, wobei h_{1}(x, y, z) = 1 ⟺ x = y = z = 1 und h_{2}(x, y, z) = 1 ⟺ x = y = z = 0. Allerdings geben wir nur den LDA-Typ F an, der Nachweis der Korrektheit ist leicht und bleibt dem Leser überlassen.

Wir benötigen die Werte 0, …, 6 und setzen F = {f, g_{1}, g_{2}} mit:

f(x, y, z) = 4 falls x = y = z = 3
f(x, y, z) = 5 falls x = y = z = 2
f(x, y, z) = 6 in allen anderen Fällen
g_{1}(4) = 1
g_{1}(x) = 0  falls x ≠ 4
g_{2}(5) = 1
g_{2}(x) = 0  falls x ≠ 5
□

3.27 Definition. Eine polynomiell-beschränkte reguläre Reduktion ist eine Reduktion der folgenden Form: A ist auf B reduzierbar, wenn es eine reguläre Menge L ⊆ {0, 1}^{∗} und eine in polynomieller Zeit berechenbare Funktion z gibt, die bei Eingabe x ein Wort z(x) = z_{1}#z_{2}# … #z_{r} berechnet mit

x ∈ A ⟺ c_{B}(z_{1})c_{B}(z_{2}) … c_{B}(z_{r}) ∈ L.

Für eine feste reguläre Menge L bezeichnen wir diesen Reduktionstyp mit ≤_{L}^{p}, und wir sagen A≤_{REG}^{p}B, falls es eine reguläre Menge L gibt mit A≤_{L}^{p}B.

Man überlegt sich leicht, daß selbst der allgemeinste der in dieser Definition eingeführten Reduktionsbegriffe, ≤_{REG}^{p}, ein Spezialfall der allgemeinsten tt-Reduktion ist. Allerdings erhalten wir als Spezialfälle dieser Definition einige wichtige Versionen der allgemeinen tt-Reduktion: die konjunktive tt-Reduktion kann dargestellt werden als ≤_{L}^{p}, wobei L = 1^{∗} ist, und die disjunktive tt-Reduktion als ≤_{L}^{p} mit L = {0, 1}^{∗}1{0, 1}^{∗}.

3.28 Satz. Das System der durch LDA-Typen charakterisierbaren Klassen ist abgeschlossen gegen ≤_{L}^{p} für jede reguläre Menge L.

Beweis. Es sei A ein Minimalautomat für die Sprache L, dessen Zustände die Bezeichnungen 4, 5, …, k − 1 tragen. Ferner sei α die Menge der akzeptierenden Zustände und δ_{0} die Zustandsübergangsfunktion bei Eingabe 0, δ_{1} die bei Eingabe 1. Wir definieren die folgenden Funktionen:

f(x, y) = δ_{1}(y) falls x = 3 und y > 3
f(x, y) = δ_{0}(y) falls x = 2 und y > 3
f(x, y) = 4  sonst
h(x) = 1  falls x ∈ α
h(x) = 0  sonst

Es gilt A ∈ ({f, h} ∘ G)P ⟺ ∃B ∈ (G)P: A≤_{L}^{p}B. Man prüft das leicht nach, wenn man bedenkt, daß ein sinnvoller Baum durch die Funktionen h und f nur so aufgebaut werden kann:

[figure: G-; Berechnung; G-; Berechnung; G-; Berechnung; .; .; .; .; .; .; .; .; .; .; Blatt mit; Wert ≥ 4; f; f; f; h]
□

3.3.3. Turing-Abschluß

Ein wichtiger Aspekt der uniformen Beschreibung vieler Komplexitätsklassen durch das LDA-Modell ist die standardisierte Form des Orakelzugriffs:

3.29 Definition. Es sei F ein LDA-Typ, A eine beliebige Menge. Dann ist die Klasse (F)P^{A} definiert als die Klasse der Mengen, die von einer nichtdeterministischen Orakelmaschine mit Zugriff auf das Orakel A und Akzeptierungsbedingung gemäß F akzeptierbar sind. Für eine Komplexitätsklasse C definieren wir (F)PC =_{def} ⋃_{A∈C}(F)P^{A}.

3.30 Satz. Es seien F und G zwei LDA-Typen. Dann gibt es einen LDA-Typ H mit (F)P^{(G)P} = (H)P.

Beweis. O.B.d.A. sei F = {f}, f eine k-wertige zweistellige Funktion. Dabei nehmen wir weiterhin an, daß f(2, y) = f(3, y) = f(0, y), f(x, 2) = f(x, 3) = f(x, 0) und f(x, y) ∉ {2, 3} ∀x, y ∈ {0, …, k − 1}. Das können wir, da nach der Bemerkung zu Beginn des Kapitels zwei nicht benutzte Werte hinzugefügt werden dürfen (nicht benutzt heißt hier, daß sie immer wie der Wert 0 wirken!), ohne die Berechnungskraft von F zu verändern. Durch Umbenennen der Werte erreichen wir dann, daß die nicht benutzten Werte 2 und 3 sind. Wir definieren eine Funktion h: {0, …, k − 1}^{3} → {0, …, k − 1} wie folgt:

h(x, y, z) = y falls x = 3, y, z ∉ {2, 3}
h(x, y, z) = z falls x = 2, y, z ∉ {2, 3}
h(x, y, z) = 0 sonst

Behauptung: ({f, h} ∘ G)P = (F)P^{(G)P}. Zum Beweis dieser Behauptung beobachten wir zunächst, daß ein h-Knoten nur dann einen von 0 verschiedenen Wert bekommen kann, wenn er als Nachfolgeknoten einen G-Knoten und zwei {f, h}-Knoten hat, wobei der G-Knoten der linke Nachfolgeknoten sein muß. (G-Knoten dürfen natürlich durch Blätter mit Wert 2 oder 3 ersetzt werden, {f, h}-Knoten durch Blätter mit Wert aus der Menge {0, 1, 4, 5, …, k − 1}.) Eine (F)P-Maschine kann also ihr (G)P-Orakel befragen, ob der G-Nachfolger den Wert 2 oder 3 hat, und braucht entsprechend nur einen der beiden anderen Nachfolger weiterzusimulieren. So sehen wir, daß ({f, h} ∘ G)P ⊆ (F)P^{(G)P} ist. Die umgekehrte Richtung folgt aber daraus, daß man jeden Orakelaufruf einer (F)P^{(G)P}-Maschine durch einen h-Knoten mit der Berechnung des Orakels im linken Nachfolger, der Konfiguration nach einer ”Ja“-Antwort im mittleren Nachfolger und der nach einer ”Nein“-Antwort im rechten Nachfolger simulieren kann. □

3.31 Korollar. Das System der durch lokal definierbare Akzeptanztypen charakterisierbaren Klassen ist abgeschlossen gegen die Operatoren ≤_{T}^{P}, ≤_{T}^{NP}, sowie eine Reihe ähnlicher verallgemeinerter Turing-Reduktionen.

Beweis. Es genügt der Hinweis, daß es LDA-Typen gibt, die P bzw. NP charakterisieren.

□

3.4. Blattsprachen und LDA-Typen

In den letzten vier Jahren wurde ein in einigen Eigenschaften den LDA-Typen sehr ähnliches Modell zur uniformen Charakterisierung von Komplexitätsklassen untersucht, nämlich die Beschreibung von Komplexitätsklassen durch Blattsprachen. Die grundlegenden Arbeiten von Bovet, Crescenzi und Silvestri [17, 18] verwendeten allerdings noch nicht den Ausdruck ”leaf languages“, dieser wurde in [43] eingeführt. Auch die Arbeiten [47, 44, 19] beschäftigen sich mit dem Blattsprachen-Modell.

In diesem Abschnitt führen wir zunächst das Modell formal ein, um es dann mit dem Modell der LDA-Typen zu vergleichen. Schließlich werden wir von einer Teilmenge der Blattsprachen (nämlich den regulären Blattsprachen) zeigen, daß sie einer bestimmten Menge von LDA-Typen (nämlich den aus einer zweistelligen assoziativen Funktion bestehenden) äquivalent ist.

Ein wichtiger Aspekt des Blattsprachenmodells ist das Kriterium aus [18] für die Existenz eines trennenden Orakels zwischen zwei durch Blattsprachen definierbaren Klassen. Wir werden auf diesen Aspekt erst im Kapitel 5 zurückkommen.

3.4.1. Das Blattsprachen-Modell

3.32 Definition. Es sei M eine nichtdeterministische Polynomialzeitmaschine, die auf jedem Pfad ihrer Berechnung ein Symbol aus einem Alphabet Σ erzeugt. Das Blattwort von M bei Eingabe x, leafstring^{M}(x), ist das Wort aus Σ^{∗}, das entsteht, wenn man die an den Blättern des Baumes erzeugten Symbole von links nach rechts aneinandersetzt. Wir setzen voraus, daß die Maschine jeweils unter den Nachfolgekonfigurationen zu einer gegebenen Konfiguration eine feste Ordnung vorgibt, so daß das Blattwort von M bei Eingabe x eindeutig bestimmt ist.

Nun kann man eine Komplexitätsklasse definieren, indem man eine Akzeptierungsmenge A in Σ^{∗} vorgibt und sagt, daß die Maschine M die Eingabe x genau dann akzeptiert, wenn leafstring^{M}(x) zur Menge A gehört:

3.33 Definition. Die Klasse Leaf^{P}(A) besteht aus allen Mengen L, für die es eine Polynomialzeitmaschine M gibt mit der Eigenschaft, daß

x ∈ L ⟺ leafstring^{M}(x) ∈ A.

Für eine Klasse C bezeichnet Leaf^{P}(C) die Vereinigung aller Leaf^{P}(A) mit A ∈ C.

Die in [17, 18, 43] betrachteten Blattsprachenklassen unterscheiden sich von dieser Definition darin, daß nur solche Maschinen zugelassen wurden, bei denen man leicht, d.h. deterministisch in Polynomialzeit, feststellen kann, welches Zeichen an der i-ten Stelle von leafstring^{M}(x) zu finden ist.

3.34 Definition. Eine nichtdeterministische Polynomialzeitmaschine heißt balanciert, wenn es eine Funktion λ ∈ FP gibt mit Werten in Σ ∪ {#}, so daß λ(x, i) = ”i-tes Bit von leafstring^{M}(x)“, falls ein solches Bit existiert, und λ(x, i) = #, sonst.

3.35 Definition. Die Klasse BalancedLeaf^{P}(A) besteht aus allen Mengen L, für die es eine balancierte Polynomialzeitmaschine M gibt mit der Eigenschaft, daß

x ∈ L ⟺ leafstring^{M}(x) ∈ A.

Für eine Klasse C bezeichnet BalancedLeaf^{P}(C) die Vereinigung aller BalancedLeaf^{P}(A) mit A ∈ C.

Die folgende Tatsache folgt direkt aus diesen Definitionen:

3.36 Fakt. Es gilt BalancedLeaf^{P}(L) ⊆ Leaf^{P}(L) für alle Sprachen L, und daher auch BalancedLeaf^{P}(C) ⊆ Leaf^{P}(C) für alle Klassen C.

In den meisten Fällen werden wir nur die Klassen Leaf^{P}(.) und BalancedLeaf^{P}(.) betrachten. Wir wollen aber noch anmerken, daß in der ursprünglichen Definition auch die Möglichkeit gegeben wurde, bei ablehnenden Berechnungen nicht alle Blattworte aus Σ^{∗} \ A zuzulassen, sondern eine Ablehnungsmenge R mit A ∩ R = ∅ einzuführen:

3.37 Definition. Die Klasse Leaf^{P}(A, R) besteht aus allen Mengen L, für die es eine Polynomialzeitmaschine M gibt mit der Eigenschaft, daß

x ∈ L ⟹ leafstring^{M}(x) ∈ A
x ∉ L ⟹ leafstring^{M}(x) ∈ R.

Analog definieren wir BalancedLeaf^{P}(A, R).

Zur Veranschaulichung des Unterschieds zwischen Leaf^{P}(.), BalancedLeaf^{P}(.) und Leaf^{P}(., .) bzw. BalancedLeaf^{P}(., .) sollen die folgenden Beispiele dienen:

Beispiel 1. Es sei L = {w ∈ Σ^{∗} | |w| ≡ 1 mod 2}. Dann gilt BalancedLeaf^{P}(L) = P: Mit binärer Suche kann man das letzte Bit des Blattworts finden und je nach Position dieses Bits akzeptieren oder ablehnen.

Auf der anderen Seite gilt aber Leaf^{P}(L) = ⊕P: Die Inklusion von links nach rechts ist trivial (man nimmt dieselbe Maschine, läßt sie aber auf allen Pfaden akzeptieren), von rechts nach links simulieren wir eine ⊕P-Maschine, indem wir am Ende eines akzeptierenden Pfades irgendein Symbol aus Σ erzeugen, am Ende eines ablehnenden Pfades aber noch eine nichtdeterministische Aufspaltung durchführen, um dann in beiden Blättern je ein Zeichen aus Σ auszugeben.

Beispiel 2. Es sei A = 0^{∗}10^{∗} ⊆ {0, 1}^{∗}, R = 0^{∗}. Dann gilt Leaf^{P}(A, R) = BalancedLeaf^{P}(A, R) = UP. Es ist sehr unwahrscheinlich, daß es eine Menge B gibt mit Leaf^{P}(B) = UP oder BalancedLeaf^{P}(B) = UP.

3.4.2. Vergleich mit dem LDA-Modell

Zunächst wollen wir uns vergegenwärtigen, daß es Komplexitätsklassen gibt, die in der Form Leaf^{P}(.) darstellbar, aber nicht mit LDA-Typen charakterisierbar sind. Wir hatten bereits im Abschnitt 3.1.1 festgestellt, daß mit LDA charakterisierbare Klassen immer Teilklassen von PSPACE sind. Das liegt im wesentlichen daran, daß ein Baumtraversierungsalgorithmus den polynomiell tiefen erzeugten Baum vollständig untersuchen und die Knotenwerte sukzessive alle berechnen kann. Schließlich wird je nach Wurzelwert über Akzeptierung oder Ablehnung entschieden. Dagegen gilt für die Leaf^{P}(.) und die BalancedLeaf^{P}(.) Klassen das folgende:

3.38 Lemma. Für alle Sprachen L gilt sowohl L ∈ Leaf^{P}(L) als auch L ∈ BalancedLeaf^{P}(L).

Beweis. Wegen Fakt 3.36 genügt es zu zeigen, daß L ∈ BalancedLeaf^{P}(L) für alle Sprachen L. Offenbar kann eine Polynomialzeitmaschine M so entworfen werden, daß sie bei Eingabe x mit |x| = n genau n Pfade gleicher Länge erzeugt und auf dem i-ten Pfad das i-te Zeichen von x erzeugt. Damit gilt leafstring^{M}(x) ∈ L ⟺ x ∈ L. □

Da wir L beliebig komplex wählen können, ergibt sich hieraus:

3.39 Korollar. Es gibt Sprachen L mit der Eigenschaft, daß Leaf^{P}(L) nicht berechenbare Sprachen enthält.

Damit ist also sicher, daß nicht jede Klasse der Form Leaf^{P}(L) oder BalancedLeaf^{P}(L) durch einen LDA-Typ charakterisiert werden kann. Umgekehrt kann aber jede durch einen LDA-Typ charakterisierbare Klasse durch eine Blattsprache definiert werden. Die Blattsprache kann sogar aus DPDA[log] gewählt werden.

3.40 Lemma. Es sei F ein LDA-Typ. Dann gibt es eine Sprache L ∈ DPDA[log] mit der Eigenschaft, daß (F)P = Leaf^{P}(L).

Beweis. Es sei F = ({f}) und f eine zweistellige k-wertige Funktion. Wir definieren eine dreistellige (k + 1)-wertige Funktion f′ durch f′(x, y, z) = f(y, z), falls x = k, y < k und z < k, f′(x, y, z) = 0, sonst. Damit wird praktisch das Blattwort einer ({f})P-Berechnung in eine Präfixform gebracht, die von einem Kellerautomaten deterministisch analysiert werden kann. Da der Kellerautomat sich immer nur polynomiell viele Werte merken muß (in der Eingabelänge der ({f})P-Maschine), braucht er in der Blattwortlänge nur logarithmisch viel Kellerspeicher. Die Einzelheiten überlassen wir dem interessierten Leser. □

Die Umkehrung dieses Lemmas ist nicht bekannt.

Für eine noch kleinere Klasse von Blattsprachen kann man aber immer einen LDA-Typ angeben, der dann auch besonders einfache Struktur hat:

3.41 Lemma. Es sei L eine reguläre Sprache über Σ. Dann gibt es eine assoziative zweistellige k-wertige Funktion f und eine Teilmenge α von {0, …, k−1} mit Leaf^{P}(L) = ({f}^{(α)})P.

Beweis. L werde von dem endlichen Automaten A = (Q, Σ, δ, q_{0}, F) akzeptiert. Wir bezeichnen mit S die Menge der Funktionen von Q nach Q mit der Eigenschaft, daß es ein Wort über Σ^{∗} gibt, das im Automat A genau diese Funktion bewirkt. Wir definieren eine |S|-wertige Akzeptierungsfunktion f, indem wir die Werte als Funktionen aus S auffassen und für zwei solche Werte x und y den Wert f(x, y) als die Hintereinanderausführung der beiden durch x und y definierten Funktionen. Als Akzeptierungsmenge nehmen wir die Menge α der solchen Funktionen aus S, die den Startzustand in einen Zustand aus F überführen.

Mit der so definierten Funktion f gilt die Behauptung des Lemmas: Leaf^{P}(L) ⊆ ({f}^{(α)})P, denn für A ∈ Leaf^{P}(L) vermöge der Maschine M kann man eine ({f}^{(α)})P-Maschine M′ definieren, die wie M arbeitet, aber anstelle des Blattwerts a aus dem Alphabet Σ ein Blatt mit Wert δ_{a} annimmt, wobei δ_{a} diejenige Funktion von Q in sich ist, die jeden Zustand q in δ(q, a) überführt. Offenbar akzeptiert M′ als ({f}^{(α)})P-Maschine genau dann die Eingabe, wenn M ein Blattwort aus L erzeugt.

Es gilt aber auch ({f}^{(α)})P ⊆ Leaf^{P}(L), denn zu jedem Wert in S existiert ein kürzestes Wort, das im Automat A die betreffende Funktion von Q nach Q bewirkt. Eine ({f}^{(α)})P-Maschine M′ kann also von einer nichtdeterministischen Polynomialzeitmaschine direkt simuliert werden, aber statt das Blatt s ∈ S zu erzeugen, erzeugt M′ eine Reihe von Blättern, die zusammen das kürzeste nichtleere Wort ergeben, das die Funktion s in A bewirkt. □

3.42 Lemma. Es sei f eine zweistellige assoziative k-wertige Funktion und α eine Teilmenge von {0, …, k − 1}. Dann existiert eine reguläre Sprache L mit Leaf^{P}(L) = ({f}^{(α)})P.

Beweis. Wir wählen als Alphabet Σ die Menge {0, …, k − 1} und definieren eine Funktion f̃: Σ^{+} → Σ durch f̃(x) = x für x ∈ Σ und f̃(wx) = f(f̃(w), x) für x ∈ Σ, w ∈ Σ^{+}. Damit gilt offenbar die behauptete Gleichheit. □

Die Lemmata 3.41 und 3.42 ergeben den folgenden Satz:

3.43 Satz. Es sei C eine Komplexitätsklasse. Dann existiert eine reguläre Sprache L mit Leaf^{P}(L) = C genau dann, wenn es eine zweistellige assoziative Funktion f und eine Akzeptierungsmenge α gibt mit ({f}^{(α)})P = C.

Da offenbar den zweistelligen assoziativen Funktionen in Verbindung mit einer Akzeptierungsmenge α eine besondere Bedeutung zukommt, wollen wir hierfür den Namen assoziativer Akzeptanztyp einführen:

3.44 Definition. Ein assoziativer Akzeptanztyp {f}^{(α)} besteht aus einer zweistelligen assoziativen k-wertigen Funktion f und einer nichttrivialen Teilmenge α von {0, …, k − 1}. Die damit verbundene Komplexitätsklasse ({f}^{(α)})P ist so definiert wie im Beweis zu Lemma 3.10 vereinbart.

Akzeptierung durch endliche Halbgruppen

Die Verwendung von Halbgruppen und Monoiden als Modell für Berechnungen hat in der Komplexitätstheorie schon eine recht lange Tradition. Insbesondere der Zusammenhang zwischen Monoiden und Automaten und damit zwischen Monoiden und regulären Sprachen (über das syntaktische Monoid einer Sprache) wurde eingehend untersucht [5, 6, 70, 71, 72]. Eine weitere Anwendung der Monoide und Halbgruppen findet man in der Schaltkreistheorie [4, 7, 8, 53, 54]. Einen guten Überblick über die Zerlegungstheorie für Monoide erhält man im Buch von Eilenberg [30].

In unserem Zusammenhang ist es nützlich, diese Beschreibung assoziativer Akzeptanztypen zu untersuchen, da man durch die vorhandenen Strukturen auf der Menge der Halbgruppen einen Ansatz bekommt für eine genaue Klassifizierung der durch assoziative Akzeptanztypen charakterisierbaren Komplexitätsklassen. Zwar ist es bisher nicht gelungen, alle solchen Klassen zu bestimmen, aber wieder aufgrund der gegebenen Strukturen gelingt es zumindest, Ergebnisse für wohldefinierte Teilmengen der Menge aller Halbgruppen zu erzielen. Zurückübersetzt in den Blattsprachen-Zusammenhang bedeutet das, es gibt wohldefinierte Teilmengen der Menge aller durch reguläre Blattsprachen definierbaren Klassen, die wir genau bestimmen können.

4.1. Das Halbgruppen-Modell

4.1.1. Algebraische Grundbegriffe

Wir werden hier einige Grundbegriffe aus der Algebra definieren. Einzelheiten kann man in vielen Standardbüchern finden, etwa in den zwar schon etwas altmodischen, aber nach wie vor elegant wirkenden Büchlein von van der Waerden [80, 81].

4.1 Definition. Ein Paar H = (S, ∘), wobei S eine Menge und ∘ eine zweistellige assoziative Operation auf S ist, heißt Halbgruppe. Ist S eine endliche Menge, so nennen wir H eine endliche Halbgruppe. Falls H = (S, ∘) eine beliebige Halbgruppe ist, schreiben wir S(H) für die Menge S und gelegentlich φ_{H}(a, b) für a ∘ b. Falls es in der Halbgruppe H ein Element e ∈ S(H) gibt mit der Eigenschaft

∀a ∈ S(H): e ∘ a = a ∘ e = a,

dann ist H ein Monoid. Falls es in einem Monoid zu jedem a ∈ S(H) ein Element a′ ∈ S(H) gibt mit der Eigenschaft

a ∘ a′ = a′ ∘ a = e,

dann ist H eine Gruppe.

Wir haben schon in dieser Definition eine Einteilung der Menge aller Halbgruppen gegeben durch die Definition der Begriffe Monoid und Gruppe. Nun wollen wir einige zusätzliche mögliche Eigenschaften dieser Strukturen definieren, die uns eine feinere Einteilung erlauben. Zunächst erläutern wir kurz die Begriffe ”kommutative Gruppe“ und ”auflösbare Gruppe“:

4.2 Definition. Eine Gruppe G heißt kommutative Gruppe, wenn für alle a, b ∈ S(G) gilt: φ_{G}(a, b) = φ_{G}(b, a).

4.3 Definition. Eine Untergruppe U der Gruppe G heißt Normalteiler, wenn für alle g ∈ G gilt: gU = Ug. (Dabei ist gU = {gu | u ∈ U}, entsprechend Ug.) Ist G eine Gruppe mit Verknüpfung ∘ und U ein Normalteiler in G, dann bildet die Menge {gU | g ∈ G} mit der Verknüpfung g_{1}U · g_{2}U = (g_{1} ∘ g_{2})U eine Gruppe, die man die Faktorgruppe G/U nennt. Eine Gruppe G heißt auflösbar, wenn es Gruppen H_{1}, H_{2}, …, H_{r} gibt, so daß H_{i} Normalteiler ist in H_{i−1} (i = 2, …, r), H_{1} = G, H_{r} = {e} und H_{i−1}/H_{i} ist kommutative Gruppe.

4.4 Definition. Es sei H = (S, ∘) eine Halbgruppe (ein Monoid).

• H heißt kommutative Halbgruppe (kommutatives Monoid), wenn für alle a, b ∈ S gilt: a ∘ b = b ∘ a.

• H heißt auflösbare Halbgruppe (auflösbares Monoid), wenn für jede Unterhalbgruppe H′ von H gilt, daß H′ keine nichtauflösbare Gruppe ist.

• H heißt aperiodische Halbgruppe (aperiodisches Monoid), wenn für jedes a ∈ S ein m > 0 existiert mit a^{m} = a^{m+1}. (Dabei ist a^{1} = a und a^{m+1} = a ∘ a^{m}.)

• H heißt idempotente Halbgruppe (idempotentes Monoid), wenn für jedes a ∈ S gilt: a ∘ a = a.

Man beachte, daß nichttriviale Gruppen nicht aperiodisch und daher auch nicht idempotent sein können.

4.1.2. Akzeptierung durch endliche Halbgruppen

4.5 Definition. Wir sagen, die Sprache L ⊆ Σ^{∗} wird durch die endliche Halbgruppe H akzeptiert, wenn Σ ⊆ S(H) und eine Menge α ⊆ S(H) existiert mit:

w = w_{1}w_{2} … w_{n} ∈ L ⟺ w_{1} ∘ w_{2} ∘ … ∘ w_{n} ∈ α.

Wir nennen α die Akzeptierungsmenge für L. Die Sprachklasse HG wird definiert als

HG =_{def} {L | ∃H: H ist endliche Halbgruppe und L wird durch H akzeptiert}.

Das folgende Lemma ist ein bekannter und einfach zu beweisender Sachverhalt. Wir geben dennoch einen kurzen Beweis, um noch einmal an den Zusammenhang zwischen endlichen Halbgruppen und regulären Sprachen zu erinnern:

4.6 Lemma. HG ⊆ REG

Beweis. Sei L ⊆ Σ^{∗}, L ∈ HG, d.h. es existiert eine endliche Halbgruppe H, durch die L akzeptiert wird. Offenbar ist α = {σ ∈ Σ | σ ∈ L}, wobei σ in der Beziehung σ ∈ L als Wort der Länge 1 aufgefaßt wird, die Akzeptierungsmenge für L. Wir definieren den endlichen Automat M = (S(H), Σ, δ, q_{0}, α) mit

\begin{matrix}δ(q_{0}, σ) = σ & ∀σ ∈ Σ \\ δ(s, σ) = s ∘ σ & ∀s ∈ S(H), σ ∈ Σ, wobei a ∘ b = φ_{H}(a, b). \end{matrix}

Für die iterierte Funktion δ̂ gilt dann (mit w = w_{1}w_{2} … w_{n}):

\begin{aligned}δ̂(q_{0}, w) ∈ α & ⟺ & w_{1} ∘ w_{2} ∘ … ∘ w_{n} ∈ α \\ & ⟺ & w_{1}w_{2} … w_{n} ∈ L \end{aligned}

Also wird L von M akzeptiert, und damit gilt L ∈ REG. □

4.1.3. HG-Akzeptanztypen

4.7 Definition. Es sei H eine endliche Halbgruppe und α ⊆ S(H). Für Σ = S(H) wird durch H mit Akzeptierungsmenge α eine Sprache L ⊆ Σ^{∗} akzeptiert, nämlich die Menge L = {w = w_{1}w_{2} … w_{n} | w_{1} ∘ w_{2} ∘ … ∘ w_{n} ∈ α}. Wir schreiben L(H_{α}) für diese Menge L.

Für die Mengen L(H_{α}) gilt nach Definition L(H_{α}) ∈ HG und damit auch L(H_{α}) ∈ REG. Wir benutzen nun diese Sprachen, um Komplexitätsklassen zu definieren:

4.8 Definition. Die Komplexitätsklasse H_{α} · P wird mit Hilfe der Menge L = L(H_{α}) wie folgt definiert:

H_{α} · P =_{def} Leaf^{P}(L).

Wir nennen H_{α} einen HG-Akzeptanztyp und sagen, Leaf^{P}(L) wird durch die endliche Halbgruppe H (mit Akzeptierungsmenge α) charakterisiert.

4.9 Lemma. Sei C eine Komplexitätsklasse. Es existiert ein HG-Akzeptanztyp H_{α} mit H_{α} · P = C genau dann, wenn es eine zweistellige assoziative k-wertige Akzeptierungsfunktion f und eine Menge β gibt, so daß ({f}^{(β)})P = C.

Beweis. Wir zeigen zunächst die Richtung von links nach rechts. Es sei also C = H_{α} ·P = Leaf^{P}(L) für die durch H mit α akzeptierte Menge L. Wir wählen k = |S(H)| und nehmen o.B.d.A. an, daß die Gleichheit S(H) = {0, …, k − 1} gilt. Wir wählen ferner f = φ_{H} und β = α. Eine ({f}^{(β)})-Maschine akzeptiert damit offenbar genau dieselben Worte wie die entsprechende Leaf^{P}(L)- Maschine. Damit gilt C = ({f}^{(β)})P.

Für die Umkehrung fassen wir die Menge {0, …, k − 1} mit der Verknüpfung a ∘ b =_{def} f(a, b) als Halbgruppe auf und setzen α = β. Dann gilt offenbar H_{α} · P = ({f}^{(β)})P. □

Die Begriffe HG-Akzeptanztyp und assoziativer Akzeptanztyp (mit mehreren Akzeptierungswerten, vgl. Definition 3.44) sind also im Grunde nichts anderes als zwei verschiedene Formulierungen ein und derselben Akzeptierungstechnik. Wir wollen sie dennoch auch im weiteren nebeneinander stehenlassen, da die Motivation für ihre Einführung verschieden war: die HG-Akzeptierung entspringt Untersuchungen über Automaten und deren syntaktischen Monoiden, der assoziative Akzeptanztyp dagegen entsteht als Spezialfall der LDA-Typen.

Wir stellen aber noch einmal die Gleichmächtigkeit dieser beiden Akzeptierungsmodelle untereinander und mit dem Modell der regulären Blattsprachen fest (vgl. Satz 3.43):

4.10 Satz. Sei C eine Komplexitätsklasse. Die folgenden Aussagen sind äquivalent:

(1) C wird durch eine reguläre Blattsprache definiert.

(2) C wird durch einen assoziativen Akzeptanztyp charakterisiert.

(3) C wird durch eine endliche Halbgruppe charakterisiert.

4.1.4. HG-Akzeptierung und balancierte Bäume

Wir wollen nun zeigen, daß man im Fall von Halbgruppen-Akzeptierung wahlweise von balancierten oder unbalancierten Bäumen ausgehen kann. Dazu benötigen wir zunächst ein einfaches technisches Lemma:

4.11 Lemma. Es sei H = (S, ∘) eine endliche Halbgruppe mit |S| = n. Ferner seien a_{1}, …, a_{n+1} irgendwelche Elemente aus S. Wir definieren Elemente b_{i} ∈ S, (1 ≤ i ≤ n + 1) durch b_{i} =_{def} a_{1} ∘ … ∘ a_{i}. Dann gibt es ein j ∈ {1, …, n + 1} und ein d ∈ S mit b_{j} ∘ d = b_{j}.

Beweis. Da wir n + 1 Elemente b_{i} haben, aber nur n verschiedene Elemente in S, müssen nach dem Schubfachprinzip mindestens zwei b_{i}’s gleich sein, etwa b_{j} = b_{k} mit j < k. Dann setzen wir d = a_{j+1}∘… a_{k} und erhalten b_{j} = b_{k} = b_{j} ∘d wie behauptet. □

4.12 Satz. Es sei H_{α} ein HG-Akzeptanztyp. Dann gilt für die zugehörige reguläre Sprache L(H_{α}):

H_{α} · P = BalancedLeaf^{P}(L(H_{α})).

Beweis. Die Inklusion von rechts nach links ist trivial. Für die Richtung von links nach rechts nehmen wir eine Sprache A ∈ Leaf^{P}(L(H_{α})), d.h. es existiert eine poly-NTM M, die auf Eingabe x ein Blattwort w_{x} ∈ S(H)^{∗} erzeugt, so daß x ∈ A ⟺ w_{x} ∈ L(H_{α}). Die Rechenzeit von M sei beschränkt durch p(|x|) für ein Polynom p.

Wir können nun eine Maschine M′ konstruieren, die im wesentlichen wie M arbeitet. Zu Beginn setzt M′ eine Variable z auf den Wert 2^{p(|x|)}, zwei Werte l, r ∈ S(H) ∪ {ε} werden zunächst auf l = r = ε gesetzt. z (das ”Ziel“) soll immer anzeigen, wieviele Blätter der noch zu erzeugende Teilbaum haben soll, l und r sind zwei potentielle ”Offsets“, die noch links bzw. rechts an ein äußeres Blatt des erzeugten Baumes anzumultiplizieren sind. Vor einer Aufzweigung überprüft M′ immer, ob die Anzahl Blätter in jedem der beiden Teilbäume noch größer oder gleich n = |S(H)| ist. Es gibt dabei vier Fälle:

• Beide Teilbäume haben mehr als n Blätter. Dann simuliert M′ die Aufzweigung von M direkt. Dabei wird in der Simulation des linken Teilbaums l beibehalten, aber r auf ε gesetzt, entsprechend wird in der Simulation des rechten Teilbaums l auf ε gesetzt und r beibehalten. In beiden Teilbäumen wird z auf den Wert \frac{z}{2} gesetzt.

• Nur der linke Teilbaum hat mehr als n Blätter. Dann berechnet M′ zunächst alle Blattwerte des rechten Teilbaums, etwa a_{1}, …, a_{s} (mit s ≤ n) und simuliert dann nur den linken Teilbaum, wobei z und l beibehalten werden, r wird auf a_{1} ∘ … ∘ a_{s} ∘ r gesetzt.

• Nur der rechte Teilbaum hat mehr als n Blätter. Dieser Fall ist analog zum vorherigen, allerdings wird hier r beibehalten und l auf l ∘ a_{1} ∘ … ∘ a_{s} gesetzt.

• Beide Teilbäume haben höchstens n Blätter, zusammen haben sie aber mehr als n Blätter. Dann berechnet M′ alle Blätter a_{1} ∘ … ∘ a_{s} (mit n < s ≤ 2n). Wegen Lemma 4.11 kann man Elemente c, d und e finden mit a_{1} ∘…∘a_{s} = c∘d∘e und c∘d = c. Das Blattwort soll also denselben Wert bekommen wie l ∘ c ∘ e ∘ r, kann aber beliebig durch Einfügen von d’s nach dem c aufgepumpt werden (und falls nötig auch durch Ausmultiplizieren auf jeden Wert größer 0 geschrumpft werden). So kann M′ einen Teilbaum mit genau z Blättern und einem entsprechenden Blattwort erzeugen.

Auf diese Weise akzeptiert M′ genau dann, wenn auch M akzeptieren würde, aber M′ ist so konstruiert, daß immer ein voller binärer Baum erzeugt wird. □

4.13 Korollar. Zu jeder regulären Sprache L existiert eine reguläre Sprache L′ mit

Leaf^{P}(L) = Leaf^{P}(L′) = BalancedLeaf^{P}(L′).

Die Maschinen, die das balancierte Modell realisieren, können sogar immer so konstruiert werden, daß sie nur volle binäre Bäume erzeugen.

4.2. Klassen von endlichen Halbgruppen

Das nachfolgende Diagramm zeigt die Beziehungen zwischen den verschiedenen Klassen von endlichen Halbgruppen. Dabei ist eine Klasse in einer anderen Klasse enthalten, wenn es eine niemals abwärtsführende Verbindung von der kleineren zur größeren Klasse gibt.

Die Buchstaben H, M und G stehen für Halbgruppen, Monoide, Gruppen; die Indizes k, l, a, i haben die Bedeutung kommutativ, auflösbar, aperiodisch, idempotent (in dieser Reihenfolge).

[figure: G; G_{l}; G_{k}; M; M_{l}; M_{k}; H; H_{l}; H_{k}; M_{a}; M_{k,a}; M_{k,i}; H_{a}; H_{k,a}; H_{k,i}]

In den nachfolgenden Unterabschnitten werden wir zunächst die kommutativen endlichen Halbgruppen, dann die kommutativen aperiodischen und kommutativen idempotenten endlichen Halbgruppen, anschließend die endlichen Gruppen und schließlich endliche auflösbare und nichtauflösbare Halbgruppen untersuchen.

4.2.1. Kommutative Halbgruppen

Im Abschnitt 2.2.6 haben wir die Klasse C_{>0,≡0(2)}P eingeführt. Sie ist definiert über poly-NTM’s, die bei Eingaben aus der erkannten Sprache eine positive gerade Anzahl akzeptierender Pfade haben, bei allen anderen Eingaben eine ungerade Anzahl oder gar keinen akzeptierenden Pfad. Dieses Konzept einer ”verschobenen MOD-Klasse“ verallgemeinern wir wie folgt:

4.14 Definition. a, t und m seien natürliche Zahlen. Der Ausdruck a mod (t, m) beschreibt die Zahl a, falls a < t + m, bzw. t + (a − t) mod m, falls a ≥ t + m.

4.15 Definition. Es seien t, m ∈ IN und γ ⊆ {0, …, t + m − 1}. Die Klasse TMOD_{(t,m,γ)}P ist definiert als die Klasse aller Sprachen L, für die es eine poly-NTM M gibt mit der Eigenschaft, daß acc_{M}(x) mod (t, m) ∈ γ.

Mit dieser Definition gilt also C_{>0,≡0(2)}P = TMOD_{(1,2,{2})}P.

Wir werden nun zeigen, daß sich alle Klassen der Form H_{α} · P für endliche kommutative Halbgruppen H aus Klassen der Form TMOD_{(t,m,γ)}P zusammensetzen lassen. Dazu benötigen wir noch den Begriff des direkten Produkts zweier oder mehrerer endlicher Halbgruppen oder Monoide.

4.16 Definition.

• Es seien M_{1} und M_{2} zwei Monoide mit S(M_{i}) = S_{i} (i = 1, 2), wobei wir o.B.d.A. voraussetzen, daß S_{1} ∩ S_{2} = ∅. Das direkte Produkt M_{1} × M_{2} ist definiert als das Monoid M = (S, ∘) mit S = S_{1}×S_{2} und (s_{1}, s_{2})∘(t_{1}, t_{2}) = (φ_{M_{1}}(s_{1}, t_{1}), φ_{M_{2}}(s_{2}, t_{2})).

• Es seien M ein Monoid mit S(M) = S_{1} und H eine Halbgruppe mit S(H) = S_{2}, wobei wir o.B.d.A. voraussetzen, daß S_{1} ∩ S_{2} = ∅. Das direkte Produkt M × H ist definiert als die Halbgruppe H′ = (S, ∘) mit S = (S_{1} × S_{2}) ∪ S_{1}. Die Verknüpfung ∘ ist auch hier komponentenweise definiert, wobei nur vorhandene Komponenten in die Rechnung eingehen, z.B. (s_{1}, s_{2}) ∘ t_{1} = (φ_{M}(s_{1}, t_{1}), s_{2}) für s_{1}, t_{1} ∈ S_{1}, s_{2} ∈ S_{2}.

• Es seien H_{1} und H_{2} zwei Halbgruppen mit S(H_{i}) = S_{i} (i = 1, 2), wobei wir o.B.d.A. voraussetzen, daß S_{1} ∩ S_{2} = ∅. Das direkte Produkt H_{1} × H_{2} ist definiert als die Halbgruppe H = (S, ∘) mit S = S_{1} × S_{2} ∪ S_{1} ∪ S_{2}. Wieder wird die Verknüpfung komponentenweise definiert, dabei ist z.B. s_{1} ∘ s_{2} = (s_{1}, s_{2}) für s_{i} ∈ S_{i} (i = 1, 2).

Alle diese Definitionen lassen sich in kanonischer Weise auf den Fall von mehr als zwei Halbgruppen und/oder Monoiden verallgemeinern.

Eine von einem Element erzeugte Halbgruppe ist eine Halbgruppe H, in der ein Element a existiert, so daß es für alle s ∈ S(H) einen Exponent m > 0 gibt mit a^{m} = s. Ein von einem Element erzeugtes Monoid ist entsprechend definiert, nur daß noch das Element e hinzukommt. Die von einem Element erzeugten Halbgruppen bzw. Monoide spielen eine wesentliche Rolle bei der Charakterisierung der durch kommutative Halbgruppen erzeugbaren Komplexitätsklassen:

4.17 Lemma. Es sei H eine endliche kommutative Halbgruppe. Dann gibt es eine endliche Halbgruppe H′, die ein direktes Produkt von einem Element erzeugter Halbgruppen ist, und einen surjektiven Homomorphismus χ, der H′ auf H abbildet. Derselbe Sachverhalt gilt sinngemäß auch für Monoide.

Beweis. Es sei S(H) = {s_{1}, s_{2}, …, s_{r}} (bzw. im Monoidfall S(H) = {s_{1}, s_{2}, …, s_{r}, e}). Zu jedem s_{i} sei m_{i} die kleinste Zahl mit der Eigenschaft, daß ein n < m_{i} existiert, so daß s_{i}^{m_{i}} = s_{i}^{n}. Wir bilden die Halbgruppen H_{i} = (S_{i}, ∘) mit S_{i} = {s_{i}, s_{i}^{2}, …, s_{i}^{m_{i}−1}} (bzw. S_{i} = {e, s_{i}, s_{i}^{2}, …, s_{i}^{m_{i}−1}}), die Verknüpfung ∘ sei dieselbe wie in H. Schließlich definieren wir H′ als das direkte Produkt der Halbgruppen (bzw. Monoide) H_{i}. Die Abbildung χ: {s_{1}, …, s_{r}} → S(H) mit χ(s_{i}) = s_{i} (und gegebenenfalls χ(e) = e) läßt sich kanonisch zu einem Homomorphismus von H′ nach H fortsetzen und ist schon wegen χ(s_{i}) = s_{i} surjektiv. □

Nun geben wir eine spezielle Sorte von Halbgruppen und Monoiden an, deren Elemente k-Tupel von natürlichen Zahlen sind, die Verknüpfung erfolgt komponentenweise durch Addition mod (t, m):

4.18 Definition. Das Monoid M_{t,m,k} wird definiert durch S(M_{t,m,k}) = {(a_{1}, …, a_{k}) | ∀i: 0 ≤ a_{i} < t + m} und (a_{1}, …, a_{k}) ∘ (b_{1}, …, b_{k}) = ((a_{1} + b_{1}) mod (t, m), …, (a_{k} + b_{k}) mod (t, m)). Entsprechend definieren wir die Halbgruppe H_{t,m,k}, die sich vom Monoid M_{t,m,k} nur darin unterscheidet, daß das Element (0, …, 0) nicht zu S(H_{t,m,k}) gehört.

4.19 Lemma. Es sei H eine kommutative endliche Halbgruppe. Dann gibt es eine normierte Halbgruppe H_{t,m,k} und einen surjektiven Homomorphismus von H_{t,m,k} auf H. Dasselbe gilt sinngemäß für Monoide.

Beweis. Wir gehen davon aus, daß H schon direktes Produkt von einem Element erzeugter endlicher Halbgruppen ist, etwa der Halbgruppen H_{i} (1 ≤ i ≤ k). H_{i} sei von s_{i} erzeugt. Ferner seien t_{i} und m_{i} minimale positive Zahlen mit s_{i}^{t_{i}} = s_{i}^{t_{i}+m_{i}}. t sei das maximale unter den t_{i}, und m sei das kleinste gemeinsame Vielfache der m_{i}. Die Abbildung von H_{t,m,k} auf H mit (0, …, 0, 1, 0, …, 0) ↦ s_{i}, wenn die 1 im Vektor an der i-ten Stelle steht, läßt sich zu einem Homomorphismus fortsetzen. □

4.20 Korollar. Es sei H_{α} ein Halbgruppen-Akzeptanztyp mit kommutativer endlicher Halbgruppe H. Dann existiert ein Halbgruppenakzeptanztyp H′_{α′}, der dieselbe Komplexitätsklasse charakterisiert und für den es Zahlen t, m und k gibt mit H′ = H_{t,m,k}. Sinngemäß überträgt sich das auf Monoid-Akzeptanztypen.

Nun wollen wir zeigen, daß alle durch HG-Akzeptanztypen definierten Klassen H_{α} · P in durch Monoid-Akzeptanztypen definierte Klassen zerfallen:

4.21 Satz. Es sei H_{α} ein HG-Akzeptanztyp mit kommutativer endlicher Halbgruppe H. Dann existieren Monoid-Akzeptanztypen M_{α^{(1)}}^{(1)}, …, M_{α^{(r)}}^{(r)} mit kommutativen Monoiden und

H_{α} · P = M_{α^{(1)}}^{(1)} · P∨^{·} … ∨^{·} M_{α^{(r)}}^{(r)} · P.

Beweis. Nach Lemma 4.19 können wir davon ausgehen, daß H von der Form H_{t,m,k} für positive Zahlen t, m und k ist. Wir schreiben H_{t,m,k}^{(i)} für die Halbgruppe, die sich ergibt, wenn in der i-ten Komponente nur die Zahlen t, t+1, …, t+m−1 zugelassen sind. Die Menge α^{(i)} besteht entsprechend nur aus den k-Tupeln aus α, deren i-te Komponente mindestens t ist. Mit dieser Festlegung bildet H_{t,m,k}^{(i)} ein Monoid mit dem Einselement (0, …, 0, t + t_{0}, 0, …, 0), wobei der Eintrag t + t_{0} an der i-ten Stelle steht und t_{0} so gewählt wird, daß t + t_{0} durch m teilbar ist. Wir schreiben kurz M^{(i)} für H_{t,m,k}^{(i)} und behaupten,

daß H_{α} · P = M_{α^{(1)}}^{(1)} · P∨^{·} … ∨^{·} M_{α^{(r)}}^{(r)}.

Sei also L ∈ H_{α} · P, d.h. es gibt eine poly-NTM M, die bei Eingabe x ∈ L einen Baum erzeugt, dessen Blätter Elemente von S(H) sind, deren Produkt in α liegt; bei L ∉ H_{α} · P liegt das Produkt der Blätter außerhalb von α.

Wir definieren die Menge L_{i} so, daß alle Eingaben in L_{i} liegen, die zu L gehören und bei denen der von M erzeugte Baum entweder weniger als kt Blätter hat oder unter den ersten kt Blättern die i-te Komponente als erste mindestens t mal vorkommt. Per Definition sind alle L_{i} in L, es ist aber auch klar, daß die Vereinigung aller L_{i} schon ganz L ergibt und daß man in Polynomialzeit feststellen kann, welche Komponente für die Mitgliedschaft in L den Ausschlag gibt.

Für die Umkehrung seien Mengen L_{i} aus M_{α^{(i)}}^{(i)} · P gegeben. Ferner sei eine in Polynomialzeit berechenbare Funktion f mit Werten in {1, …, k} gegeben, so daß x ∈ L ⟺ x ∈ L_{f(x)}. Wir müssen zeigen, daß die Vereinigung der L_{i} in H_{α} · P liegt. Das ist aber klar, da ein Algorithmus zunächst deterministisch feststellen kann, welche Menge L_{i} entscheidend ist. Sodann wird der M_{α^{(i)}}^{(i)} · P-Algorithmus für die Eingabe direkt simuliert.

□

Der eben bewiesene Satz besagt, daß der Unterschied zwischen Halbgruppen-Akzeptanztypen und Monoid-Akzeptanztypen nicht allzu groß ist; jeder Monoid-Akzeptanztyp ist per Definition auch ein Halbgruppen-Akzeptanztyp, und jeder HG-Akzeptanztyp kann durch Monoid-Akzeptanztypen mit der Ptrennbaren Vereinigung ersetzt werden.

Die Normalform der Monoid-Akzeptanztypen mit Monoiden der Form M_{t,m,k} erlaubt uns die Klassifizierung aller durch kommutative Monoide charakterisierbaren Klassen:

4.22 Satz. Eine Klasse C ist genau dann durch einen Monoid-Akzeptanztyp mit einem kommutativen Monoid charakterisierbar, wenn sie eine schließlich periodische Anzahlklasse ist. Insbesondere gibt es dann Zahlen t und m und Mengen γ_{1}, …, γ_{k} mit

C = TMOD_{(t,m,γ_{1})}P∨^{·} … ∨^{·} TMOD_{(t,m,γ_{k})}P.

Beweis. Die Klasse sei definiert durch das Monoid M = M_{t,m,k} mit Akzeptierungsmenge α. Wir definieren eine Blattsprache L über dem Alphabet Σ = {0, …, k} durch die Festlegung w ∈ L ⟺ (|w|_{1} mod (t, m), …, |w|_{k} mod (t, m)) ∈ α. Diese Blattsprache hat offenbar die Eigenschaft, daß ihre Komponentenanzahlen, sobald sie den Wert t überschreiten, nur modulo m signifikant sind. Ebenso leicht sieht man, daß Leaf^{P}(L) = M_{α} · P gilt.

Die Tatsache, daß jede schließlich periodische Anzahlklasse durch einen kommutativen Monoid-Akzeptanztyp charakterisierbar ist, ist offensichtlich.

Schließlich entnehmen wir dem Beweis zu Satz 4.21, daß wir C in der angegebenen Art zerlegen können.

□

4.2.2. Kommutative aperiodische Halbgruppen

In diesem Unterabschnitt schränken wir die im vorigen Abschnitt untersuchten Halbgruppen ein auf den Fall, daß jedes Element die Periode 1 hat. Alle Aussagen des vorigen Abschnitts kann man sinngemäß auch für aperiodische endliche Halbgruppen beweisen. Insbesondere gilt das folgende Analogon zu Satz 4.21:

4.23 Satz. Es sei H_{α} ein HG-Akzeptanztyp mit kommutativer aperiodischer endlicher Halbgruppe H. Dann existieren Monoid-Akzeptanztypen M_{α^{(1)}}^{(1)}, …, M_{α^{(r)}}^{(r)} mit kommutativen aperiodischen endlichen Monoiden und

H_{α} · P = M_{α^{(1)}}^{(1)} · P∨^{·} … ∨^{·} M_{α^{(r)}}^{(r)} · P.

Weiter erhalten wir ebenso:

4.24 Satz. Eine Klasse C ist genau dann durch einen Monoid-Akzeptanztyp mit einem kommutativen aperiodischen Monoid charakterisierbar, wenn sie eine beschränkte Anzahlklasse ist. Insbesondere gibt es dann eine Zahl t und Mengen γ_{1}, …, γ_{k} mit

C = TMOD_{(t,1,γ_{1})}P∨^{·} … ∨^{·} TMOD_{(t,1,γ_{k})}P.

Im Kapitel 5 werden wir einen Algorithmus konstruieren, der uns zu zwei gegebenen beschränkten Anzahlklassen C_{1} und C_{2} effektiv die Frage beantwortet, ob es ein Orakel X gibt, für das C_{1}^{X} ⊈ C_{2}^{X}, oder ob in allen Relativierungen C_{1} ⊆ C_{2} gilt. Damit können wir für den Fall kommutativer aperiodischer endlicher Halbgruppen die Frage, welche Klassen durch entsprechende Akzeptanztypen charakterisierbar sind, als vollständig gelöst ansehen. Dieses Ergebnis ist das weitestgehende dieser Art, das bisher bekannt ist. Ein ähnlich umfassendes Resultat erhalten wir lediglich noch für den Fall der kommutativen Gruppen (vgl. Unterabschnitt 4.2.4), wo wir zeigen können, daß genau alle Klassen der Form TMOD_{(0,k,γ)}P charakterisierbar sind. Allerdings können wir für diesen Fall in manchen Fällen die Frage nach einem trennenden Orakel nicht beantworten.

4.2.3. Kommutative idempotente Halbgruppen

Auch für den Fall kommutativer idempotenter endlicher Halbgruppen können wir zunächst eine Vereinfachung wie im Abschnitt 4.2.1 durchführen. Wir erhalten:

4.25 Satz. Es sei H_{α} ein HG-Akzeptanztyp mit kommutativer idempotenter endlicher Halbgruppe H. Dann existieren Monoid-Akzeptanztypen M_{α^{(1)}}^{(1)}, …, M_{α^{(r)}}^{(r)} mit kommutativen idempotenten Monoiden und

H_{α} · P = M_{α^{(1)}}^{(1)} · P∨^{·} … ∨^{·} M_{α^{(r)}}^{(r)} · P.

Weiter erhalten wir ebenso:

4.26 Satz. Eine Klasse C ist genau dann durch einen Monoid-Akzeptanztyp mit einem kommutativen idempotenten Monoid charakterisierbar, wenn sie eine beschränkte Anzahlklasse mit Schranke 1 ist. Insbesondere gibt es dann Mengen γ_{1}, …, γ_{k} mit

C = TMOD_{(1,1,γ_{1})}P∨^{·} … ∨^{·} TMOD_{(1,1,γ_{k})}P.

Man beachte hierbei, daß TMOD_{(1,1,γ)}P für alle γ entweder eine triviale Klasse oder NP oder coNP beschreibt.

Der letzte Satz zeigt insbesondere, daß alle durch kommutative idempotente Monoide charakterisierbaren Klassen in der booleschen Hierarchie über NP liegen. Wir zeigen nun, daß jede solche Klasse genau gleich einer Klasse der booleschen Hierarchie über NP ist und daß alle Klassen der Hierarchie tatsächlich so charakterisierbar sind.

4.27 Satz. C sei eine durch ein kommutatives idempotentes Monoid charakterisierbare Klasse. Dann existiert eine Zahl k so, daß entweder C = NP(k) oder C = coNP(k) gilt. Für jede der Klassen NP(k) und coNP(k) gibt es ein entsprechendes kommutatives idempotentes Monoid.

Beweis. C sei durch das Monoid M charakterisiert. Die Konstruktion von Lemma 4.19 liefert uns ein Monoid der Form M_{1,1,r} und einen surjektiven Homomorphismus von diesem Monoid auf M. Die Akzeptierungsmenge zu M sei α. Dann gilt mit der Akzeptierungsmenge α′, die aus allen Elementen in M_{1,1,r} besteht, die unter dem Homomorphismus nach α abgebildet werden, die Gleichheit C = M′_{α′} mit M′ = M_{1,1,r}. Nun sei L eine Sprache in C, dann existiert eine poly-NTM, die bei jeder Eingabe einen Baum mit Blättern der Form (a_{1}, …, a_{r}) erzeugt, wobei die a_{i} jeweils 0 oder 1 sind. Die Mitgliedschaft in der Menge L wird dann anhand der Frage entschieden, für welche i es ein Blatt gibt, bei dem die i-te Komponente 1 ist. Definieren wir die NP-Mengen L_{i} so, daß jede Eingabe zu L_{i} gehört, bei der mindestens ein Blatt erzeugt wird, das in der i-ten Komponente eine 1 hat, so ist L eine boolesche Kombination dieser L_{i}. Diese Kombination ist unabhängig von der Maschine, d.h. wir haben eine boolesche Formel, mit der wir aus beliebigen NP-Mengen eine Menge in C bilden können. Folglich ist C eine Klasse in der booleschen Hierarchie, und nach [87] von der Form NP(k) oder coNP(k).

Umgekehrt kann man jede boolesche Formel auf k Mengen aus NP ohne weiteres durch das kommutative idempotente Monoid M_{1,1,k} mit einer entsprechenden Akzeptierungsmenge realisieren. □

Im kommutativ idempotenten Fall kann man schon mit Monoiden alle Klassen charakterisieren, die man mit allgemeinen Halbgruppen definieren kann. Das sehen wir in Verbindung mit dem eben bewiesenen Satz wie folgt:

4.28 Satz. C sei eine durch eine kommutative idempotente endliche Halbgruppe charakterisierbare Klasse. Dann existiert eine Zahl k so, daß entweder C = NP(k) oder C = coNP(k) gilt. Für jede der Klassen NP(k) und coNP(k) gibt es eine entsprechende kommutative idempotente endliche Halbgruppe.

Beweis. O.B.d.A. sei C durch die Halbgruppe H = H_{1,1,r} charakterisiert. Die Akzeptierungsmenge sei α. Wir benutzen die Mind-Change Technik [11]. Die Menge der r-Tupel über {0, 1} sei wie folgt geordnet: (a_{1}, …, a_{r}) ≤ (b_{1}, …, b_{r}), falls für alle i gilt a_{i} ≤ b_{i}. Sind überdies die beiden Vektoren ungleich, so schreiben wir (a_{1}, …, a_{r}) < (b_{1}, …, b_{r}). Es sei v_{1} < … < v_{k} eine längste Kette solcher Vektoren mit v_{i} ∈ α ⟺ v_{i+1} ∉ α, (i = 1, …, k − 1). Wir können hierbei v_{k} = (1, …, 1) wählen und v_{1} = (0, …, 0, 1, 0, …, 0) mit der 1 in der j-ten Komponente. Ferner nehmen wir an, daß v_{1} ∉ α gilt, der andere Fall ist analog zu behandeln.

Nun setzen wir α_{j} so, daß alle Elemente von α mit j-ter Komponente gleich 1 zu α_{j} gehören, und darüberhinaus sollen alle (a_{1}, …, a_{j−1}, 0, a_{j+1}, …, a_{r}) mit (a_{1}, …, a_{j−1}, 1, a_{j+1}, …, a_{r}) ∈ α zu α_{j} gehören. Mit dieser Festlegung können wir in der Halbgruppe H das Element (0, …, 0, 1, 0, …, 0) (die 1 in der j-ten Komponente) wie ein Einselement benutzen, ohne die Klasse H_{α_{j}} · P zu ändern, d.h. es gilt H_{α_{j}} ·P = M_{α_{j}} ·P = coNP(k). Andererseits gilt sicher H_{α_{j}} ·P ⊆ H_{α}·P, also haben wir coNP(k) ⊆ H_{α} · P.

Andererseits gilt H_{α} · P ⊆ M_{α} · P. Die längste Kette in M bezüglich α hat aber wegen v_{1} ∉ α und (0, …, 0) ∉ α auch nur die Länge k, so daß gilt M_{α} · P = coNP(k). Also folgt H_{α} · P = coNP(k).

Die Existenz einer Halbgruppe für jede Klasse der booleschen Hierarchie folgt natürlich aus der Existenz eines Monoids für dieselbe Klasse. □

Wir sehen an diesem Beweis, daß man durch Betrachten der Ketten immer effektiv feststellen kann, welche Klasse der booleschen Hierarchie durch eine kommutative idempotente Halbgruppe charakterisiert werden kann. Da bekannt ist, welche Klassen dieser Hierarchie von welchen durch Orakel getrennt werden können, haben wir unabhängig vom allgemeineren Fall der kommutativen aperiodischen Halbgruppen hier eine vollständige Lösung des Charakterisierbarkeitsproblems.

4.2.4. Gruppen

Wir beginnen mit dem Fall der kommutativen endlichen Gruppen. Wir können Lemma 4.19 anwenden und erhalten eine Halbgruppe der Form H = H_{0,k,r}, d.h. eine Gruppe, die direktes Produkt von r zyklischen Gruppen der Ordnung k ist. Wir untersuchen zunächst den Fall |α| = 1, d.h. wie bei der ursprünglichen Definition der LDA-Typen wird nur ein Akzeptierungswert zugelassen. Dann besteht die Klasse H_{α} · P aus allen Mengen, die sich als Durchschnitt von r Mengen aus coMOD_{k}P darstellen lassen; solche Durchschnitte sind aber wieder in coMOD_{k}P. Damit haben wir gezeigt:

4.29 Lemma. Es sei H eine kommutative Gruppe in Normalform, α eine Akzeptierungsmenge mit |α| = 1. Dann existiert ein k mit H_{α} · P = coMOD_{k}P.

Da nun jede Akzeptierungsmenge sich als Vereinigung solcher Mengen mit einem Element schreiben läßt, ergibt sich:

4.30 Satz. Es sei H eine kommutative Gruppe, α eine Akzeptierungsmenge. Dann existieren Zahlen k und r, so daß

H_{α} · P ⊆ ⋁_{(r)} coMOD_{k}P.

Dabei bedeutet diese Schreibweise, daß jede Menge der linken Seite sich als Vereinigung von r Mengen aus coMOD_{k}P schreiben läßt.

Nun wollen wir untersuchen, was man im Fall auflösbarer endlicher Gruppen über die Struktur der entsprechenden Klassen sagen kann. Dabei beschränken wir uns jeweils auf den Fall eines Akzeptierungswertes. Die spezielle Wahl des Akzeptierungswertes ist dann offenbar unerheblich, da man aufgrund der Invertierbarkeit in einer Gruppe immer durch Anhängen eines Blattes jeden Wert auf einen beliebigen Wert abbilden kann. Wir gehen allgemein vom Einselement als Akzeptierungselement aus und beginnen mit einem allgemeinen Sachverhalt über Faktorisierungen:

4.31 Lemma. Es sei G eine Gruppe mit Normalteiler U. Die Faktorgruppe sei H = G/U. Dann gilt

G · P ⊆ U · P^{H·P[2]}.

Beweis. Es sei M eine Maschine, in deren Blättern Werte gu mit g ∈ G und u ∈ U ausgegeben werden, wobei für jedes Element der Faktorgruppe nur ein festes g benutzt wird. Dabei sei für das Element U der Faktorgruppe der Vertreter e gewählt. Das Blattwort hat dann die Form

g_{1}u_{1}g_{2}u_{2} … g_{s}u_{s}.

Eine U · P-Maschine überprüft zunächst durch eine Orakelfrage, ob das Produkt g_{1}g_{2} … g_{s} in H gleich e ist (falls nicht, wird einfach ein nicht akzeptierender Wert produziert und die Arbeit beendet), und arbeitet dann wie M. Wenn aber auf dem i-ten Pfad der Wert g_{i}u_{i} ausgegeben werden soll, dann ”rät“ die Maschine zunächst, welchen Wert das Produkt g_{1}g_{2} … g_{i} in H hat und verifiziert den Wert durch eine Frage an das H · P -Orakel. War der Wert falsch geraten, so gibt die Maschine das Blatt e aus, andernfalls dasjenige u′_{i}, für das g_{1}g_{2} … g_{i}u_{i} = u′_{i}g_{1}g_{2} … g_{i} gilt. Damit haben wir einen Baum erzeugt, dessen Blätter u′_{1}u′_{2} … u′_{s} die Eigenschaft haben, daß g_{1}u_{1}g_{2}u_{2} … g_{s}u_{s} = u′_{1}u′_{2} … u′_{s}g_{1}g_{2} … g_{s} gilt. Folglich akzeptiert die Maschine genau dann, wenn auch M akzeptiert, da ja g_{1}g_{2} … g_{s} = e gelten muß. □

Mit Hilfe dieses Lemmas erhalten wir den folgenden Satz:

4.32 Satz. Es sei G eine auflösbare Gruppe der Ordnung k. Dann gibt es eine Primfaktorzerlegung von k, k = p_{1} ·p_{2} ·. . .·p_{r} mit nicht notwendig verschiedenen Primfaktoren p_{i}, so daß G · P ⊆ MOD_{p_{1}} · MOD_{p_{2}} · . . . · MOD_{p_{r}}P gilt.

Beweis. Jede auflösbare Gruppe läßt sich so sukzessive zerlegen, daß die auftretenden Faktorgruppen von Primzahlordnung sind. Damit sind die Orakel jeweils durch entsprechende coMOD_{p}P-Klassen zu ersetzen. Man muß sich nun nur noch überlegen, daß man die zwei Fragen an das Orakel, die auf jedem Pfad der oben beschriebenen Simulation gestellt werden, durch zwei erst zum Schluß gestellte Fragen ersetzen kann. Schließlich muß man bedenken, daß die coMOD_{p}P-Klassen für Primzahl p immer abgeschlossen gegen Durchschnitt, Vereinigung und Komplement sind. Das überträgt sich auch auf Klassen der Form MOD_{p_{i}} · MOD_{p_{i+1}} · . . . · MOD_{p_{r}}P. □

Eine genauere Klassifizierung der durch auflösbare Gruppen charakterisierbaren Klassen ist kompliziert. Insbesondere gilt mit hoher Wahrscheinlichkeit nicht, daß allein die Dekomposition entsprechend der Auflösbarkeitsbedingung die Klasse eindeutig definiert. Wir sehen das an folgenden Beispielen:

Beispiel 1. Die folgende Gruppe G_{1} mit 21 Elementen repräsentiert die Klasse MOD_{7} · MOD_{3}P:

G_{1} = {a^{i}b^{j} | 0 ≤ i ≤ 2, 0 ≤ j ≤ 6} mit

a^{i}b^{j} ∘ a^{k}b^{l} = a^{(i+k) mod 3}b^{(2^{k}j+l) mod 7}.

Insbesondere gilt also ba = ab^{2}.

Nach Satz 4.32 und dem zugehörigen Beweis wissen wir schon, daß G · P ⊆ MOD_{7} · MOD_{3}P, denn die Gruppe G_{1} hat einen Normalteiler mit 7 Elementen und einer Faktorgruppe mit 3 Elementen. Wir müssen zeigen, daß auch die Umkehrung gilt. Man beachte hierzu, daß man die MOD_{3}-Berechnungen mit dem Buchstaben a durchführen kann. Zur Übersetzung wählen wir den Ausdruck (xb)^{15}. Es gilt für x = e, a, a^{2}: (eb)^{15} = b^{15} = b, (ab)^{15} = ((ab)^{3})^{5} = e^{5} = e und (a^{2}b)^{15} = ((a^{2}b)^{3})^{5} = e^{5} = e. Also können wir eine MOD_{7} ·MOD_{3}P Berechnung direkt simulieren, wenn aber von der MOD_{7}-Berechnung auf eine MOD_{3}-Frage umgeschaltet wird, erzeugen wir 30 Zweige, auf denen mit ungerader Nummer simulieren wir die MOD_{3}-Berechnung so, daß im positiven Fall e erscheint, andernfalls a oder a^{2}, die Zweige mit gerader Nummer geben das Blatt b aus.

Beispiel 2. Die Gruppe G_{2} mit 42 Elementen repräsentiert die Klasse MOD_{7} · MOD_{6}P:

G_{2} = {a^{i}b^{j} | 0 ≤ i ≤ 5, 0 ≤ j ≤ 6} mit

a^{i}b^{j} ∘ a^{k}b^{l} = a^{(i+k) mod 6}b^{(3^{k}j+l) mod 7}.

Insbesondere gilt also ba = ab^{3}.

Der Beweis ist ganz analog zu dem obigen.

Beispiel 3. Die Gruppe G = G_{3} mit 42 Elementen repräsentiert die Klasse (MOD_{7} · MOD_{3}P) ∧ MOD_{6}P:

G_{3} = {a^{i}b^{j} | 0 ≤ i ≤ 5, 0 ≤ j ≤ 6} mit

a^{i}b^{j} ∘ a^{k}b^{l} = a^{(i+k) mod 6}b^{(2^{k}j+l) mod 7}.

Insbesondere gilt also ba = ab^{2}.

Hier ist die Richtung (MOD_{7} ·MOD_{3}P)∧MOD_{6}P ⊆ G·P klar, da wir unter ausschließlicher Verwendung von a jede MOD_{6}-Berechnung simulieren können und ähnlich wie in Beispiel 1 Berechnungen in MOD_{7} ·MOD_{3}P durchführen können. Dabei kann die letztere Berechnung so eingerichtet werden, daß der Wurzelwert immer eine Potenz von b ist, die MOD_{6}-Berechnung kann so gemacht werden, daß der Wurzelwert immer eine Potenz von a ist. Also ist auch eine Menge im Durchschnitt der beiden Klassen akzeptierbar.

Für die Umkehrung überlegen wir uns zunächst das folgende: die Wirkung von a auf Werte b beim ”Vorbeiziehen“ ist dieselbe wie im Beispiel 1. Wenn wir also von der Gruppe aus Beispiel 1 ausgehen, können wir schon überprüfen, ob die entstehende b-Potenz verschwindet. Zusätzlich können wir einfach durch ignorieren der b’s in MOD_{6}P feststellen, ob die Anzahl der a’s durch 6 teilbar ist. Da sich die a-Potenz beim Sortieren des Blattworts nach a’s und b’s nicht ändert, können wir also in (MOD_{7} · MOD_{3}P) ∧ MOD_{6}P feststellen, ob die G · P-Maschine akzeptiert.

Man prüft leicht nach, daß die b-Potenzen auch in G_{3} einen Normalteiler der Ordnung 7 bilden und daß die Faktorgruppe eine zyklische Gruppe der Ordnung 6 ist.

Nun haben wir noch den Fall der nichtauflösbaren Gruppen zu untersuchen. Wir benötigen einen weiteren Satz aus der Algebra. Zur Vorbereitung geben wir die folgende Definition:

4.33 Definition. Es sei G eine Gruppe, a, b seien Elemente von G, die Verknüpfung in G sei ∘. Dann heißt das Element a∘b∘a^{−1}∘b^{−1} der Kommutator von a und b. Die kleinste Untergruppe von G, die alle Kommutatoren enthält heißt Kommutator-Untergruppe.

Damit gilt der folgende Satz:

4.34 Satz. Eine Gruppe G ist genau dann nicht auflösbar, wenn sie eine Untergruppe U hat (|U| > 1), deren Kommutator-Untergruppe gleich U ist.

Damit können wir den folgenden Satz beweisen, der erstmals in [43] erschien:

4.35 Satz. Es sei G eine nicht auflösbare Gruppe. Dann gilt G·P = PSPACE.

Beweis. Es sei U eine Untergruppe von G, die gleich ihrer Kommutator-Untergruppe ist. Wir zeigen, daß U · P = PSPACE gilt, woraus dann natürlich die Behauptung des Satzes folgt.

Wir können jedes Element von U als ein Produkt von Kommutatoren schreiben. Zu jedem u ∈ U mit u ≠ e (e das Einselement der Gruppe) existiert also ein kürzester Ausdruck a_{1}b_{1}a_{1}^{−1}b_{1}^{−1}a_{2}b_{2}a_{2}^{−1}b_{2}^{−1} … a_{r}b_{r}a_{r}^{−1}b_{r}^{−1} mit

u = a_{1}b_{1}a_{1}^{−1}b_{1}^{−1}a_{2}b_{2}a_{2}^{−1}b_{2}^{−1} … a_{r}b_{r}a_{r}^{−1}b_{r}^{−1}.

Nun simulieren wir eine alternierende Maschine M, die nur mit universellen Konfigurationen und mit negierenden Konfigurationen arbeitet, wie folgt durch eine U-Maschine M′:

Wir wollen zeigen, daß wir einen beliebigen (Teil-) Baum der Berechnung von M mit einem gegebenen ”Zielwert“ u ∈ U (u ≠ e) so simulieren können, daß der Wurzelwert u wird, falls wir einen akzeptierenden Teilbaum simulieren, e, sonst. Wir führen eine Induktion über die Tiefe des zu simulierenden Baumes durch:

Die Tiefe des Baumes sei 0. Dann ist die Ausgangskonfiguration bereits eine Endkonfiguration. Ist sie akzeptierend, so erzeugen wir ein Blatt mit Wert u, andernfalls eines mit Wert e.

Für den Induktionsschritt sei u ein bestimmtes Element von U mit u ≠ e. Ferner sei c die gegebene Konfiguration von M. Diese ist entweder eine universelle Konfiguration mit Nachfolgern c_{1} und c_{2} oder eine negierende Konfiguration mit Nachfolger c_{1}. Wir untersuchen zunächst den Fall einer negierenden Konfiguration. Hier erzeugen wir einen nichtdeterministischen Schritt, in dessen linkem Nachfolger wir die Konfiguration c_{1} annehmen und den Zielwert u^{−1} geben, im rechten Nachfolger erzeugen wir ein Blatt mit Wert u. Wird nun der Zielwert im linken Teilbaum erreicht, d.h. die Nachfolgekonfiguration c_{1} in M ist akzeptierend, so erreichen wir in der Simulation den Wurzelwert u^{−1} ∘ u = e, ist sie dagegen ablehnend, so erreichen wir den Wurzelwert e ∘ u = u, wie gefordert.

Nun bleibt der Fall einer universellen Konfiguration zu klären: Wir nehmen an, u sei durch das Produkt u = a_{1}b_{1}a_{1}^{−1}b_{1}^{−1} … a_{r}b_{r}a_{r}^{−1}b_{r}^{−1} dargestellt. Dann verzweigen wir auf 4r verschiedenen Nachfolgekonfigurationen. Dabei wird für den (4i−3)-ten Zweig die Konfiguration c_{1} weitergegeben, allerdings mit Zielwert a_{i} (i = 1, …, r), an den (4i − 1)-ten Zweig wird auch die Konfiguration c_{1} weitergegeben, aber mit Zielwert a_{i}^{−1}. Entsprechend wird an den (4i − 2)-ten Zweig die Konfiguration c_{2} mit Zielwert b_{i} weitergegeben und an den (4i)-ten Zweig c_{2} mit Zielwert b_{i}^{−1}. Nun sieht man sofort, daß bei akzeptierenden Teilbäumen sowohl für c_{1} als auch für c_{2}, wenn also nach Induktionsvoraussetzung jeweils die Zielwerte erreicht werden, sicherlich der Wert des zu c gehörenden Knotens genau u wird. Ist c_{1} aber ein Knoten, dessen Teilbaum ablehnend ist, so gehen wir nach Induktionsvoraussetzung vom Wurzelwert e in allen Zweigen mit Nummern (4i − 3) oder (4i − 1) aus, d.h. wir erhalten entweder eb_{1}eb_{1}^{−1} … eb_{r}eb_{r}^{−1} als Knotenwert für den zu c gehörenden Teilbaum (wenn c_{2} akzeptierend ist) oder ein Produkt von 4i Kopien von e (wenn c_{2} auch ablehnend ist), in jedem Fall also den Wurzelwert e. Das gleiche gilt natürlich, wenn c_{2} ablehnend und c_{1} akzeptierend ist, analog. Damit ist der Satz bewiesen. □

4.2.5. Auflösbare und nichtauflösbare Halbgruppen

Für nichtauflösbare endliche Halbgruppen folgt aus dem entsprechenden Ergebnis für nichtauflösbare Gruppen bereits, daß die entsprechende Klasse PSPACE sein muß. Für beliebige auflösbare endliche Halbgruppen wollen wir zunächst zeigen, daß alle nichttrivialen Klassen, die durch eine Halbgruppe charakterisierbar sind, bereits den NP-, coNP-, oder einen MOD_{k}P-Mechanismus beinhalten:

4.36 Lemma. Es sei H_{α} ein HG-Akzeptanztyp. Die Berechnungen einer H_{α}- Maschine können so normiert werden, daß in den Blättern bis auf das letzte Blatt nur Elemente a vorkommen, die erweiterbar sind, d.h. für die ein Element c existiert mit a ∘ c = a.

Beweis. Nach dem Beweis zu Satz 4.12 kann der Halbgruppen-Akzeptanztyp o.B.d.A. so gewählt werden, daß für jede akzeptierte Sprache eine Maschine existiert, die auf jeder Eingabe nur volle binäre Bäume produziert. Wir nehmen an, daß die Halbgruppe r Elemente hat und wählen eine Zweierpotenz, die größer als r ist, etwa 2^{r}. Bei jeder Eingabe, die einen Baum mit weniger als 2^{r} Blättern erzeugen würde, kann die Maschine künstlich den Baum vergrößern (wenn es keine großen ablehnenden oder keine großen akzeptierenden Bäume gibt, ist die charakterisierte Klasse trivial!). Nun können wir die Blätter also in Gruppen der Länge 2^{r} einteilen. In solchen Gruppen gibt es immer einen Anfangsabschnitt der Länge s < 2^{r}, etwa a_{1}a_{2} … a_{s}, so daß ein Element b existiert mit a_{1} ∘a_{2} ∘…∘a_{s} ∘b = a_{1} ∘a_{2} ∘…∘a_{s}. Wir setzen a = a_{1} ∘a_{2} ∘…∘a_{s} und a′ = a_{s+1} ∘ … ∘ a_{2^{r}}. Nach diesen Vorbereitungen können wir die folgende Simulation der gegebenen Maschine konstruieren:

Die neue Maschine simuliert direkt die Originalmaschine, bis sie einen Knoten erreicht, der Wurzel eines Teilbaums mit genau 2^{r} Blättern ist. Nun ermittelt die Simulation alle 2^{r} Blätter dieses Teilbaums und auch alle 2^{r} Blätter des links benachbarten Teilbaums derselben Tiefe (falls ein solcher existiert). Der links benachbarte Teilbaum zerfalle nach obigem Mechanismus in die Teile a und a′, der direkt erreichte Teilbaum in b und b′. Dann gibt die Simulation das Element a′ ∘ b aus. Befinden wir uns ganz links im Baum (d.h. es existiert kein links benachbarter Teilbaum), so gibt die Simulation einfach b aus (da a′ nicht existiert). Befinden wir uns ganz rechts im Baum (d.h. es existiert kein rechts benachbarter Teilbaum), so gibt die Simulation a′ ∘ b ∘ b′ aus, da sonst der Teilwert b′ unter den Tisch fallen würde. Die beschriebene Simulation erzeugt ein Blattwort, das in der Halbgruppe ausgewertet denselben Wert ergibt, wie das von der ursprünglichen Maschine produzierte Blattwort, das aber bis auf das letzte Symbol nur erweiterbare Elemente ausgibt. □

Nun können wir einen alternativen Beweis des Ergebnisses von Borchert [19] geben:

4.37 Satz. Die Komplexitätsklasse C sei durch eine reguläre Blattsprache definiert. Es gebe ein Orakel, das C von P trennt. Dann enthält C eine der Klassen NP, coNP oder eine MOD-Klasse. Diese Inklusionsrelation ist relativierbar.

Beweis. Die Klasse C ist nach Satz 4.10 durch einen HG-Akzeptanztyp charakterisierbar. Nach dem eben bewiesenen Lemma können wir davon ausgehen, daß bei der Berechnung stets bis auf das letzte Blattsymbol nur erweiterbare Elemente der Halbgruppe ausgegeben werden. Wir nehmen zunächst an, daß es ein erweiterbares Element a, Elemente x und y (x und y dürfen auch leer sein) und eine Zahl i > 1 gibt mit xay ∈ α ⟺ xa^{i}y ∉ α. Wir betrachten die Reihe xay, xa^{2}y, …, deren Zugehörigkeit zu α schließlich periodisch werden muß. Da aber weder alle diese Werte zu α, noch alle nicht zu α gehören, muß entweder eine MOD-Klasse oder NP oder coNP mit einem Algorithmus simulierbar sein, der auf den Randblättern x ∘ a (links) bzw. y (rechts) ausgibt, dazwischen für akzeptierende Pfade ein a und für ablehnende Pfade eine neutrale Erweiterung von a. Diese Simulation ist relativierbar. Von jetzt an gehen wir also davon aus, daß für alle erweiterbaren Elemente a und alle (evtl. leeren) x und y gilt:

xay ∈ α ⟺ ∀i > 1: xa^{i}y ∈ α.

Nun nehmen wir zusätzlich an, daß in der Halbgruppe für alle a, b, c_{1}, c_{2} und d, die bis auf b alle erweiterbar sind, gilt:

a ∘ c_{1} ∘ d ∘ b ∈ α ⟺ a ∘ c_{2} ∘ d ∘ b ∈ α.

In diesem Fall ist C = P, und diese Gleichheit ist relativierbar. Das widerspricht unserer Annahme. Folglich existieren solche Werte mit a ∘ c_{1} ∘ d ∘ b ∈ α und a ∘ c_{2} ∘ d ∘ b ∉ α. Wir nehmen an, daß a ∘ d ∘ b ∉ α, der andere Fall verläuft ganz analog. Wir betrachten alle Werte der Form a ∘ x ∘ d ∘ b, wo x ein Produkt von Werten c_{1} und d in beliebig gemischter Reihenfolge ist. Wir behaupten, daß a ∘ x ∘ d ∘ b zu α gehört genau dann, wenn mindestens ein c_{1} vorkommt. Daß es nur dann zu α gehören kann, folgt daraus, daß a ∘ d^{i} ∘ d ∘ b ∈ α ⟺ a ∘ d ∘ b ∈ α, was nach Annahme nicht der Fall ist. Andererseits können wir ähnlich in einem Ausdruck, in dem in x mindestens ein c_{1} vorkommt, alle mehrfachen Vorkommen von c_{1} zu einem zusammenschmelzen, ebenso alle mehrfachen Vorkommen von d. Nun erhalten wir a ∘ (c_{1} ∘ d)^{i} ∘ b für ein i > 0, aber auch (c_{1} ∘ d) ist ein erweiterbares Element, also können mehrfache Vorkommen hiervon auch zu einem zusammengefaßt werden, und wir erhalten a ∘ c_{1} ∘ d ∘ b, und das ist ein Element von α. Also haben wir eine relativierbare Simulation von NP zur Verfügung. □

Als letzte Aussage über auflösbare endliche Halbgruppen geben wir die folgende obere Schranke an, die in [43] bewiesen wurde:

4.38 Satz. Es sei H_{α} ein HG-Akzeptanztyp mit einer auflösbaren Halbgruppe H. Dann gilt H_{α} · P ⊆ MOD-PH.

Beweis. Zunächst wollen wir uns überlegen, daß es genügt, den Sachverhalt für auflösbare Monoide zu zeigen. Es gilt nämlich für jede auflösbare Halbgruppe H, daß H_{α} · P ⊆ M_{α}^{H} · P, wenn M^{H} das Monoid bezeichnet, das aus H durch Hinzufügen eines Einselements entsteht.

In [72] wird gezeigt, daß die durch auflösbare Monoide beschreibbaren regulären Sprachen durch endlichoftmalige Anwendung von booleschen Operatoren, Konkatenation und den Operatoren mod_{q,i} aus höchstens einelementigen Mengen entstehen. Dabei ist der Operator mod_{q,i} auf zwei Sprachen L_{1} und L_{2} wie folgt definiert:

mod_{q,i}(L_{1}, L_{2}) = {x ∈ Σ^{∗} | |{(y, z): x = yz ∧ y ∈ L_{1} ∧ z ∈ L_{2}}| ≡ i mod q}

Da die Klasse H_{α} · P durch die Blattsprache L(H_{α}) definiert ist, genügt es, die folgenden Zusammenhänge zwischen Blattsprachen und den dazugehörigen Leaf-Klassen zu beweisen:

1) Leaf^{P}(A ∪ B) ⊆ Leaf^{P}(A) ∨ Leaf^{P}(B).

2) Leaf^{P}(\overline{A}) = co-Leaf^{P}(A).

3) Leaf^{P}(A · B) ⊆ ∃(Leaf^{P}(A) ∧ Leaf^{P}(B)).

4) Leaf^{P}(mod_{q,i}(A, B)) ⊆ coMOD_{q}(Leaf^{P}(A) ∧ Leaf^{P}(B)).

Diese Inklusionen sind aber allesamt direkt durch Anwendung der Definitionen zu beweisen. Nun bemerken wir noch, daß höchstens einelementige Mengen als Blattsprachen nur Teilklassen von P charakterisieren können. Dadurch ergibt sich durch Induktion, daß eine Sprache, die durch Vereinigung, Komplementbildung, Konkatenation oder mod_{q,i} aus solchen Mengen hervorgeht als Blattsprache sicher auch nur Mengen in MOD-PH erzeugen kann, da keiner der Operatoren ∨, co-, ∧, ∃ oder coMOD_{q} aus MOD-PH herausführt. □

Orakelseparationen

Nun wenden wir uns der Frage zu, wann zwei durch lokal definierbare Akzeptanztypen charakterisierbare Komplexitätsklassen durch ein Orakel voneinander getrennt werden können. In der Vergangenheit wurden zahlreiche Orakelresultate verschiedenster Art bewiesen (z.B. [1, 14, 15, 22, 50, 66, 68, 88], um nur einige zu nennen).

Ein Kriterium zur Trennung gewisser durch Anzahl-Blattsprachen definierbarer Komplexitätsklassen wurde in [29] entwickelt. Unser Kriterium geht in den meisten Fällen deutlich über dieses hinaus. Allerdings gibt es Fälle, in denen auch bei nichtbeschränkten Anzahlsprachen mit dem in [29] bewiesenen Kriterium eine Trennung erhalten wird, die wir aber mit unserem Ansatz nicht so direkt bearbeiten können.

Wir wollen für eine nichttriviale Menge von Komplexitätsklassen einen Algorithmus entwickeln, der zu zwei gegebenen Klassen entscheidet, ob sie durch ein Orakel separiert werden können oder nicht. Dazu bedienen wir uns eines Resultates, das wir das BCS-Theorem nennen wollen.

5.1. Der Satz von Bovet, Crescenzi und Silvestri

Das wichtigste Werkzeug, das wir in diesem Kapitel zur Trennung von Komplexitätsklassen benutzen wollen, ist der Satz von Bovet, Crescenzi und Silvestri [17, 18].

5.1.1. Das BCS-Theorem

Wir benötigen dazu die folgenden Definitionen, in denen mehrfach Berechnungen in polylogarithmischer Zeit benutzt werden. Wir gehen bei solchen Berechnungen grundsätzlich davon aus, daß die Eingabebits durch Angabe der Adresse auf einem Indexband abgefragt werden können, da andernfalls bei großen Eingaben immer nur ein kurzes Präfix für das Ergebnis der Berechnung ausschlaggebend sein könnte.

5.1 Definition. Eine Funktion f: Σ^{∗} → Δ^{∗} heißt plt-Funktion, wenn es Zahlen c und k gibt, so daß folgendes gilt:

• Die Länge von f(x) ist in Zeit c · log^{k}(|x|) berechenbar.

• Es gibt einen Algorithmus, der bei Eingabe (x, i) mit 0 ≤ i < |f(x)| das i-te Bit von f(x) in Zeit c · log^{k}(|x|) berechnet.

5.2 Definition.

a) Die Sprache A ⊆ Σ^{∗} heißt plt-reduzierbar auf B ⊆ Δ^{∗}, in Zeichen A ≤_{m}^{plt} B, falls es eine plt-Funktion f: Σ^{∗} → Δ^{∗} gibt mit x ∈ A ⟺ f(x) ∈ B.

b) Das Paar (A, R) von Sprachen A, R ⊆ Σ^{∗} mit A ∩ R = ∅ heißt pltreduzierbar auf das Paar (B, S) von Sprachen B, S ⊆ Δ^{∗} mit B ∩ S = ∅, in Zeichen (A, R) ≤_{m}^{plt} (B, S), falls es eine plt-Funktion f: Σ^{∗} → Δ^{∗} gibt mit x ∈ A ⟺ f(x) ∈ B und x ∈ R ⟺ f(x) ∈ S.

Nun können wir das folgende Theorem formulieren:

5.3 Satz (Bovet, Crescenzi, Silvestri).

a) Es sei C_{1} = BalancedLeaf^{P}(A) und C_{2} = BalancedLeaf^{P}(B). Dann gilt A ≤_{m}^{plt} B genau dann, wenn für alle Orakel X gilt C_{1}^{X} ⊆ C_{2}^{X}.

b) Es sei C_{1} = BalancedLeaf^{P}(A, R) und C_{2} = BalancedLeaf^{P}(B, S). Dann gilt (A, R) ≤_{m}^{plt} (B, S) genau dann, wenn für alle Orakel X gilt C_{1}^{X} ⊆ C_{2}^{X}.

5.1.2. Ein Beispiel

Wir wollen als Beispiel für die Anwendung des BCS-Theorems zeigen, daß es ein Orakel X gibt mit ⊕P^{X} ⊈ NP^{X}. Die Klasse ⊕P kann mit der Blattsprache A = {w ∈ {0, 1}^{∗} | |w|_{1} ist ungerade} definiert werden, d.h. BalancedLeaf^{P}(A) = ⊕P. Ebenso gilt BalancedLeaf^{P}(B) = NP mit der Blattsprache B = {w ∈ {0, 1}^{∗} | |w|_{1} > 0}.

Behauptung: A ≰_{m}^{plt} B.

Beweis. Zum Beweis dieser Behauptung stellen wir uns vor, es gäbe eine plt-Reduktion f, die A auf B reduziert. Wir wählen n so, daß 2c · log^{k} n < n gilt. Nun muß gelten, daß f(10^{n−1}) zu B gehört, da ja 10^{n−1} in A ist. Das heißt, in f(10^{n−1}) kommt mindestens eine 1 vor, etwa an Position i. Nun verbrauchen sowohl die Berechnung der Länge von f(10^{n−1}), als auch die Berechnung des iten Bits von f(10^{n−1}) lediglich c·log^{k} n < n viele Rechenschritte, also können sie auch jeweils höchstens c · log^{k} n < n verschiedene Eingabebits verarbeiten. Bei diesen beiden Berechnungen werden also maximal 2c · log^{k} n < n viele Bits der Eingabe beachtet. Es gibt also ein Bit, das wir ändern können, so daß sich weder die Länge des Bildes noch dessen i-tes Bit ändern. Damit bleibt das Bild in der Menge B, obwohl bei Änderung genau eines Bits der Eingabe 10^{n−1} sich die Eingabe nicht mehr in A befindet. Das ist ein Widerspruch zur Annahme, daß f eine Reduktion von A auf B realisiert. Damit ist die Behauptung bewiesen. □

Aus dieser Behauptung folgt aber durch direkte Anwendung des Satzes 5.3, daß es ein Orakel gibt, das ⊕P von NP trennt.

5.2. Die Hypergraphenmethode

5.2.1. Definitionen

5.4 Definition. Mit [n] bezeichnen wir die Menge [n] = {1, …, n}. Entsprechend ist [n] × [r] die Menge der Paare (a, b) mit 1 ≤ a ≤ n, 1 ≤ b ≤ r. Dabei bezeichnen wir die Menge {(a, k) | 1 ≤ a ≤ n} für festes k (1 ≤ k ≤ r) mit [n] × {k} und nennen sie die k-Sorte von [n] × [r].

Für Teilmengen I ⊆ [n] × [r] werden wir manchmal den Vektor (t_{1}, …, t_{r}) als ”Größe“ von I bezeichnen, wenn |I ∩ ([n] × {j})| = t_{j} für alle j (1 ≤ j ≤ r). Gelegentlich wollen wir die Mengen [n · r] und [n] × [r] als identisch ansehen. Wir rechtfertigen das formal, indem wir die folgenden Abbildungen immer als vorgegeben voraussetzen: Für r ≥ 1 definieren wir σ_{r}: IN → [r] durch σ_{r}(n) = 1 + (n − 1) mod r und π_{r}: IN → IN durch π_{r}(n) = 1+(n−1) div r. Die dadurch auf gewissen Abschnitten [n] von IN induzierten Abbildungen nennen wir ebenfalls σ_{r} und π_{r}. Damit ist die Abbildung φ: [m · r] → [m] × [r] definiert durch φ(n) = (π_{r}(n), σ_{r}(n)) eine Bijektion. Wenn die Zahlen r und n vorgegeben sind, können wir zu einer beliebigen Menge I ⊆ [n] das Wort x_{I} ∈ {0, …, r}^{n} definieren durch die Festlegung x_{I} = z_{1}z_{2} … z_{n}, wobei z_{j} = 0, falls j ∉ I, und z_{j} = σ_{r}(j) für alle j ∈ I. Der Begriff ”Hypergraph“ wird in der Literatur auf verschiedene Weisen definiert. Wir wollen diesen noch eine neue hinzufügen durch folgende Vereinbarungen:

5.5 Definition. Ein Hypergraph auf n Elementen ist eine Funktion H: 2^{[n]} → IN. Die Elemente der Menge [n] heißen Knoten. Eine Menge X ⊆ [n] mit H(X) > 0 heißt Hyperkante der Ordnung H(X).

Der Name Hypergraph rührt daher, daß man sich die Knotenmenge als Punkte in der Ebene aufzeichnen kann, und dann jede Teilmenge, die eine Hyperkante der Ordnung k darstellt, k-mal einkreisen kann. Das folgende Bild veranschaulicht den Fall n = 4, H({1, 2}) = 1, H(∅) = 2, H({2, 3, 4}) = 2, H(X) = 0 in allen anderen Fällen:

[figure: 3; 1; 2; 4]

Wir werden auch abzählbar unendliche Reihen von Hypergraphen betrachten, wobei für jede Knotenzahl genau ein Hypergraph benötigt wird:

5.6 Definition. Eine Hypergraph-Sequenz, auch kurz H-Sequenz, ist eine Folge (H_{n})_{n∈IN} von Hypergraphen, wobei H_{n} ein Hypergraph auf n Elementen sein soll. Die Hypergraph-Sequenz (H_{n}) heißt gleichmäßig, wenn es eine Funktion f: IN → IN gibt mit H_{n}(X) = f(|X|) für alle n ∈ IN und X ⊆ [n].

Wir wollen auch Hypergraphen definieren, in denen es mehrere Sorten von Knoten bzw. Kanten gibt:

5.7 Definition. Ein (r, s)-Hypergraph auf r · n Elementen ist eine Funktion H: 2^{[n]×[r]} → IN^{s}. Die Elemente der Menge [n] × [r] heißen Knoten. Dabei nennen wir Elemente von [n] × {k} auch Knoten von der Sorte k. Eine Menge X ⊆ [n] × [r] mit H(X) = (h_{1}, …, h_{s}) ≠ (0, …, 0) heißt Hyperkante der Ordnung (h_{1}, …, h_{s}).

Da wir bei gegebenem r die Mengen [n · r] und [n] × [r] auf kanonische Weise bijektiv aufeinander abbilden können, werden wir auch Funktionen von 2^{[n·r]} nach IN^{s} als (r, s)-Hypergraphen bezeichnen.

Analog zur Veranschaulichung der einfachen Hypergraphen, kann man sich einen (r, s)-Hypergraphen dadurch aufzeichnen, daß man in r voneinander räumlich getrennten Teilen die r·n Knoten in die Ebene setzt und dann in s verschiedenen Farben jede Teilmenge X genau h_{j}-mal in der Farbe j einkreist, wenn H(X) = (h_{1}, …, h_{s}).

Auch hier wollen wir wieder Sequenzen und gleichmäßige Sequenzen definieren:

5.8 Definition. Eine (r, s)-H-Sequenz ist eine Folge (H_{n})_{n∈IN} von (r, s)- Hypergraphen, wobei H_{n} ein (r, s)-Hypergraph auf r · n Elementen sein soll. Die (r, s)-H-Sequenz (H_{n}) heißt gleichmäßig, wenn es eine Funktion f: IN^{r} → IN^{s} gibt mit H_{n}(X) = f(|X ∩ ([n] × {1})|, …, |X ∩ ([n] × {r})|) für alle n ∈ IN und X ⊆ [n] × [r].

Die Hypergraphen und (r, s)-Hypergraphen induzieren jeweils noch eine weitere Funktion, in der wir auf einer Menge X die Ordnungen aller in X enthaltenen Kanten aufaddieren:

5.9 Definition. Es sei H ein Hypergraph oder ein (r, s)-Hypergraph. Dann definieren wir die Funktion \overline{H} durch

\overline{H}(X) = ∑_{Y ⊆X} H(Y).

5.2.2. Die Monotonie-Bedingung

Die Hypergraphen wollen wir benutzen, um Aussagen über gewisse Funktionen (nämlich über plt-Reduktionen) machen zu können. Dazu benötigen wir die folgende Definition:

5.10 Definition. Eine Funktion f: {0, …, r}^{∗} → {0, …, s}^{∗} erfüllt die m-n-Monotonie-Bedingung (m ≡ 0 mod r), wenn eine Menge J ⊆ [n] mit |J| = m existiert, so daß die folgenden Bedingungen erfüllt sind:

• ∀j (1 ≤ j ≤ r) |J ∩ σ_{r}^{−1}(j)| = \frac{m}{r}

• ∀i ∀I_{1}, I_{2} ⊆ J:

[f(x_{I_{1}})_{i} = k > 0 ∧ I_{1} ⊆ I_{2} ⟹ f(x_{I_{2}})_{i} = k] ∧
[f(x_{I_{1}})_{i} = k > 0 ∧ f(x_{I_{2}})_{i} = k ⟹ f(x_{I_{1}∩I_{2}})_{i} = k]

Die Menge J nennen wir ein Monotoniegebiet der Größe m.

In Worten gesagt heißt das, wenn man eine genügend große Eingabelänge annimmt, dann gibt es eine Menge J in der Menge der Indizes in die Eingabe, die m Indizes umfaßt (und zwar von jeder Sorte gleich viele), mit der Eigenschaft: wenn man nur Eingaben betrachtet, die außerhalb von J nur Null-Bits haben und innerhalb von J nur Bits mit Wert 0 oder dem durch die Sorte vorgegebenen Wert, dann gibt es zu jedem Bit des Bildes eine gewisse Teilmenge von J so, daß das Bildbit genau dann einen von 0 verschiedenen Wert hat, wenn alle Bits, die zu dieser Teilmenge von J in der Eingabe gehören, den von 0 verschiedenen Wert haben. Dadurch wird also jedem Ausgabebit eine Teilmenge von J eindeutig zugeordnet.

Das folgende Lemma folgt ganz trivial aus dieser Definition:

5.11 Lemma.

1) Zu jeder Funktion f: {0, 1}^{∗} → {0, 1}^{∗}, die die m-n-Monotonie-Bedingung erfüllt, existiert ein Hypergraph H auf m Elementen, der die folgende Eigenschaft hat:

(∗) Wenn J ein Monotoniegebiet der Größe m ist, dann gibt es eine Bijektion φ zwischen J und der Menge [m] mit

|f(x_{I})|_{1} = \overline{H_{m}}(φ(I))

für jedes I ⊆ J.

2) Zu jeder Funktion f: {0, …, r}^{∗} → {0, …, s}^{∗}, die die m-n-Monotonie-Bedingung erfüllt, existiert ein (r, s)-Hypergraph H auf r · \frac{m}{r} Elementen, der die folgende Eigenschaft hat:

(∗) Wenn J ein Monotoniegebiet der Größe m zu f ist und φ eine Bijektion zwischen J und der Menge [\frac{m}{r}] × [r], die alle Elemente der Sorte k nach [\frac{m}{r}] × \{k\} abbildet, dann gilt

(|f(x_{I})|_{1}, …, |f(x_{I})|_{s}) = \overline{H}(φ(I))

für alle Mengen I ⊆ J.

5.2.3. plt-Reduktionen in Normalform

Grundsätzlich sind die Funktionen, die eine plt-Reduktion realisieren, in der Lage, durchaus in komplizierter Weise auf die Eingabe zuzugreifen, insbesondere auch abhängig von den schon gelesenen Bits erst zu entscheiden, welche weiteren Bits gelesen werden. Auch kann die Länge des Bildwortes stark variieren, sie muß ja nur in polylogarithmischer Zeit berechenbar sein.

Für viele Zwecke ist es einfacher, wenn man von einer Normalform ausgehen kann. Dazu definieren wir zunächst:

5.12 Definition. Eine Funktion f: Σ^{∗} → Δ^{∗} ist eine normale polylog-Funktion, wenn es ein Polynom p gibt mit |f(x)| = 2^{p(log |x|)} für alle x ∈ Σ^{+} und wenn für festes n das i-te Bit von f(x) (wobei |x| = n und i ∈ [2^{p(log |x|)}]) nur von p(log n) vielen Bits der Eingabe abhängt. Die Funktion f heißt normale polylog-Reduktions-Funktion von A auf B, wenn darüberhinaus x ∈ A ⟺ f(x) ∈ B gilt.

5.13 Definition. Eine plt-Reduktion f heißt in Normalform, wenn sie eine normale polylog-Reduktions-Funktion ist.

Wir zeigen nun, daß man in vielen interessanten Fällen die plt-Reduktion in dieser Form wählen kann:

5.14 Lemma. Es sei A ≤_{m}^{plt} B vermöge der plt-Funktion f, wobei B ⊆ {0, …, s}^{∗}. Ferner gelte für alle Wörter x, y ∈ {0, …, s}^{∗}, daß xy ∈ B ⟺ x0y ∈ B. Dann existiert auch eine plt-Reduktion f′ in Normalform, die A auf B reduziert.

Beweis. Zunächst können wir die Funktion f in eine Funktion f_{1} umwandeln, die die Eigenschaft hat, daß sie immer Wörter der vollen Länge 2^{c·log^{k}(|x|)} bei Eingabe x erzeugt, indem für jedes i (1 ≤ i ≤ 2^{c·log^{k}(|x|)}) zunächst die Länge von f(x) berechnet wird. Dann wird bei i ≤ |f(x)| einfach die Berechnung des i-ten Bits von f(x) simuliert, während bei i > |f(x)| eine 0 ausgegeben wird. Es gilt also f_{1}(x) = f(x)0^{2^{c·log^{k}(|x|)}−|f(x)|} und damit f_{1}(x) ∈ B ⟺ f(x) ∈ B. f_{1} ist eine plt-Reduktion, die immer Wörter voller Länge produziert.

Nun entwerfen wir die Funktion f_{2} wie folgt: es gibt für jedes i mit 1 ≤ i ≤ 2^{c·log^{k}(|x|)} einen Block von t Bits, wobei die Zahl t genau die Anzahl der verschiedenen Teilmengen I von {1, …, n} mit |I| ≤ c · log^{k}(|x|) ist. Wir nehmen eine feste Numerierung dieser Mengen von 1 bis t als gegeben an. Das j-te Bit des i-ten Blocks von f_{2}(x) wird nun wie folgt berechnet: die j-te Teilmenge von {1, …, n} sei I_{j}. Es werden zunächst genau die Bits von x, deren Nummern zu I_{j} gehören, gelesen. Dann wird versucht, die Berechnung des i-ten Bits von f_{1}(x) zu simulieren, wobei aber nur die gelesenen Bits verwendet werden dürfen. Gelingt das, und werden auch alle Bits aus I_{j} tatsächlich bei der Simulation gelesen, dann wird die Ausgabe f_{1}(x)_{i} produziert, andernfalls eine 0. Offenbar wird in jedem Block bei genau einer Berechnung tatsächlich das i-te Bit von f_{1}(x) produziert und sonst nur Nullen. Da nach Voraussetzung die eingestreuten Nullen die Mitgliedschaft in B nicht verändern, folgt f_{2}(x) ∈ B ⟺ f_{1}(x) ∈ B. f_{2} ist auch eine plt-Reduktion und erfüllt die Bedingungen des Lemmas. □

Nun bleibt für konkrete Anwendungen der Hypergraphenmethode noch folgendes zu leisten:

1) Finde für zwei zu trennende Klassen C_{1} und C_{2} jeweils eine Blattsprache A bzw. B mit BalancedLeaf^{P}(A) = C_{1} und BalancedLeaf^{P}(B) = C_{2}.

2) Zeige, daß für alle x und y gilt xy ∈ B ⟺ x0y ∈ B.

3) Zeige, daß zu jeder plt-Reduktion von A auf B in Normalform eine normale polylog-Reduktions-Funktion von A auf B existiert, die für gewisse Paare (m, n) die m-n-Monotonie-Bedingung erfüllt.

4) Zeige, daß die hierdurch induzierten Hypergraphen nicht existieren können.

5.2.4. Erste Anwendung der Hypergraphenmethode

Wir werden das Programm des letzten Unterabschnitts in den nächsten Abschnitten an vielen wichtigen Fällen durchführen. Jetzt wollen wir aber zunächst zwei interessante und charakteristische Beispiele geben:

Beispiel 1. Wir wollen die Schritte 1), 2) und 4) exemplarisch für den folgenden Fall zeigen. Schritt 3) ist zu aufwendig – wir verschieben ihn daher auf den nächsten Abschnitt, wo er allgemein für eine ganze Klasse von Sprachpaaren (A, B) gezeigt wird.

Wir wählen die Klasse C_{1}, die aus allen Sprachen bestehen sollen, die durch poly-NTM’s akzeptiert werden mit der Akzeptierungsbedingung ”Anzahl akzeptierender Pfade ist entweder 3 oder 4“. Die Klasse C_{2} soll ähnlich aus allen Sprachen bestehen, die durch poly-NTM’s akzeptiert werden mit der Akzeptierungsbedingung ”Anzahl akzeptierender Pfade ist entweder 2 oder 3“. Man sieht leicht, daß C_{1} durch die Blattsprache

A = 0^{∗}10^{∗}10^{∗}10^{∗} ∪ 0^{∗}10^{∗}10^{∗}10^{∗}10^{∗}

definiert wird. Ebenso wird C_{2} durch die Blattsprache

B = 0^{∗}10^{∗}10^{∗} ∪ 0^{∗}10^{∗}10^{∗}10^{∗}

definiert. Damit ist Schritt 1) gelöst und, wie man durch Betrachten der Sprache B sofort feststellt, auch Schritt 2). Da wir Schritt 3) ja auf den nächsten Abschnitt verschieben wollen, nehmen wir nun an, wir hätten schon eine normale polylog-Reduktions-Funktion von A auf B, die die 6-n-Monotonie-Bedingung für irgendein n erfüllt. Nun bleibt zu zeigen, daß der induzierte Hypergraph nicht existieren kann.

Bei der Untersuchung des Hypergraphen sprechen wir der Einfachheit halber von k Kanten, wenn H(I) = k > 0 für eine Menge I gilt.

Der Hypergraph hätte die folgende Eigenschaft: wenn man ein Teilgebiet mit 3 oder 4 Knoten auswählt, dann gibt es darin genau 2 oder 3 Kanten. Wählt man ein Teilgebiet mit mehr als 4 Knoten aus, so gibt es darin mindestens 4 Kanten. Wählt man schließlich ein Teilgebiet mit weniger als 3 Knoten aus, so gibt es darin höchstens eine Kante.

Nehmen wir an, der Hypergraph hätte eine Kante der Größe 0, d.h. H(∅) > 0. Es muß aber gelten, daß H(∅) < 2, da wir sonst in einem Teilgebiet mit weniger als 3 Knoten mehr als eine Kante hätten, also H(∅) = 1. Nun müßten alle anderen Kanten mindestens die Größe 3 haben. Also müßte auch jede (!) mögliche Kante der Größe 3 mindestens einmal vorhanden sein. Dann wären aber in jedem Teilgebiet der Größe 4 schon mindestens 5 Kanten im Widerspruch zur Voraussetzung.

Wir können also davon ausgehen, daß es keine Kante der Größe 0 gibt. Nehmen wir an, es gäbe zwei Kanten der Größe 1, dann würden die beiden betreffenden Knoten zusammen ein Gebiet der Größe 2 mit mindestens zwei Kanten darstellen. Ein solches darf nicht existieren, also gibt es maximal eine Kante der Größe 1. Es bleibt also jedenfalls ein Teilgebiet der Größe 5, das weder eine Kante der Größe 0 noch eine Kante der Größe 1 hat.

Nun nehmen wir an, es gäbe zwei Kanten der Größe 2. Dabei sind drei mögliche Fälle zu betrachten: wir haben zweimal dieselbe Kante, oder die zwei Kanten überschneiden sich in einem Punkt oder die zwei Kanten überschneiden sich gar nicht. Im ersten Fall haben wir sofort wieder einen Widerspruch, da es dann ein Gebiet der Größe 2 mit zwei Kanten gäbe. Im Fall der sich überschneidenden Kanten haben wir folgende Situation:

[figure: c; a; b; d]

Das Drei-Punkte-Gebiet (b, c, d) muß nach Voraussetzung mindestens zwei Kanten beherbergen, also haben wir im Vier-Punkte-Gebiet (a, b, c, d) mindestens vier Kanten, im Widerspruch zur Voraussetzung. Es bleibt also nur noch der dritte Fall, in dem folgende Situation vorliegt:

[figure: c; a; b; d]

Hier ist klar, daß jedes der Gebiete (a, b, c), (a, b, d), (a, c, d) und (b, c, d) mindestens noch eine weitere Kante haben muß. Diese Kanten können nicht alle identisch sein, da die einzige mögliche in allen diesen Gebieten enthaltene Kante die Kante der Größe 0 wäre, von der wir schon wissen, daß sie nicht vorhanden ist. Also müssen mindestens zwei weitere Kanten im Gebiet (a, b, c, d) liegen, was aber zu einer Gesamtzahl von mindestens vier Kanten führen würde.

Nun wissen wir also, daß in unserem Gebiet der Größe 5 keine Kanten der Größen 0 oder 1 und höchstens eine Kante der Größe 2 vorhanden ist. Durch Wegnahme eines geeigneten Punktes erhalten wir dann ein Gebiet der Größe 4, in dem keine Kante der Größe kleiner als 3 vorhanden ist. Nun sollen aber in jedem Gebiet der Größe 3 mindestens zwei Kanten vorkommen, die also genau die Größe 3 haben müssen. Wir haben vier solche Teilgebiete, also insgesamt acht Kanten in unserem Vier-Punkte-Gebiet. Das ist ein Widerspruch zur Annahme, und folglich kann der gewünschte Hypergraph nicht existieren.

Also wissen wir, daß ein Orakel X existiert mit C_{1}^{X} ⊈ C_{2}^{X}.

Beispiel 2. Nun wollen wir zeigen, daß es ein Orakel X gibt, so daß NP^{X} ⊈ ⊕P^{X}. Man beachte, daß wir im Abschnitt 5.1.2 die Umkehrung gezeigt haben, d.h. die Klassen NP und ⊕P können in beiden Richtungen getrennt werden.

Wir beschreiben NP durch die Blattsprache A = {0, 1}^{∗}1{0, 1}^{∗} und ⊕P durch die Blattsprache B = (0^{∗}10^{∗}10^{∗})^{∗}. Wir haben auch hier bereits durch diese Definition die Aufgaben 1) und 2) gelöst. Zur Aufgabe 3): Man kann leicht eine gegebene normale polylog-Reduktions-Funktion, die A auf B reduziert, wie folgt abändern: würde bei einer gewissen Berechnung die Menge I von Eingabebits gelesen, um ein Ausgabebit zu erzeugen, so werden jetzt 2^{|I|} Ausgabebits erzeugt, und zwar für jede Teilmenge I′ von I eines. Dabei nehmen wir zunächst jeweils an, I′ sei genau die Teilmenge von I mit der Eigenschaft, daß alle Eingabebits in I′ den Wert 1 und alle Eingabebits in I \ I′ den Wert 0 haben. Wir testen sodann, ob es stimmt, daß alle Eingabebits in I′ den Wert 1 haben. Wenn nein, dann geben wir eine 0 aus. Wenn ja, so berechnen wir, wieviele Teilmengen von I′ wiederum fälschlicherweise den Wert 1 produziert haben. Ist diese Zahl ungerade, so geben wir genau dann eine 1 aus, wenn die ursprüngliche Reduktion eine 0 ausgegeben hätte. Ist aber die Anzahl der fälschlich durch Teilmengen von I′ ausgegebenen 1-Bits gerade, so geben wir genau denselben Wert aus, wie die ursprüngliche Reduktions-Funktion. Durch diesen Mechanismus geben wir modulo 2 genau so viele 1-Bits aus wie die ursprüngliche Reduktions-Funktion. Also haben wir wieder eine Reduktions-Funktion von A auf B, die aber offenbar auf der gesamten Eingabelänge monoton ist. Durch diese Monotonie auf der gesamten Eingabe erhalten wir einen entsprechenden Hypergraphen mit polylogarithmischer Kantengröße, der die Abbildung A auf B wiederspiegelt.

Nun brauchen wir nur noch zu zeigen, daß es für große n keinen Hypergraphen mit polylogarithmischer Kantengröße geben kann, für den \overline{H}(∅) ≡ 1 mod 2 und \overline{H}(X) ≡ 0 mod 2 für alle X ≠ ∅ gilt. Das sehen wir daraus, daß wir induktiv für alle k-elementigen Mengen X zeigen können, daß aus der obigen Bedingung folgt: H(X) ≡ 1 mod 2. Das ist aber ein Widerspruch zur Bedingung, daß die Kantengröße polylogarithmisch beschränkt ist, da für große n also die Kantengröße kleiner als n sein muß, und folglich für X = [n] nicht gelten kann: H(X) ≡ 1 mod 2.

Für k = 0 ist H(X) = H(∅) ≡ 1 mod 2 nach Voraussetzung. Nun sei X eine Menge mit |X| = k > 0. Dann hat X genau 2^{k} − 1 echte Teilmengen Y, die alle nach Induktionsvoraussetzung einen Wert H(Y) ≡ 1 mod 2 haben. Die Summe dieser Werte ist wieder ungerade, so daß, da ja die Summe über alle Teilmengen (einschließlich X selbst) gerade sein muß, folgt: H(X) ≡ 1 mod 2. Damit ist die Behauptung bewiesen, und wir folgern, daß es keine plt-Reduktion von A auf B geben kann, d.h. es existiert ein Orakel X mit NP^{X} ⊈ ⊕P^{X}.

5.3. Separation von beschränkten Anzahlklassen

In Abschnitt 4.2.2 haben wir gesehen, daß beschränkte Anzahlklassen genau die sind, die durch ein endliches kommutatives aperiodisches Monoid beschreibbar sind. Wir wollen nun einen Algorithmus entwickeln, der uns von zwei gegebenen beschränkten Anzahlklassen entscheidet, ob es ein trennendes Orakel gibt oder nicht. Es seien also Zahlen m, r > 0 und eine Menge α ⊆ {0, …, m}^{r} gegeben. Dann ist die Klasse C_{1} = BalancedLeaf^{P}(A) eine beschränkte Anzahlklasse, wobei A = {w ∈ {0, …, r}^{∗} | (max(|w|_{1}, m), …, max(|w|_{r}, m)) ∈ α} ist. Ferner seien Zahlen m′, s > 0 und eine Menge α′ ⊆ {0, …, m′}^{s} gegeben. Dann ist die Klasse C_{2} = BalancedLeaf^{P}(B) eine beschränkte Anzahlklasse, wobei B = {w ∈ {0, …, s}^{∗} | (max(|w|_{1}, m′), …, max(|w|_{s}, m′)) ∈ α′} ist.

Für die Klassen C_{1} und C_{2} ist die Aufgabe 1) unseres Programms aus Abschnitt 5.2.3 bereits erfüllt, da wir die Klassen direkt über Blattsprachen definiert haben. Aufgabe 2) ist erfüllt, da wir grundsätzlich nur die Vorkommen der von 0 verschiedenen Symbole zählen müssen, um Mitgliedschaft in A bzw. B zu entscheiden. Für die Anwendbarkeit der Methode müssen wir also noch die Aufgabe 3) erfüllen. Das werden wir in 5.3.1 tun. Aufgabe 4) wird dann nach der Erläuterung des dafür notwendigen Ramsey-Theorems in 5.3.2 im Unterabschnitt 5.3.3 gelöst.

5.3.1. Anwendbarkeit der Hypergraphenmethode

Die Mengen A und B seien wie oben angegeben durch die Zahlen m und r und die Menge α bzw. m′, s und die Menge α′ definiert. f sei eine plt-Reduktion von A auf B in Normalform. Wir wollen zeigen, daß es dann eine normale polylog-Reduktions-Funktion f′ von A auf B gibt, die für jedes n die m-n-Monotonie-Bedingung erfüllt, wobei m die kleinste durch r teilbare Zahl ist, die größer oder gleich log log n ist. Wir müssen dafür zunächst die Funktion so abändern, daß niemals mehr als m′ viele Ausgabebits den Wert i haben (1 ≤ i ≤ s), bei deren Berechnung genau dieselben Eingabebits mit von Null verschiedenen Werten gelesen werden. Wir tun das so: Wenn die Funktion f mehr als m′ solche Ausgabebits erzeugt, dann erzeugt die neue Funktion f′ nur die ersten m′ dieser Ausgabebits, die übrigen Ausgabebits, die unter f den Wert i haben, erhalten unter f′ den Wert 0. Damit zerstören wir unter Umständen die plt-Berechenbarkeit, die Funktion f′ ist aber immer noch eine normale polylog-Reduktions-Funktion von A auf B, da ja die Zugehörigkeit des Bildes zu B ohnehin nur von der Häufigkeit der Symbole bis zum Wert m′ abhängt.

Es sei nun k die kleinste durch r teilbare Zahl, die größer oder gleich log log n ist. Das Argument ist ein Abzählargument. Wir setzen die Bijektion φ: [r · n] → [n] × [r] voraus. Dann zählen wir ab, wieviele J ⊆ [r · n] mit |J| = r · k und |φ(J) ∩ ([n] × {i})| = k für alle i ∈ {1, …, r} es bei genügend großem n geben kann, die die Monotonie-Bedingung verletzen. Sind das weniger als es insgesamt solche Teilmengen J gibt (also weniger als \binom{n}{k}^{r}), dann muß es also eine Teilmenge J der gewünschten Größe geben, die die Monotonie-Bedingung erfüllt.

Wir nehmen irgendeine Menge I mit |φ(I)∩([n]×{i})| ≤ k für alle i ∈ {1, …, r} und rechnen aus, wieviele Mengen J mit |φ(J) ∩ ([n] × {i})| = k für alle i ∈ {1, …, r} einen Widerspruch zur Monotonie-Bedingung durch diese Menge I bekommen könnten.

Behauptung: Wenn für alle I ⊆ J gilt, daß bei der Berechnung der von 0 verschiedenen Ausgabesymbole von f(x_{I}) keine Eingabe-Adressen in J \ I benutzt werden, dann ist die Monotonie-Bedingung mit der Menge J erfüllt.

Beweis. Es seien I_{1} und I_{2} Teilmengen von J mit I_{1} ⊆ I_{2} und f(x_{I_{1}})_{i} = k > 0. Da bei der Berechnung von f(x_{I_{1}})_{i} keine Eingabeadressen aus J \ I benutzt werden, sich I_{1} und I_{2} aber nur an diesen Stellen unterscheiden können, gilt auch f(x_{I_{2}})_{i} = k. Nun sei f(x_{I_{1}})_{i} = k > 0, f(x_{I_{2}})_{i} = k und f(x_{I_{1}∩I_{2}})_{i} = k′ ≠ k. Wir nehmen zunächst an, daß k′ > 0 ist. Dann würde aber aus I_{1} ∩ I_{2} ⊆ I_{1} nach dem ersten Teil dieses Beweises folgen, daß auch f(x_{I_{1}})_{i} = k′ wäre. Das ist ein Widerspruch zur Annahme f(x_{I_{1}})_{i} = k. Also kann höchstens noch gelten f(x_{I_{1}∩I_{2}})_{i} = 0. Wir betrachten die Berechnung von f(x_{I_{1}∪I_{2}})_{i}: Bei dieser Berechnung können keine Eingabeadressen aus I_{1} \ I_{2} benutzt werden, da sonst bei der Berechnung von f(x_{I_{2}})_{i} diese auch benutzt würden. Ebenso können keine Eingabeadressen aus I_{2} \I_{1} benutzt werden. Also werden nur Eingabeadressen aus I_{1} ∩I_{2} oder außerhalb von J benutzt. Dann ergibt sich aber bei der Berechnung von f(x_{I_{1}∩I_{2}})_{i} dasselbe Ergebnis wie bei der von f(x_{I_{1}})_{i}, also k im Widerspruch zur Annahme.

□

Eine Menge J kann also nur als mögliches Monotonie-Gebiet ausscheiden, wenn es eine Teilmenge I ⊆ J gibt, so daß bei der Berechnung der von 0 verschiedenen Ausgabesymbole von f(x_{I}) mindestens eine Eingabeadresse aus J \ I benutzt wird. Zu einer festen Menge der Größe k′ < r · k gibt es weniger als

\binom{r · n}{r · k − k′ − 1} · s · 2^{k′} · polylog n

viele Mengen J, die von dieser Menge ausgeschieden werden. Mengen J, die von I ausgemustert werden, müssen Obermengen von I sein. Dadurch sind k′ Elemente von J schon festgelegt. Der erste Faktor des genannten Produkts kommt daher, daß wir alle außer einem der noch zu wählenden Elemente (um I zu J zu erweitern) frei wählbar lassen. Lediglich ein Element darf nur unter denen gewählt werden, die bei der Eingabe x_{I} für ein von Null verschiedenes Bildsymbol gelesen werden. Nun kann es aber nicht mehr als s · 2^{k′} viele von Null verschiedene Bildsymbole geben und für jedes werden höchstens polylogarithmisch viele Eingabebits gelesen. Das erklärt den Faktor s · 2^{k′} · polylog n. Es gibt aber nur \binom{r·n}{k′} viele verschiedene Mengen der Größe k′. Durch irgendwelche Mengen der Größe k′ werden also höchstens

\binom{r · n}{r · k − k′ − 1} · \binom{r · n}{k′} · s · 2^{k′} · polylog n

viele Mengen J ausgemustert. Diese Größe ist aber von der Ordnung

n^{r·k−1} · 2^{k′} · polylog n

und damit für genügend große n kleiner als (n^{r·k}·2^{k′})/ log^{2} n. Durch Teilmengen der Größe kleiner oder gleich log log n werden also (für große n) höchstens

\frac{n^{r·k} · log n}{log^{2} n} · log log n = (n^{r·k} log log n)/ log n

viele Mengen J ausgemustert. Die Anzahl der in Frage kommenden Mengen J der Größe r · k ist aber von der Ordnung n^{r·k}, es bleibt also immer eine solche übrig, die durch keine ihrer Teilmengen ausgemustert worden sein kann.

Das beweist den folgenden Sachverhalt:

5.15 Lemma. Es sei f eine plt-Reduktion, die die Blattsprachen A und B zweier beschränkter Anzahlklassen aufeinander reduziert. (A und B so definiert, wie oben angegeben.) Es sei ferner f′ die zugehörige Reduktionsfunktion, die die Sprache A so auf B reduziert, daß die Anzahl verschiedener Ausgabebits mit Wert k, die durch Lesen derselben von 0 verschiedenen Eingabebits entstehen können, durch m′ beschränkt ist für alle k mit 0 < k ≤ s. Dann erfüllt f′ für jedes n die r · ⌈\frac{log log n}{r}⌉-n-Monotonie-Bedingung.

5.16 Korollar. Es seien A und B Anzahlsprachen und A ≤_{m}^{plt} B, wobei A über {0, …, r}^{∗} definiert ist mit Schwellwert m und Akzeptierungsmenge α ⊆ {0, …, m}^{r}, und B über {0, …, s}^{∗} mit Schwellwert m′ und Akzeptierungsmenge α′ ⊆ {0, …, m′}^{s}. Dann existiert eine (r, s)-H-Sequenz (H_{n}) mit der Eigenschaft, daß für alle I mit I ⊆ [n] × [r] gilt:

\begin{matrix}max ((I ∩ ([n] × \{1\}), …, I ∩ ([n] × \{r\})), m) ∈ α \\ ⟺ max ((\overline{H_{n}}(I)), m′) ∈ α′ \end{matrix}

Dabei wird das Maximum der Vektoren mit m bzw. m′ komponentenweise gebildet.

5.3.2. Das Ramsey-Theorem

Das berühmte Ramsey-Theorem [63] kann man in unserer Sprache wie folgt formulieren:

5.17 Satz (Ramsey, 1930). Es sei (H_{n}) eine H-Sequenz. Für eine feste Zahl k sei der Wert H_{n}(I) für alle n und alle I mit |I| = k beschränkt durch die Konstante m. Ferner sei eine Zahl n_{0} vorgegeben. Dann existiert eine Zahl N, so daß für alle n > N gilt, daß es in [n] eine Teilmenge J mit |J| = n_{0} gibt mit der Eigenschaft, daß für alle I, I′ mit I, I′ ⊆ J und |I| = |I′| = k gilt: H_{n}(I) = H_{n}(I′). Wir schreiben R(k, m, n_{0}) für die kleinste Zahl N, die das leistet.

Den Beweis findet man in der Originalarbeit von Ramsey, aber z.B. auch in dem Buch von Graham, Rothschild und Spencer [34]. Es sei hier auch angemerkt, daß die Anwendung eines Ramsey Arguments in der Komplexitätstheorie nicht neu ist. Als ein Beispiel sei die Arbeit von Verbitsky [79] genannt. Wir benötigen eine (r, s)-Version des Ramsey-Theorems. Zunächst beweisen wir die folgende (r, 1)-Version:

5.18 Satz. Es sei (H_{n}) eine (r, 1)-H-Sequenz. Für ein festes r-Tupel (k_{1}, …, k_{r}) sei der Wert H_{n}(I) für alle n und alle I mit |I ∩ ([n] × {i})| = k_{i} (1 ≤ i ≤ r) beschränkt durch die Konstante m. Ferner sei eine Zahl n_{0} vorgegeben. Dann existiert eine Zahl N, so daß für alle n > N gilt, daß es in [n] × [r] eine Teilmenge J gibt mit J ∩ ([n] × [i]) = n_{0} und der Eigenschaft, daß für alle I, I′ mit I, I′ ⊆ J und |I ∩ ([n] × {i})| = |I′ ∩ ([n] × {i})| = k_{i} (1 ≤ i ≤ r) gilt: H_{n}(I) = H_{n}(I′). Tatsächlich kann die Zahl N gewählt werden als N = R(k_{1}, m^{2^{n_{0}(r−1)}}, n_{0}).

Beweis. Nehmen wir an, wir haben einen (r, 1)-Hypergraphen der Größe r·n > r · R(k_{1}, m^{2^{n_{0}(r−1)}}, n_{0}). Wenn wir als das ”Verhalten“ einer Teilmenge I_{1} von [n]×{1} die Funktion h_{I_{1}}: [n_{0}]×[r−1] → IN ansehen, die durch h_{I_{1}}(I_{2}, …, I_{r}) = H_{n}(I_{1}, …, I_{r}), falls |I_{j}| = k_{j} für alle j, h_{I_{1}}(I_{2}, …, I_{r}) = 0, sonst, definiert ist, dann gibt es offenbar maximal t = m^{2^{n_{0}(r−1)}} viele verschiedene Verhalten. Wir denken uns diese Verhalten durchnumeriert mit 1 bis t. Dann konstruieren wir einen Hypergraphen H′ auf n Knoten mit der Festlegung H′(I_{1}) = j, falls |I_{1}| = k_{1} ist und die Menge I_{1} das Verhalten j hat, H′(I_{1}) = 0 für alle I_{1} mit |I_{1}| ≠ k_{1}. Nach dem Ramsey-Theorem hat der Hypergraph H′ eine Teilmenge der Größe R(k_{1}, m^{2^{n_{0}(r−1)}}, n_{0}), auf der H′(I_{1}) konstant ist für alle I_{1} mit |I_{1}| = k_{1}. Das heißt, wir finden eine Teilmenge in [n] von der Größe n_{0}, auf der alle Teilmengen der Größe k_{1} das gleiche Verhalten gegenüber Mengen der Größe (k_{2}, …, k_{r}) aufweisen. Damit ist der Satz bewiesen. □

Nun erhalten wir leicht auch das Ramsey-Theorem für (r, s)-H-Sequenzen:

5.19 Satz. Es sei (H_{n}) eine (r, s)-H-Sequenz. Für ein festes r-Tupel (k_{1}, …, k_{r}) seien alle Komponenten des Wertes H_{n}(I) für alle I mit |I ∩ ([n] × {i})| = k_{i} (1 ≤ i ≤ r) beschränkt durch die Konstante m (für alle n). Ferner sei eine Zahl n_{0} vorgegeben. Dann existiert eine Zahl N, so daß für alle n > N gilt, daß es in [n] × [r] eine Teilmenge J gibt mit |J ∩ ([n] × [i])| = n_{0} und der Eigenschaft, daß für alle I, I′ mit I, I′ ⊆ J und |I ∩([n]×{i})| = |I′ ∩([n]×{i})| = k_{i} (1 ≤ i ≤ r) gilt: H_{n}(I) = H_{n}(I′).

Beweis. Hier führen wir eine Induktion über s durch. Für s = 1 ist das der vorherige Satz.

Nun nehmen wir an, daß wir den Satz schon für s − 1 bewiesen hätten. Es sei (H_{n}) eine (r, s)-H-Sequenz. Nehmen wir zunächst an, wir haben schon einen Hypergraphen der Größe r · n, in dessen zweiter bis s-ter Komponente auf Mengen I der Größe (k_{1}, …, k_{r}) schon immer dieselben Werte (h_{2}, …, h_{s}) erscheinen. Dann können wir, wenn n nur groß genug ist, nach dem vorherigen Satz (unter Außerachtlassung der zweiten bis s-ten Komponente) einen Teilgraphen auswählen, in dem die erste Komponente von H(I) für alle I der Größe (k_{1}, …, k_{r}) konstant ist. Damit haben wir das gewünschte Ergebnis, indem wir noch feststellen, daß wir nach Induktionsvoraussetzung wiederum zunächst die Größe r · n′ so groß wählen können, daß wir, wenn wir einen (r, s − 1)-Hypergraphen dieser Größe ansehen, einen Teilgraphen der Größe r · n auswählen können, der in den Komponenten 2 bis s auf Mengen I der Größe (k_{1}, …, k_{r}) konstant ist. □

Anwenden wollen wir diesen Satz hauptsächlich in der folgenden Form, die sich direkt durch mehrmaliges Anwenden ergibt:

5.20 Korollar. Es sei (H_{n}) eine (r, s)-H-Sequenz mit der Eigenschaft, daß für Mengen I mit |I| ≤ k immer H_{n}(I) in allen Komponenten durch m beschränkt ist. Dann kann man zu vorgegebenem n_{0} einen Teilgraphen finden, auf dem für alle I mit |I| ≤ k der Wert H_{n}(I) bereits durch die Werte |I ∩ ([n] × {i})| (1 ≤ i ≤ r) bestimmt ist.

5.3.3. Lösung des Separationsproblems

Wir gehen nun wieder zurück zur Ausgangsfrage: gegeben eine Sprache A ⊆ {0, …, r}^{∗}, definiert durch die Zahl m und die Menge α ⊆ {0, …, m}^{r} und eine Sprache B ⊆ {0, …, s}^{∗}, definiert durch die Zahl m′ und die Menge α′ ⊆ {0, …, m′}^{s}.

Wir nehmen an, es gibt eine plt-Reduktion von A auf B. Nach Korollar 5.16 können wir dann eine (r, s)-H-Sequenz mit der Eigenschaft konstruieren, daß jede Teilmenge I der Größe (k_{1}, …, k_{r}) mit \overline{H_{n}}(I) = (l_{1}, …, l_{s}) die Äquivalenz

(max(m, k_{1}), …, max(m, k_{r})) ∈ α ⟺ (max(m′, l_{1}), …, max(m′, l_{s})) ∈ α′

erfüllt. Wenn wir nun den Wert H_{n}(I) durch m beschränken (d.h. wenn er eigentlich größer als m ist, ändern wir den entsprechenden Hypergraphen so ab, daß der Wert genau m wird), dann erfüllen die großen Hypergraphen dieser Sequenz die Bedingungen des Korollars 5.20 und wir können einen beliebig großen gleichmäßigen Teilgraphen konstruieren. Das bedeutet, es gibt für jedes r-Tupel x ∈ {0, …, m}^{r} einen Vektor c_{x} ∈ {0, …, m′}^{s} mit der Eigenschaft H_{n}(I) = c_{x}, falls I von der Größe x ist.

Der Wert \overline{H_{n}}(I) für Teilmengen I von der Größe x läßt sich damit berechnen als \overline{H_{n}}(I) = ∑_{y≤x} \binom{x}{y}c_{y}. (Man beachte, daß \binom{x}{y} ein Multinomialkoeffizient ist.)

Nun sind die Werte in den in Frage kommenden Vektoren durch m′ beschränkt, d.h. es gibt nur eine endliche Anzahl solcher Vektoren. Wir können damit durchprobieren, ob es eine Zuordnung x ↦ c_{x} für alle Vektoren x ∈ {0, …, m}^{r} gibt, unter der jeder Vektor aus α in der Summe ∑_{y≤x} \binom{x}{y}c_{y} in einen Vektor aus α′ übergeht. Gibt es keine solche Zuordnung, dann kann es also auch keine plt-Reduktion von A nach B geben. Umgekehrt folgt aber aus einer solchen Zuordnung in kanonischer Weise eine plt-Reduktion von A auf B: Rate ein r-Tupel x = (k_{1}, …, k_{r}) mit k_{i} ≤ m für alle i (1 ≤ i ≤ r), rate dann k_{1} + … + k_{r} Eingabebits und teste, ob die ersten k_{1} den Wert 1, die nächsten k_{2} den Wert 2 haben, usw. Sind alle diese Tests positiv, dann gib soviele Symbole k aus, wie der Vektor c_{x} in der k-ten Komponente angibt. Man überprüft leicht, daß damit eine plt-Reduktion von A auf B definiert ist.

Damit haben wir den Satz bewiesen:

5.21 Satz. Es gibt einen Algorithmus, der für zwei Blattsprachen A, B, die durch die Eingabe r, m, α, s, m′, α′ mit α ⊆ {0, …, m}^{r} und α′ ⊆ {0, …, m′}^{s} definiert sind, entscheidet, ob die dadurch definierten Komplexitätsklassen BalancedLeaf^{P}(A) und BalancedLeaf^{P}(B) durch ein Orakel getrennt werden können, d.h. ob es ein Orakel X gibt mit BalancedLeaf^{P}(A)^{X} ⊈ BalancedLeaf^{P}(B)^{X}.

5.3.4. Die Klassen {a, b}P

In [42] wurde das Problem untersucht, wann zwei Klassen der Form {a, b}P durch ein Orakel voneinander getrennt werden können. Dabei ist {a, b}P die Klasse, die durch die Blattsprache {w ∈ {0, 1}^{∗} | |w|_{1} ∈ {a, b}} definiert wird. Dort konnte nur ein partielles Ergebnis erzielt werden. Mit dem oben entwickelten Algorithmus kann nun natürlich für je zwei dieser Klassen im Einzelfall entschieden werden, ob die eine Klasse in der anderen unter allen Relativierungen enthalten ist oder ob es ein trennendes Orakel gibt. Wir können aber auch eine generelle Lösung angeben:

5.22 Satz. Es seien a, b, c und d natürliche Zahlen mit a < b und c < d. Falls a ≤ c und (b − a) ≤ (d − c) oder a > c und d ≥ \binom{b}{a} + c − 1, dann ist \{a, b\}P unter allen Relativierungen in {c, d}P enthalten. In allen anderen Fällen gibt es ein Orakel X, so daß {a, b}P^{X} ⊈ {c, d}P^{X}.

Beweis. Unter allen Orakeln ist {a, b}P in {a + 1, b + 1}P und {a, b}P in {a, b + 1}P enthalten. Das sieht man dadurch, daß man im ersten Fall durch Hinzufügen eines akzeptierenden Pfades, im zweiten Fall durch Raten von b akzeptierenden Pfaden, die (falls gefunden) zu einem zusätzlichen akzeptierenden Pfad werden, die entsprechenden Anzahlen erhält. Damit ist klar, daß im Fall a ≤ b und (b − a) ≤ (d − c) die behauptete Inklusion gilt.

Andererseits gilt unter allen Orakeln, daß \{a, b\}P (mit a > 0) in \{1, \binom{b}{a}\}P liegt, da man durch Raten von a verschiedenen akzeptierenden Pfaden die Anzahl a in 1, b in \binom{b}{a} überführt und auch keine andere Anzahl auf eine dieser beiden Zahlen abgebildet wird. Nach dem ersten untersuchten Fall gilt damit durch Addition von c−1 Pfaden auf beiden Seiten, daß auch \{a, b\}P in \{c, \binom{b}{a}+c−1\}P liegt. Damit ist auch der zweite Teil bewiesen.

Es bleibt also nur zu zeigen, daß in allen anderen Fällen ein trennendes Orakel existiert. Das machen wir, indem wir zeigen, daß in den Fällen a ≤ c und (b − a) > (d − c) bzw. a > c und d < \binom{b}{a} + c − 1 jeweils keine plt-Reduktionen zwischen den entsprechenden Blattsprachen existieren können.

Wir nehmen also an, es sei f: {0, 1}^{∗} → {0, 1}^{∗} eine plt-Reduktion, die A = {w ∈ {0, 1}^{∗} | |w|_{1} ∈ {a, b}} in B = {w ∈ {0, 1}^{∗} | |w|_{1} ∈ {c, d}} überführt. Daher können wir nach dem Beweis zu Satz 5.21 davon ausgehen, daß sich c in der Form

c = ∑_{y≤a} c_{y} · \binom{a}{y}

und d in der Form

d = ∑_{y≤b} c_{y} · \binom{b}{y}

schreiben läßt.

Nun sei a = 0. Dann müssen wir nur den Fall (b − a) > (d − c) betrachten. Es gilt c = c_{0} (da ∑_{y≤0} c_{y} · \binom{a}{y} = c_{0}) und b > 1 (sonst könnte nicht b − a größer als

d − c sein), also muß c_{1} > 0 gelten, denn sonst würde bei einer Eins im Urbild dasselbe passieren wie bei 0 Einsen. Dann hätten wir aber keine Reduktion von A auf B. Wenn aber c_{1} ≥ 1 gilt, dann folgt schon d ≥ c_{0} + c_{1} · b ≥ c + b, und wegen a = 0 also (d − c) ≥ (b − a). In dem uns interessierenden Fall gibt es daher keine solche plt-Reduktion.

Nun sei a > 0 und zunächst (b − a) > (d − c). Dann muß in der Summe für c mindestens ein Koeffizient c_{y} mit 1 ≤ y ≤ a positiv sein. Mit diesem y gilt dann:

d − c ≥ c_{y} (\binom{b}{y} − \binom{a}{y})

Falls hier y = a gilt, haben wir d − c ≥ b − 1 ≥ b − a im Widerspruch zur Voraussetzung. Aber für y < a können wir die Ungleichung \binom{a−1}{y−1} ≥ y benutzen und erhalten

d − c ≥ (\binom{b}{y} − \binom{a}{y}) ≥ \frac{b − a}{y} · \binom{a − 1}{y − 1} ≥ b − a

und damit wieder einen Widerspruch zur Voraussetzung.

Schließlich sei a > c und d < \binom{b}{a} + c − 1. Wegen c < a muß dann in der Summe für c gelten, daß c_{y} = 0 für alle y mit 1 ≤ y < a, d.h. c = c_{0} + c_{a}. Andererseits kann c_{a} nicht den Wert 0 haben, sonst würde a − 1 auch auf c abgebildet. Also wissen wir c_{a} > 0. Nun schließen wir wie folgt:

d ≥ c_{0} + c_{a} · \binom{b}{a} = c_{0} + (c_{a} − 1) · \binom{b}{a} + \binom{b}{a} ≥ c_{0} + c_{a} − 1 + \binom{b}{a} = c − 1 + \binom{b}{a}

im Widerspruch zur Voraussetzung. □

Die Beziehungen zwischen verschiedenen Klassen der Form {a, b}P lassen sich durch das folgende Bild veranschaulichen:

[figure: .; .; .; .; .; .; .; .; .; .; .; a = 0; a = 1; a = 2; a = 3; a = 4; a = 5; a = 6; a = 7; a = 8; a = 9; b = 1; b = 3; b = 5; b = 7; b = 9; b = 11; ⇒ (a, b)P ⊆ (c′, d′)P; ⇒ (a, b)P ⊈ (c, d)P (rel.); ⊈; ⊈; ⊆; ⊈; (c, d); (c′, d′); (a, b); (1, \binom{b}{a})]

5.4. Weitere Anzahlklassen

In diesem Abschnitt werden wir einige Fälle untersuchen, in denen Komplexitätsklassen, die durch nicht notwendig aperiodische Anzahlbedingungen definiert sind, verglichen werden sollen.

5.4.1. Die Klasse C_{>0,≡0(2)}P

Wir beginnen mit der Klasse C_{>0,≡0(2)}P, die uns bereits im Satz über die durch dreiwertige Funktionen charakterisierbaren Klassen begegnet ist. Man vergegenwärtigt sich leicht, daß C_{>0,≡0(2)}P eine Teilklasse von NP ∧ ⊕P ist. Aber es ist keineswegs trivial, die beiden Klassen voneinander zu trennen. Die Klasse C_{>0,≡0(2)}P kann durch die Blattsprache B = {w ∈ {0, 1}^{∗} | |w|_{1} ≡ 0 mod 2 ∧ |w|_{1} > 0} definiert werden. Wir betrachten auch die Blattsprache A = {w ∈ {0, 1}^{∗} | |w|_{1} ≡ 1 mod 2∧|w|_{1} > 1}. Offenbar ist auch die durch diese Blattsprache definierte Komplexitätsklasse eine Teilklasse von NP ∧ ⊕P, so daß es genügt zu zeigen, daß es keine plt-Reduktion von A auf B gibt. Die Aufgaben 1) und 2) aus unserem Separierungsprogramm sind bereits wieder erfüllt. Wir wollen nun zunächst die Anwendbarkeit der Hypergraphenmethode untersuchen. Dazu müssen wir unter der Annahme einer plt-Reduktion die Existenz einer Reduktionsfunktion folgern, die die Monotonie-Bedingung erfüllt.

Es wird uns aber in diesem Fall nicht genügen, die (prinzipiell auch hier anwendbare) Technik des Falls der beschränkten Anzahlklassen zu übernehmen. Diese Technik ergab nämlich nur die Existenz von gleichmäßigen Hypergraphen, deren Kanten generell beliebige Größe haben können. Im periodischen Fall kann man aber durch jeweilige Anpassung für jede Größenordnung immer solche Hypergraphen konstruieren. Wir benötigen eine Monotonie-Bedingung, aus der folgt, daß es für genügend große n Hypergraphen mit ”kleinen“ Kanten gibt, die die Reduktion von A auf B repräsentieren in dem Sinne, daß genau für alle J mit |J| > 1 und |J| ≡ 1 mod 2 gilt: H(J) > 0 und H(J) ≡ 0 mod 2.

Wir nehmen also an, es gäbe eine plt-Reduktion f von A auf B und wollen zunächst zeigen, daß es dann für jedes n einen Hypergraphen der Größe n mit Kantengröße kleiner als \frac{n}{8} gibt, der die Reduktion von A auf B repräsentiert. Dazu suchen wir zunächst eine Menge J mit der Eigenschaft, daß für alle I ⊆ J mit |I| < 4 gilt: Bei der Berechnung der ersten zwei Einsen im Bild von x_{I} (falls überhaupt zwei Einsen existieren) werden keine Bits aus J \ I benutzt. Werden weniger als zwei Einsen produziert, so ist die Bedingung entsprechend anzupassen (bzw. wegzulassen, wenn gar keine Eins produziert wird). Da die Hyperkanten von vornherein polylogarithmische Größe haben, genügt uns die Größe |J| = 8·p(log n) für das entsprechende Polynom p. Jede Menge I mustert also maximal 2·p(log n)·\binom{n}{|J|−1}·|J|^{2} der möglichen \binom{n}{|J|} Mengen aus. Die Anzahl der ausgemusterten Mengen ist von der Ordnung n^{8·p(log n)−1} · (p(log n))^{3}, die Anzahl der möglichen Mengen von der Ordnung n^{8·p(log n)}. Also gibt es für große n immer eine nicht ausgemusterte solche Menge.

Nun haben wir also eine Menge der Größe 8 · p(log n) mit der Eigenschaft, daß bei Eingaben mit weniger als drei Einsen niemals durch Hinzunahme von Einsen im Bild ein Rückschritt von zwei auf weniger als zwei Einsen oder von einer auf null Einsen erfolgen kann.

Daher können wir genauso wie im zweiten Beispiel im Abschnitt 5.2.4 ohne weitere Verkleinerung von J die konstruierte polylog-Reduktions-Funktion auf Eingaben x_{I} mit I ⊆ J so abändern, daß sie monoton wird. Damit haben wir Aufgabe 3) erfüllt und für jedes große n einen Hypergraphen auf n Knoten konstruiert, der die Reduktion von A auf B repräsentiert.

Nun müssen wir die Nichtexistenz dieser Hypergraphen für unendlich viele n beweisen. Wir nehmen nun also für beliebiges n an, der Hypergraph H existiere. Zunächst nehmen wir weiter an, daß H(∅) > 0 gelte. Wegen der Reduktionseigenschaft hätten wir dann \overline{H}(X) ≡ 0 mod 2 genau dann, wenn |X| ∈ {m > 1 | m ≡ 1 mod 2}. Wir behaupten, daß dann gelten muß: H(X) = 1 genau dann, wenn |X| = 0 oder |X| > 1 und ungerade. Man kann das durch eine leichte Induktion nachprüfen. Da es aber Teilmengen von J gibt, deren Elementezahl ungerade Zahlen größer als p(log n) sind, haben wir einen Widerspruch. Also gilt H(∅) = 0.

Für die einelementigen Mengen X ⊆ J gilt entweder H(X) = 0 oder H(X) ist ungerade. Wir können aber jedenfalls in unserer Menge J eine Menge der Größe 4 · p(log n) auswählen, so daß entweder für alle einelementigen X ⊆ J gilt, daß H(X) = 0 ist, oder aber für alle solchen X ist H(X) ungerade.

Aus unserer Menge J wählen wir uns nun eine größte Menge aus, deren Elementezahl eine Potenz von 2 ist. Die ausgewählte Menge nennen wir wieder J und ihre Elementezahl ist größer als 2 · p(log n). Da die Kantengröße durch p(log n) beschränkt ist, gibt es insgesamt auch einen entsprechenden Hypergraph, wenn wir die Kantengröße durch |J|/2 beschränken. Der Vorteil dieser Schranke ist der, daß sie auch eine Potenz von 2 ist.

Damit haben wir unseren Hypergraphen in eine besondere Form gebracht: Er hat als Größe eine Zweierpotenz, seine Kantengröße ist beschränkt durch die nächstkleinere Zweierpotenz und auf Kanten der Größen kleiner als 2 ist er gleichmäßig. Ist der Fall eingetreten, daß auf Teilmengen X mit |X| = 1 immer H(X) ungerade ist, so muß dasselbe auch auf Teilmengen X mit |X| = 2 gelten. Damit ist dann die Frage, ob H(X) gerade oder ungerade ist, für jedes X nur noch von der Elementezahl X abhängig, da die Gleichmäßigkeit auf Mengen der Größe k > 2 direkt aus der Gleichmäßigkeit auf Mengen der Größe kleiner als k folgt. Bei gleichmäßigen Graphen folgt aber für \overline{H}(J), daß \overline{H}(J) ≡ 0 mod 2 ist, da es von jeder erlaubten Kantengröße eine gerade Anzahl innerhalb von J gibt (man erinnere sich, daß |J| eine Zweierpotenz ist), außer von der Kantengröße 0, aber wir wissen schon, daß auf der leeren Menge gilt H(∅) = 0.

Wir müssen also noch den Fall untersuchen, daß für alle einelementigen Mengen X gilt: H(X) = 0. Dann können die zweielementigen Mengen auch noch entweder den Wert 0 oder einen ungeraden Wert ergeben. Hier können wir nicht mehr einfach eine Teilmenge auswählen, die gleichmäßig ist, da wir dann nur logarithmisch viele Knoten behalten würden, folglich würden wir die Beschränkung der Kantengröße verlieren.

Wir behelfen uns mit folgender Überlegung: es sei irgendeine Menge X ⊆ J mit |X| = 2 vorhanden, so daß H(X) = 0 ist. Setzen wir nun H(X) = 1, so ändert sich in jeder Menge Y mit X ⊆ Y und |Y | ≤ |J|/2 zunächst das Parity von \overline{H}(Y). Also verändern wir in jeder solchen Menge ebenfalls den Wert um 1. Damit haben wir für alle I ⊆ J mit |I| ≤ |J|/2 immer noch alle Bedingungen korrekt erfüllt, und auch für J hat sich nichts geändert, denn die Anzahl der Änderungen läßt sich berechnen als

∑_{i=0}^{|J|/2−2} \binom{|J| − 2}{i},

denn zu jeder Größe a ∈ \{2, …, |J|/2\} gibt es \binom{|J|−2}{a−2} Mengen in J von der Größe a, die die Menge X enthalten und höchstens |J|/2 Elemente haben. Allgemein gilt aber \binom{2^{n}−2}{i} ist (für i < 2^{n−1}) ungerade genau dann, wenn i gerade ist. Unter den Zahlen {0, …, |J|/2 − 2} sind genau |J|/4 gerade Zahlen, und da J eine große Zweierpotenz ist, ist die Summe gerade.

Damit haben wir gezeigt, daß wir alle zweielementigen X mit H(X) = 0 zum Wert H(X) = 1 ändern und alle anderen Kanten zulässiger Größe entsprechend anpassen können, ohne den Wert von \overline{H}(J) zu ändern (modulo 2). Damit erhalten wir wieder einen gleichmäßigen Hypergraph, von solchen haben wir aber oben schon gezeigt, daß sie zwingend \overline{H}(J) ≡ 0 mod 2 erfüllen. Also gilt letzteres auch für unseren ursprünglichen Hypergraphen im Widerspruch zur Annahme, daß er die Reduktion A auf B korrekt repräsentiert.

Als Resultat können wir nun schließen, daß es ein Orakel gibt, das Leaf^{P}(B) von Leaf^{P}(A) und damit auch NP ∧ ⊕P von C_{>0,≡0(2)}P trennt.

5.4.2. MOD-Klassen

Nach den wichtigen, aber komplizierten Anwendungen des Hypergraphen-Ansatzes in den vorangegangenen Abschnitten, wollen wir nun in diesem und dem nächsten Abschnitt zwei Fälle behandeln, in denen die Vorteile dieses Ansatzes voll zum Tragen kommen, da die angestrebten Trennungen sehr einfach zu erhalten sind. Wir beginnen mit den MOD-Klassen, und zwar zeigen wir für eine Primzahl p und eine beliebige Zahl k, die keine p-Potenz ist, daß es ein Orakel X gibt mit MOD_{k}P^{X} ⊈ MOD_{p}P^{X}. Die Klasse MOD_{p}P kann durch das Blattsprachenpaar (B, R) definiert werden, wobei B aus allen Wörtern über {0, 1} mit einer durch p teilbaren Anzahl Einsen besteht, R aus allen solchen Wörtern, deren Anzahl Einsen kongruent 1 modulo p ist. Die Klasse MOD_{k}P kann durch das Blattsprachenpaar (A, \overline{A}) definiert werden, wobei A aus allen Wörtern über {0, 1} mit einer nicht durch k teilbaren Anzahl Einsen besteht. Nehmen wir an, es gäbe eine normierte plt-Reduktion, die das Paar (A, \overline{A}) auf (B, R) reduziert. Dann könnten wir wie im Beispiel 2 des Abschnitts 5.2.4 ohne weiteres die plt-Reduktion monoton machen, indem wir für eine Berechnung, die die Eingabebits aus der Menge I lesen und daraufhin ihre Ausgabe entscheiden will, auf alle Teilmengen I′ von I verzweigen und testen, ob alle Bits zu I′ den Wert 1 haben. Wenn ja, wird angenommen, das seien genau alle 1-Bits in I und es wird die zugehörige Ausgabe berechnet. Zusätzlich wird für alle Teilmengen von I′ die durch diese jeweilige Teilmenge fälschlich ausgegebene Menge 1-Bits durch eine entsprechende Anzahl weiterer 1-Bits kompensiert. Das geht immer, da wir nur an der Anzahl der 1-Bits modulo p interessiert sind. Damit haben wir gezeigt, daß wir die plt-Reduktion so einrichten können, daß die gesamte Eingabegröße ein Monotoniegebiet darstellt. Das heißt, wir können Hypergraphen konstruieren, deren Kanten nur polylogarithmisch groß sind, mit der Eigenschaft: Wenn die Knotenmenge X eine nicht durch k teilbare Elementezahl hat, dann ist H(X) durch p teilbar. Ist dagegen |X| durch k teilbar, so gilt H(X) ≡ 1 mod p. In einem solchen Hypergraphen ist natürlich die Zahl H(X) mod p bereits durch |X| festgelegt. Nehmen wir nun einen Hypergraphen der Größe p^{n}, dessen Kanten kleiner als p^{n−1} sind, dann muß für die Menge J aller Knoten sicher gelten: |J| = p^{n}, und daher \overline{H}(J) ≡ 1 mod p, denn zu allen erlaubten Kantengrößen größer als 0 gibt es eine durch p teilbare Anzahl von Kanten, deren Werte sich also modulo p aufheben. Es bleibt aber die leere Kante, die den Wert H(∅) ≡ 1 mod p haben muß, da k ein Teiler von 0 ist. Aus der Kongruenz \overline{H}(J) ≡ 1 mod p folgern wir aber, daß k ein Teiler von |J| = p^{n} sein muß. Da aber p eine Primzahl und k keine p-Potenz ist, kann das nicht sein. Also gab es die angenommene plt-Reduktion gar nicht. Damit erhalten wir noch einmal einen Beweis des Ergebnisses von Beigel [10]:

5.23 Satz. Es sei p eine Primzahl und k > 2 keine p-Potenz. Dann gibt es ein Orakel X mit der Eigenschaft, daß MOD_{k}P^{X} ⊈ MOD_{p}P^{X}.

5.4.3. Die Klassen NP und C_{=}P

Das letzte Ergebnis stammt ursprünglich von Torán [75, 76]:

5.24 Satz. Es gibt ein Orakel X mit der Eigenschaft, daß NP^{X} ⊈ C_{=}P^{X}.

Da die Umkehrung schon aus den bekannten Tatsachen folgt, daß coNP ⊆ C_{=}P (unter allen Relativierungen) und daß es ein Orakel gibt, das NP und coNP trennt, erhalten wir also die Nichtvergleichbarkeit der Klassen NP und C_{=}P.

Beweis. Wir geben ein einfaches Argument für Toráns Ergebnis: NP sei auf die übliche Art mit der kanonischen Blattsprache A definiert, C_{=}P mit der Blattsprache B = {w ∈ {0, 1, 2}^{∗} | |w|_{1} = |w|_{2}}. Wir nehmen an, es gäbe eine plt-Reduktion von A auf B. Dann können wir wieder leicht ein Monotoniegebiet der vollen Größe erreichen, da wir auch für die Blattsprache B eine Art Korrekturmechanismus wie im vorigen Fall einführen können. Wichtig war ja nur, daß wir bei geratener Menge I die fälschlicherweise erzeugten Werte von Teilmengen I′ ⊆ I wieder rückgängig machen konnten. Das können wir auch hier, indem wir für jede fälschlich erzeugte 1 eine 2, und für jede fälschlich erzeugte 2 eine 1 erzeugen. Damit machen wir deren Wirkung auf die Frage, ob |w|_{1} = |w|_{2} gilt, tatsächlich rückgängig.

Wir können also von einem (1, 2)-Hypergraphen beliebiger Größe n mit polylogarithmischer Kantengröße ausgehen, der nur in der leeren Knotenmenge verschieden viele Kanten der Sorten 1 und 2 hat, in jeder größeren Knotenmenge aber gleichviele Kanten beider Sorten. O.B.d.A. gelte H(∅) = (a, b) mit a > b. Wir folgern per Induktion, daß dann für jedes X mit |X| ≡ 1 mod 2 und H(X) = (c, d) gelten muß, daß a − b = d − c ist, und für jedes X mit |X| ≡ 0 mod 2 und H(X) = (c, d) gelten muß, daß a − b = c − d.

Induktionsanfang: Wir wissen das schon für |X| = 0.

Induktionsschritt: Wir nehmen an, daß die Behauptung für Mengen X bis zur Größe k − 1 gilt und wollen sie dann auch für Mengen der Größe k nachweisen. Nun gibt es bekanntlich in einer beliebigen nichtleeren Menge immer gleich viele Teilmengen mit gerader Anzahl wie mit ungerader Anzahl. Da wir aus allen Teilmengen mit gerader Anzahl einen Überschuß von b − a in der ersten Komponente des Wertes unter H erhalten, aus allen Teilmengen mit ungerader Anzahl denselben Überschuß in der zweiten Komponente, können wir nur dann auf einen insgesamt ausgeglichenen Wert unter \overline{H} kommen, wenn sich auch die k-elementige Menge an diese Regel hält. Also gilt für k ungerade, |X| = k und H(X) = (c, d), daß a−b = d−c ist, und für k gerade entsprechend a−b = c−d.

Insbesondere stimmt das auch für große Mengen X, für die aber nach Voraussetzung H(X) = (0, 0) gilt. Da aber a > b ist, gilt a−b ≠ 0−0 im Widerspruch zu den angegebenen Bedingungen. □

110 Orakelseparationen

Abschlußeigenschaften der Klasse #P

In diesem Kapitel wollen wir eine überraschende Konsequenz aus den Ergebnissen des Abschnitts 5.3 ziehen, indem wir die Hypergraphentechnik dazu verwenden, Orakel zu konstruieren, die gegen bestimmte Abschlußeigenschaften der Funktionenklasse #P sprechen. Wir beginnen damit, eine bestimmte besonders interessante Klasse von möglichen Abschlußeigenschaften einzuführen:

6.1. Einfache Abschlußeigenschaften

6.1 Definition. Eine Abschlußeigenschaft der Klasse #P ist eine Vorschrift, wie man aus bestimmten gegebenen Funktionen f_{1}, …, f_{r} : Σ^{∗} → IN eine Funktion g: Σ^{∗} → IN konstruiert, so daß gilt:

∀i f_{i} ∈ #P ⟹ g ∈ #P.

Die Abschlußeigenschaft heißt einfach, wenn die Vorschrift durch eine Funktion h: IN^{r} → IN gegeben ist, so daß

g(x) = h(f_{1}(x), …, f_{r}(x)).

Einige triviale einfache Abschlußeigenschaften kennen wir schon; so ist #P abgeschlossen gegen Addition, Multiplikation, Inkrement, Binomialkoeffizient mit Konstanten, etc. Dagegen haben Ogiwara und Hemachandra [56] gezeigt, daß die Polynomialzeithierarchie kollabieren würde, wenn #P abgeschlossen wäre gegen Dekrement oder Subtraktion.

Wir werden grundsätzlich nicht in der Lage sein, von einer einfachen Abschlußeigenschaft zu zeigen, daß #P sie nicht hat, da wir damit eine Trennung von P und PSPACE erzielen würden. Daher müssen wir uns darauf beschränken, von Abschlußeigenschaften zu zeigen, daß #P sie in einer bestimmten Relativierung nicht hat. Das motiviert die folgende Definition:

6.2 Definition. Eine Abschlußeigenschaft von #P heißt starke Abschlußeigenschaft, wenn sie unter allen Relativierungen gilt.

Nach unserer Überzeugung sollten alle einfachen Abschlußeigenschaften von #P starke Abschlußeigenschaften sein (bei der klaren uniformen Definition der Klasse #P erscheint es uns ausgeschlossen, daß es einfache Abschlußeigenschaften geben könnte, die durch ein Orakel zerstört werden), und wir meinen, daß für den Vergleich von Zählklassen (zu denen die meisten in dieser Arbeit betrachteten Komplexitätsklassen in irgendeiner Weise gehören) in den meisten Fällen tatsächliche relativierbare Inklusionen bereits durch einfache Abschlußeigenschaften realisierbar sind.

Wir gehen also davon aus, daß wir durch die Betrachtung einfacher starker Abschlußeigenschaften bereits die zentralen Abschlußeigenschaften von #P erfaßt haben.

6.2. Verallgemeinerung des Hypergraphenansatzes

Im Abschnitt 5.3 haben wir die Anwendbarkeit der Hypergraphenmethode auf beschränkte Anzahlklassen untersucht. Die dort benutzte Definition der Klassen durch eine Teilmenge α der Menge {0, …, m}^{r} kann man auf zwei Teilmengen α und ρ mit α ∩ ρ = ∅ verallgemeinern. Wird durch das Tripel r, m, α die Blattsprache A definiert und durch r, m, ρ die Blattsprache R, so folgt A∩R = ∅, so daß die Klasse BalancedLeaf^{P}(A, R) wohldefiniert ist.

Mit dieser Definition und analogen Definitionen für ein Paar (B, T) über die Zahlen s, m′ und die Mengen β und τ können wir den Beweis des Korollars 5.16 unverändert durchführen und erhalten folgende allgemeinere Form:

6.3 Lemma. Es seien (A, R) und (B, T) Paare von Anzahlsprachen, und es gelte (A, R) ≤_{m}^{plt} (B, T), wobei A und R über {0, …, r}^{∗} definiert sind mit Schwellwert m und Akzeptierungsmengen α, ρ ⊆ {0, …, m}^{r}, und B und T über {0, …, s}^{∗} mit Schwellwert m′ und Akzeptierungsmengen β, τ ⊆ {0, …, m′}^{s}. Dann existiert eine (r, s)-H-Sequenz (H_{n}) mit der Eigenschaft, daß für alle I mit I ⊆ [n] × [r] gilt:

max ((I ∩ ([n] × \{1\}), …, I ∩ ([n] × \{r\})), m) ∈ α ⟹ max ((\overline{H_{n}}(I)), m′) ∈ β

6.3. Abschlußeigenschaften der Form f: IN → IN 113

max ((I ∩ ([n] × \{1\}), …, I ∩ ([n] × \{r\})), m) ∈ ρ ⟹ max ((\overline{H_{n}}(I)), m′) ∈ τ Dabei wird das Maximum der Vektoren mit m bzw. m′ komponentenweise gebildet.

Auf die Hypergraphen aus diesem Lemma ist nun auch das Korollar 5.20 anwendbar, d.h. wir können sogar gleichmäßige Hypergraphen mit der angegebenen Eigenschaft finden.

6.3. Abschlußeigenschaften der Form f: IN → IN

Wir gehen von einer Funktion f: IN → IN aus und wollen ermitteln, ob f eine einfache starke Abschlußeigenschaft von #P ist. Wenn dem so wäre, dann müßte für alle Funktionen g: Σ^{∗} → IN gelten:

g ∈ #P ⟹ f ∘ g ∈ #P.

Wir eliminieren nun schrittweise viele Funktionen, die keine einfachen starken Abschlußeigenschaften sind:

6.4 Lemma. Es sei f: IN → IN, und für eine Zahl m ∈ IN gelte f(m) > f(m + 1). Dann ist f keine starke Abschlußeigenschaft von #P.

Beweis. Wir nehmen an, f wäre eine starke Abschlußeigenschaft von #P und führen diese Annahme zu einem Widerspruch.

Mit f ist auch die Funktion f′: IN → IN, gegeben durch f′(n) = f(m + n) + f(m) · \binom{n}{2} eine starke Abschlußeigenschaft von #P, denn #P ist (relativierbar) abgeschlossen unter Addition, Multiplikation und Binomialkoeffizient mit Konstanten. Nun gilt aber f′(1) = f(m + 1) und f′(n) > f(m + 1) für alle n ≠ 1. Nun sei eine Sprache L aus 1-NP gegeben. Dann existiert eine Funktion g ∈ #P mit x ∈ L ⟺ g(x) = 1. Aber auch die Funktion h definiert durch h(x) = f′(g(x)) ist in #P, und es gilt x ∈ L ⟺ g(x) = 1 ⟺ h(x) ≤ f(m+1). Damit ist L ∈ coNP. Nun wissen wir aber bereits, daß es ein Orakel gibt, das 1-NP von coNP trennt (das ist bekannt, kann aber auch mit dem Algorithmus aus Abschnitt 5.3 ermittelt werden), also kann f′ und damit auch f keine starke Abschlußeigenschaft von #P sein. □

6.5 Lemma. Es sei f: IN → IN, und für eine Zahl m ∈ IN gelte f(m) < f(m + 1) = f(m + 2). Dann ist f keine starke Abschlußeigenschaft von #P.

Beweis. Wir nehmen an, f wäre eine starke Abschlußeigenschaft von #P und führen diese Annahme zu einem Widerspruch.

Mit f ist auch die Funktion f′: IN → IN, gegeben durch f′(n) = f(m + n) + f(m + 1) · \binom{n}{3} eine starke Abschlußeigenschaft von #P. Es gilt aber f′(0) < f′(1) = f′(2) < f′(i) für alle i > 2. Daraus folgt die relativierbare Inklusion {1, 2}-P ⊆ 1-NP. Das kann nicht sein, da mit dem Algorithmus von Abschnitt 5.3 nachgewiesen werden kann, daß ein Orakel X existiert, für das {1, 2}-P^{X} ⊈ 1-NP^{X} gilt. □

Nun wissen wir also, daß für starke Abschlußeigenschaften f: IN → IN von #P gelten muß:

f(0) = f(1) = … = f(m) < f(m + 1) < f(m + 2) < …

für ein m ≥ 0. Damit beweisen wir weiter:

6.6 Lemma. Es sei f: IN → IN eine starke Abschlußeigenschaft, und es sei m die eindeutig bestimmte Zahl mit der Eigenschaft

f(0) = f(1) = … = f(m) < f(m + 1) < f(m + 2) < ….

Dann existiert für alle i ≥ 0 eine plt-Reduktion von (A, \overline{A}) auf (B, R), wobei

\begin{aligned}A & = & \{0, 1, …, m − 1, m, m + 2, m + 4, …, m + 2i\} \\ B & = & \{f(m), f(m + 2), f(m + 4), …, f(m + 2i)\} \\ R & = & \{f(m + 1), f(m + 3), …, f(m + 2i − 1)\} ∪ \{f(j) | j > m + 2i\} \end{aligned}

Beweis. Wir zeigen, daß für alle i mit der obigen Definition von A, B und R gilt, daß BalancedLeaf^{P}(A, \overline{A}) ⊆ BalancedLeaf^{P}(B, R) und daß diese Inklusion relativierbar ist. Also muß es die angegebene Reduktion geben.

Es sei also L ∈ BalancedLeaf^{P}(A, \overline{A}) gegeben, d.h. es gibt eine Funktion g ∈ #P mit der Eigenschaft, x ∈ L ⟺ g(x) ∈ A. Nach Voraussetzung ist dann auch die Funktion h mit h(x) = f(g(x)) in #P, und es gilt x ∈ L ⟺ g(x) ∈ A ⟹ h(x) ∈ B, sowie x ∉ L ⟺ g(x) ∉ A ⟹ h(x) ∈ R. Also ist auch L ∈ BalancedLeaf^{P}(B, R). Keiner der verwendeten Schritte war nicht relativierbar, also ist die resultierende Inklusion der beiden Klassen relativierbar. □

Nun können wir also zu jedem Paar (f, i), wo f: IN → IN eine starke Abschlußeigenschaft von #P ist und i eine Zahl, einen gleichmäßigen Hypergraphen finden, der die plt-Reduktion von (A, \overline{A}) auf (B, R) (mit den oben angegebenen Definitionen für A, B und R) repräsentiert. Aus der Gleichmäßigkeit dieser Hypergraphen folgt aber sofort, daß die Funktion f für alle j einen Wert der Form

f(j) = ∑_{k≤j} α_{k}\binom{j}{k}

für feste Werte α_{k} annimmt. Damit können wir allgemein schreiben:

f(n) = ∑_{k∈IN} α_{k}\binom{n}{k}.

Denn die unendliche Summe reduziert sich für jeden Wert von n in Wirklichkeit auf die endliche Summe für k ≤ n, da der Binomialkoeffizient \binom{n}{k} für k > n den Wert 0 annimmt. Tatsächlich können wir aber beweisen, daß diese unendliche Summe in Wirklichkeit auch global nur endlich viele nicht verschwindende Summanden hat:

6.7 Lemma. Es sei f: IN → IN eine starke Abschlußeigenschaft von #P. Dann existieren Zahlen m und α_{0}, α_{1}, …, α_{m}, so daß für alle n ∈ IN gilt:

f(n) = ∑_{0≤k≤m} α_{k}\binom{n}{k}.

Beweis. Wir wissen schon, daß sich f mit einer unendlichen Summe der angegebenen Art darstellen läßt. Nun nehmen wir an, daß es tatsächlich unendlich viele Koeffizienten α_{k} > 0 gibt. Wir wissen, daß die Funktion g(x) = 2^{|x|} in #P liegt. Damit muß auch die Funktion h(x) = f(2^{|x|}) in #P liegen. Nun gilt aber für alle k mit α_{k} > 0, daß h(0^{⌈log 2k⌉}) = f(2^{⌈log 2k⌉}) > f(2k) > \binom{2k}{k} > 2^{k} ist. Aber der Wert 2^{k} ist doppelt exponentiell in der Länge der Eingabe zu h, und wir können diese Ungleichung für beliebig große k erhalten. Das bedeutet, daß es für beliebig große Eingabelängen unter h einen Wert gibt, der doppelt exponentiell ist. Es ist aber klar, daß die Werte von Funktionen aus #P immer exponentiell beschränkt sind (in der Eingabelänge). Also kann h keine #P-Funktion sein. Damit haben wir die Annahme, es gäbe für unendlich viele k positive Koeffizienten α_{k}, zum Widerspruch geführt. □

Nun können wir leicht den folgenden Satz beweisen, der die möglichen starken einfachen Abschlußeigenschaften f: IN → IN für #P vollständig charakterisiert:

6.8 Satz. Eine Funktion f: IN → IN ist genau dann eine starke Abschlußeigenschaft von #P, wenn Zahlen m und α_{0}, α_{1}, …, α_{m} existieren, so daß für alle n ∈ IN gilt:

f(n) = ∑_{0≤k≤m} α_{k}\binom{n}{k}.

Beweis. Daß f in dem beschriebenen Fall eine starke Abschlußeigenschaft ist, folgt daraus, daß bekannterweise #P abgeschlossen ist unter Binomialkoeffizient mit Konstanten und unter Addition und daß diese Tatsachen relativierbar sind. Damit ist die ”dann“-Richtung bewiesen. Die ”nur dann“-Richtung ist aber genau die Aussage des vorherigen Lemmas. □

6.4. Abschlußeigenschaften der Form f: IN^{r} → IN

Nun wollen wir die Technik aus dem vorigen Abschnitt verallgemeinern, um ein analoges Ergebnis auch für mehrstellige Abschlußeigenschaften zu erhalten.

Es sei also f: IN^{r} → IN, und wir nehmen an, daß für alle Funktionen-Tupel (g_{1}, …, g_{r}) mit g_{i} ∈ #P für alle i gilt, daß auch f ∘ (g_{1}, …, g_{r}) ∈ #P ist. Dabei meinen wir mit f ∘ (g_{1}, …, g_{r}) die Funktion h, die definiert ist durch h(x) = f(g_{1}(x), …, g_{r}(x)).

Es gilt analog zu Lemma 6.4:

6.9 Lemma. Es sei f: IN^{r} → IN, und für Zahlen m_{1}, …, m_{r} gelte die Ungleichung

f(m_{1}, …, m_{i−1}, m_{i}, m_{i+1}, …, m_{r}) > f(m_{1}, …, m_{i−1}, m_{i} + 1, m_{i+1}, …, m_{r}).

Dann ist f keine starke Abschlußeigenschaft.

Beweis. Das folgt aus Lemma 6.4, da für feste Zahlen m_{1}, …, m_{i−1}, m_{i+1}, …, m_{r} und für eine starke Abschlußeigenschaft f auch die Zuordnung g ↦ h eine starke Abschlußeigenschaft ist, wenn h definiert wird durch h(x) = f(m_{1}, …, m_{i−1}, g(x), m_{i+1}, …, m_{r}). □

Also sind auch r-stellige starke einfache Abschlußeigenschaften von #P immer monoton. Für gegebenes Maximum m betrachten wir nun die folgende Menge:

V = {f(m_{1}, …, m_{r}) | m_{i} < m}.

Diese Menge denken wir uns in geordneter Form dargestellt als V = {v_{1}, …, v_{s}} für s = |V | ≤ m^{r}. Ferner betrachten wir die Teilmenge V_{1} von V, definiert durch V_{1} = {v_{i} ∈ V | i ≡ s mod 2} und die Teilmenge V_{2} von V, definiert durch V_{2} = {v_{i} ∈ V | i ≡ s − 1 mod 2}. Weiter definieren wir die Menge

A = {w ∈ {0, …, r}^{∗} | f(|w|_{1}, …, |w|_{r}) ∈ V_{1}}.

Damit ist die Klasse BalancedLeaf^{P}(A, \overline{A}) festgelegt. Schließlich definieren wir

B = {w ∈ {0, 1}^{∗} | |w|_{1} ∈ V_{1}}

und

R = {w ∈ {0, 1}^{∗} | |w|_{1} ∈ V_{2} ∨ |w|_{1} > f(m, …, m)}.

Damit gilt offenbar BalancedLeaf^{P}(A, \overline{A}) ⊆ BalancedLeaf^{P}(B, R) und diese Inklusion ist relativierbar. Folglich erhalten wir eine plt-Reduktion, die (A, \overline{A})

6.4. Abschlußeigenschaften der Form f: IN^{r} → IN 117

auf (B, R) reduziert. Der diese Reduktion repräsentierende Hypergraph kann gleichmäßig gewählt werden, also müssen die Werte f(m_{1}, …, m_{r}) für m_{i} < m jeweils als Summen der Form

f(v) = ∑_{u≤v} α_{u}\binom{v}{u}

darstellbar sein, wobei u und v Vektoren der Länge r mit Komponenten kleiner als m sind und \binom{v}{u} ein Multinomialkoeffizient ist. Daraus erhalten wir für die globale Funktion f die Darstellung

f(v) = ∑_{u∈IN^{r}} α_{u}\binom{v}{u}.

Es ergibt sich aber mit dem gleichen Argument wie im eindimensionalen Fall wieder, daß nur endlich viele dieser Summanden wirklich mit einem Koeffizienten α_{u} > 0 vorkommen können. Also ergibt sich der folgende Satz, in dem wir die vorkommenden Multinomialkoeffizienten der besseren Lesbarkeit halber durch ein äquivalentes Produkt von Binomialkoeffizienten ersetzen:

6.10 Satz. Es sei f: IN^{r} → IN eine starke Abschlußeigenschaft von #P. Dann gibt es einen Vektor v ∈ IN^{r} und Koeffizienten α_{u} für alle Vektoren u ≤ v, so daß für alle m_{1}, …, m_{r} ∈ IN^{r} gilt:

f(m_{1}, …, m_{r}) = ∑_{{u = (u_{1}, …, u_{r}) \atop u ≤ v}} α_{u} ∏_{i=1}^{r} \binom{m_{i}}{u_{i}}.

Umgekehrt ist jede so darstellbare Funktion eine starke Abschlußeigenschaft der Klasse #P.

118 Abschlußeigenschaften der Klasse #P

Zusammenfassung der Ergebnisse

Wir wollen nun noch einmal kurz die Ergebnisse dieser Arbeit zusammenfassen:

Lokal definierbare Akzeptanztypen Das Modell der lokal definierbaren Akzeptanztypen ist eine sinnvolle Verallgemeinerung des Prinzips, das hinter den Definitionen prominenter Polynomialzeit-Komplexitätsklassen wie NP, coNP, ⊕P, PSPACE (definiert über alternierende Polynomialzeitmaschinen) etc. steht. Wir konnten eine Normalform für durch k-wertige LDA-Typen charakterisierbare Klassen beweisen. Wir konnten zeigen, daß bereits die dreiwertigen LDA-Typen in Normalform eine relativ große Menge charakterisierbarer Klassen erzeugt, nämlich 20, während im zweiwertigen Fall bekannterweise nur fünf Klassen erzeugt werden. Über eine Reihe von Konstruktionsoperatoren, die aus gegebenen Klassen neue Klassen erzeugen, wurde nachgewiesen, daß beinahe alle bekannten und interessanten Komplexitätsklassen im Bereich zwischen P und PSPACE (mit Ausnahme der probabilistischen Klassen und der sogenannten ”Promise“-Klassen) durch lokal definierbare Akzeptanztypen charakterisierbar sind.

Halbgruppen-Akzeptanztypen Im Kapitel 4 haben wir den Spezialfall der assoziativen Akzeptanztypen näher untersucht. Solche Akzeptanztypen werden durch eine Halbgruppe charakterisiert. Hier wurden eine Reihe interessanter Aussagen gemacht, welche Komplexitätsklassen durch welche Sorte von Halbgruppen charakterisiert werden können. In den Extremfällen (nichtauflösbare Halbgruppen am oberen Ende, kommutative aperiodische Halbgruppen bzw. kommutative Gruppen am unteren Ende) konnten genaue Charakterisierungen bewiesen werden, in den Zwischenbereichen sind immerhin noch globale Aussagen der Art ”durch auflösbare Halbgruppen beschriebene Klassen sind in MOD-PH enthalten“ erzielt worden.

Als Nebenergebnisse erhalten wir hier die Gleichmächtigkeit des balancierten und des unbalancierten Modells, sowie einen neuen Beweis der Tatsache, daß alle von P verschiedenen so charakterisierbaren Klassen entweder NP oder coNP oder eine MOD-Klasse enthalten.

Orakelseparationen und Abschlußeigenschaften von #P

Eine völlig neue Entwicklung ist das Verfahren, mit Hilfe der Existenzfrage für bestimmte Hypergraphen die Existenz einer Orakelseparation zwischen bestimmten Komplexitätsklassen zu beantworten. Dies gelang im Kapitel 5 für viele interessante Fälle. Herauszuheben ist hier der Fall der beschränkten Anzahlklassen, in denen durch die Anwendbarkeit des Ramsey-Theorems eine vollständige Lösung der Separationsfrage entstand; auch die letztlich hinter diesem Ergebnis stehende Bedeutung ist für sich allein interessant: Es gibt im wesentlichen keine sinnvollen Simulationen für Maschinen, die Sprachen aus einer beschränkten Anzahlklasse erkennen, außer denen, die man schon lange kennt und deren sämtliche Berechnungen von der Form sind, daß man eine feste endliche Anzahl von Berechnungswegen der simulierten Maschine rät und nur dann akzeptiert, wenn alle diese Wege akzeptierend sind.

Diese Aussage führte schließlich noch zu dem überraschenden Resultat, daß alle relativierbaren Abschlußeigenschaften von #P, die nur auf den Werten der Eingabefunktion arbeiten (also ”einfache“ Abschlußeigenschaften), als Summe von Binomialkoeffizienten (bzw. im allgemeinsten Fall Multinomialkoeffizienten) darstellbar sind.

Index

Symbole

IN, 10 false, 22 true, 22

Funktionen

acc_{M}, 10 rej_{M}, 10 a mod (t, m), 70 c_{A}, 11 f_{∨}, 24 f_{∧}, 24 φ_{H}(a, b), 64 id, 23 \overline{H}(X), 89 R(k, m, n_{0}), 99 Sum_{k}, 23 \binom{n}{m}, 10 \binom{(n_{1},...,n_{r})}{(m_{1},...,m_{r})}, 11 |w|, 11 |w|_{σ}, 11

Komplexitätsklassen

P, 11 NP, 12 coNP, 12 UP, 12 PSPACE, 12 f(C, …, C), 13 Σ_{k}^{p}, 13 Π_{k}^{p}, 13 Δ_{k}^{p}, 13 Θ_{k}^{p}, 13 P_{||}^{Σ_{k−1}^{p}}, 13 PP, 13 CH, 13 NP(k), 14 coNP(k), 14 NP ∧ coNP, 14 MOD_{k}P, 14 ⊕P, 14 A-P, 15 ∇P, 16 co-∇P, 16 C_{>0,≡0(2)}P, 16 #P, 16 P^{NP}[1], 20 ATIME[poly], 23 (F)P, 23 1-NP, 15, 29 US, 30 (F^{(α)})P, 33 ({f}^{(α)})P, 34 Leaf^{P}(A), 58 Leaf^{P}(C), 58 Leaf^{P}(A, R), 59 BalancedLeaf^{P}(A), 59 BalancedLeaf^{P}(C), 59 BalancedLeaf^{P}(A, R), 59 HG, 65 H_{α} · P, 66 TMOD_{(t,m,γ)}P, 70 {a, b}P, 101

Operatoren

F ∘ G, 50 G/U, 64 ⟨F ⟩, 25 co-C, 17 C_{1} ⊕ C_{2}, 17 C_{1}∨^{·} C_{2}, 18 C_{1} ∨ C_{2}, 17 C_{1} ∧ C_{2}, 17 C_{1}C^{2}, 10 C^{A}, 10 C^{B}, 20 P^{B}, 20 Δ′C, 18 Θ′C, 18 ∃C, 18 ∀C, 18 A-C, 18 BH(C), 14

Reduktionstypen

≤_{m}^{p}, 25 ≤_{T}^{P}, 20 ≤_{T}^{NP}, 57 ≤_{m}^{plt}, 86

Begriffe

Ablehnungsmenge, 59 Abschluß, 25 Abschlußeigenschaft, 111 einfache, 111 starke, 112

Abschlußeigenschaften, 41

Akzeptanztyp HG-, 66 assoziativer, 62 boolescher lokal definierbarer,

26 lokal definierbarer, 23 akzeptierender F -Baum, 25 Akzeptierung, 24 Akzeptierungsmenge, 65 Akzeptierungsmodell zweistufiges, 50 Akzeptierungswerte, 24 Alphabet, 11 Anzahlklassen

beschränkte, 15

schließlich periodische, 16 arm, 42

Baumauswertungsphase, 22, 23 Baumtraversierungsalgorithmus, 60 BCS-Theorem, 85 Berechnung

ablehnende, 10 akzeptierende, 10 Berechnungsbaum, 9 binaryclosure, 45 Binomialkoeffizient, 10 Blattsprachen, 57 Blattwort, 58 boolesche Funktionen, 25

Counting-Operator, 13 Counting classes, 16

D^{P}, 14 deterministische Turing-Maschine, 9 direktes Produkt, 70 DTM, 9

Einführung zusätzlicher Variablen,

25 erweiterbar, 81 Erzeugungsphase, 23 existentiell, 12

F -Baum

akzeptierender, 25 Faktorgruppe, 64 Funktion

charakteristische, 11

GapP, 17 gleichmäßige (r, s)-H-Sequenz, 89 Größe, 87 Gruppe

auflösbare, 64 Faktor-, 64 kommutative, 64

H_{t,m,k}, 71 H-Sequenz, 88 Halbgruppe, 63

aperiodische, 64 idempotente, 65 von einem Element erzeugte, 70

HG-Akzeptanztyp, 66 Hierarchie

boolesche, 14 Polynomialzeit-, 13

Hypergraph, 87

(r, s)-, 88

Hypergraph-Sequenz, 88

gleichmäßige, 88 Hypergraphenmethode, 87 Hyperkante, 88

Identifizierung von Variablen, 25 Indexband, 86

Join, 17

k-wertige Funktionen, 23 Knoten, 88 Knoten von der Sorte k, 88 Kommutator, 79 Kommutator-Untergruppe, 79

Länge, 11 Leaf language, 58 leafstring^{M}(x), 58

m-n-Monotonie-Bedingung, 89 M_{t,m,k}, 71 Maschine

C-, 20

alternierende, 12 balancierte, 58 empfindliche alternierende, 16

Menge von Akzeptierungswerten, 24 minimalrepresentative, 46 MOD_{m}C, 18 mod_{q,i}, 83 Monoid, 63

aperiodisches, 64 idempotentes, 65 syntaktisches, 63

Monotoniegebiet, 89 Multinomialkoeffizient, 11 nichtdeterministische

Turing-Maschine, 9 normale polylog-Funktion, 91 normale polylog-Reduktions-

Funktion, 91 Normalform, 33, 91 Normalteiler, 64 NTM, 9

ODER-Funktion, 22 Orakel, 10

plt-Funktion, 86 plt-reduzierbar, 86 polylog-Funktion

normale, 91 polylog-Reduktions-Funktion

normale, 91 polylogarithmische Zeit, 85 Polynomialzeit-Turing-Maschine, 9 Post, 26 Prädikat, 25 Promise-Klasse, 12

Ramsey-Theorem, 98 Reduktion

reguläre, 55 (r, s)-H-Sequenz, 89

gleichmäßige, 89 (r, s)-Hypergraph, 88

S(H), 64 Sequenz

(r, s)-H-, 89

H-, 88

Hypergraph-, 88 Substitution, 25 T (x), 21 Trennung, 85 truth-table-Reduktion, 53 k-beschränkte, 54

tt-Reduktion disjunktive, 55 konjunktive, 55 Turing-Abschluß, 56 Turing-Maschine, 9

deterministische, 9 nichtdeterministische, 9 Polynomialzeit-, 9 Turing-Reduktion, 20

verallgemeinerte, 57 Turing-reduzierbar C-, 20 Polynomialzeit-, 20

unaryclosure, 43 UND-Funktion, 22 universell, 12

Vereinigung

P-trennbare, 18 Vertauschung von Variablen, 25 Vertreter, 77 ≤_{m}^{p}-vollständige Probleme, 25

Zählklassen, 16

Zustandsübergangstafel, 24 zweistufige Berechnung, 50 zweistufiges Akzeptierungsmodell,

50 zweiwertiger Fall, 25

Literatur

[1] T. Baker, J. Gill, R. Solovay, Relativizations of the P =? NP question; SIAM Journal on Computing 4 (1975), 431–441.

[2] J. L. Balcázar, J. Díaz, J. Gabarró, Structural Complexity I; Springer Verlag (Berlin – Heidelberg – New York, 1988).

[3] J. L. Balcázar, J. Díaz, J. Gabarró, Structural Complexity II; Springer Verlag (Berlin – Heidelberg – New York, 1990).

[4] D. A. Barrington, Bounded-width polynomial-size branching programs recognize exactly those languages in NC^{1}; Journal Comp. & System Sciences 38 (1989), 150–164.

[5] D. A. Barrington, H. Straubing, D. Thérien, Non-uniform automata over groups; Information & Computation 89 (1990), 109–132.

[6] D. A. Barrington, D. Thérien, Finite monoids and the fine structure of NC^{1}; Journal of the ACM 35 (1988), 941–952.

[7] M. Beaudry, P. McKenzie, Circuits, matrices, and nonassociative computation; Proceedings of the 7th Structure in Complexity Theory Conference (1992), 94–106.

[8] M. Beaudry, P. McKenzie, P. Péladeau, Circuits with monoidal gates; Proceedings of the 10th Symp. on Theoretical Aspects of Computer Science (1993), LNCS 665, 555–565.

[9] R. Beigel, On the relativized power of additional accepting paths; Proceedings of the 4th Structure in Complexity Theory Conference (1989), 216– 224.

[10] R. Beigel, Relativized counting classes: Relations among thresholds, parity, and mods; Journal of Computer and System Sciences 42 (1991), 76–96.

[11] R. Beigel, Bounded queries to SAT and the boolean hierarchy; Theoretical Computer Science 84 (1991), 199–223.

[12] R. Beigel, J. Gill, U. Hertrampf, Counting classes: Thresholds, parity, mods, and fewness; Proceedings of the 7th Symp. on Theoretical Aspects of Computer Science (1990), LNCS 415, 49–57.

[13] R. Beigel, J. Gill, Counting classes: Thresholds, parity, mods, and fewness; Theoretical Computer Science 103 (1992), 3–23.

[14] C. Bennett, J. Gill, Relative to a random oracle A, P^{A} ≠ NP^{A} ≠ co-NP^{A} with probability 1; SIAM Journal on Computing 10 (1981), 96–112.

[15] M. Blum, R. Impagliazzo, Generic oracles and oracle classes; Proceedings of the 28th Symp. on Foundations of Computer Science (1987), 118– 126.

[16] D. P. Bovet, P. Crescenzi Introduction to the theory of complexity, Prentice Hall International (1994).

[17] D. P. Bovet, P. Crescenzi, R. Silvestri, Complexity classes and sparse oracles; Proceedings of the 6th Structure in Complexity Theory Conference (1991), 102–108.

[18] D. P. Bovet, P. Crescenzi, R. Silvestri, A uniform approach to define complexity classes; Theoretical Computer Science 104 (1992), 263–283.

[19] B. Borchert, On the acceptance power of regular languages; Proceedings of the 11th Symp. on Theoretical Aspects of Computer Science (1994), LNCS 775, 533–544.

[20] B. Borchert, Predicate classes and promise classes; Proceedings of the 9th Structure in Complexity Theory Conference (1994), 235–241.

[21] G. Buntrock, C. Damm, U. Hertrampf, C. Meinel, Structure and importance of logspace-MOD-classes; Mathematical Systems Theory 25 (1992), 223–237.

[22] J. Cai, With probability one, a random oracle separates PSPACE from the polynomial-time hierarchy; Proceedings of the 18th ACM Symp. on Theory of Computing (1986), 21–29.

[23] J. Cai, T. Gundermann, J. Hartmanis, L. Hemachandra, V. Sewelson, K. W. Wagner, G. Wechsung, The boolean hierarchy I: Structural properties; SIAM Journal on Computing 17:6 (1988), 1232-1252.

[24] J. Cai, T. Gundermann, J. Hartmanis, L. Hemachandra, V. Sewelson, K. W. Wagner, G. Wechsung, The boolean hierarchy II: Applications; SIAM Journal on Computing 18:1 (1989), 95–111.

[25] J. Cai, L. Hemachandra, The boolean hierarchy: Hardware over NP; Proceedings of the 1st Structure in Complexity Theory Conference (1986), LNCS 223, 105–124.

[26] J. Cai, L. Hemachandra, On the power of parity polynomial time; Proceedings of the 6th Symp. on Theoretical Aspects of Computer Science (1989), LNCS 349, 229–239.

[27] J. Cai, G. Meyer, Graph minimal uncolorability is D^{P} -complete; SIAM Journal on Computing 16 (1987), 259–277.

[28] A. Chandra, D. Kozen, L. Stockmeyer, Alternation; Journal of the ACM 28 (1981), 114–133.

[29] K. Cronauer, Ein Kriterium zur Trennung von Komplexitätsklassen durch Orakel; Diplomarbeit, Universität Würzburg, Institut für Informatik, 1994.

[30] S. Eilenberg, Automata, Languages, and Machines, Vol. B; Academic Press (New York – San Francisco – London, 1976).

[31] S. Fenner, L. Fortnow, S. Kurtz, Gap-definable counting classes; Proceedings of the 6th Structure in Complexity Theory Conference (1991), 30–42.

[32] M. Garey, D. Johnson, Computers and intractability: A guide to the theory of NP-completeness; Freeman & Co. (New York, 1979).

[33] L. M. Goldschlager, I. Parberry, On the construction of parallel computers from various bases of boolean functions, Theoretical Computer Science 43 (1986), 43–58.

[34] R. Graham, B. Rothschild, J. Spencer, Ramsey theory; John Wiley & Sons (New York, 1980).

[35] T. Gundermann, N.A. Nasser, G. Wechsung, A survey on counting classes; Proceedings of the 5th Structure in Complexity Theory Conference (1990), 140–153.

[36] T. Gundermann, G. Wechsung, Nondeterministic Turing machines with modified acceptance; Proceedings of the 12th Symposium on Mathematical Foundations of Computer Science (1986), LNCS 233, 396–404.

[37] T. Gundermann, G. Wechsung, Counting classes of finite acceptance types; Computers and Artificial Intelligence 6 (1987), 395–409.

[38] U. Hertrampf, Relations among MOD-classes, Theoretical Computer Science 74 (1990), 325–328.

[39] U. Hertrampf, Locally definable acceptance types for polynomial time machines; Proceedings of the 9th Symp. on Theoretical Aspects of Computer Science (1992), LNCS 577, 199–207.

[40] U. Hertrampf, Locally definable acceptance types — the three valued case; 1st Latin American Symp. on Theoretical Informatics (1992), LNCS 583, 262–271.

[41] U. Hertrampf, Locally definable acceptance types — the three valued case; Technical Report No. 29, Universität Würzburg (1992).

[42] U. Hertrampf, Complexity classes with finite acceptance types; Proceedings of the 11th Symp. on Theoretical Aspects of Computer Science (1994), LNCS 775, 543–553.

[43] U. Hertrampf, C. Lautemann, T. Schwentick, H. Vollmer, K.W. Wagner, On the power of polynomial time bit-reductions; Proceedings of the 8th Structure in Complexity Theory Conference (1993), 200–207.

[44] U. Hertrampf, H. Vollmer, K.W. Wagner, On balanced vs. unbalanced computation trees; Technical Report, Universität Würzburg (1994).

[45] J. E. Hopcroft, J. D. Ullman, Introduction to Automata Theory, Languages, and Computation, Addison-Wesley Publishing Company (Reading, Mass., 1979).

[46] S. W. Jablonski, G. P. Gawrilow, W. B. Kudrjawzew, Boolesche Funktionen und Postsche Klassen, Akademie-Verlag (Berlin, 1970).

[47] B. Jenner, P. McKenzie, D. Thérien, Logspace and logtime leaf languages; Proceedings of the 9th Structure in Complexity Theory Conference (1994), 242–254.

[48] J. Kadin, The polynomial hierarchy collapses if the boolean hierarchy collapses; SIAM Journal on Computing 17 (1988), 1263–1282.

[49] J. Köbler, S. Toda, On the power of generalized MOD-classes; Proceedings of the 8th Structure in Complexity Theory Conference (1993), 147– 155.

[50] J. Köbler, U. Schöning, S. Toda, J. Torán, Turing machines with few accepting computations and low sets for PP; Proceedings of the 4th Structure in Complexity Theory Conference (1989), 208–215.

[51] J. Köbler, U. Schöning, K. W. Wagner, The difference and truthtable hierarchies for NP; RAIRO Inform. Theor. 21:4 (1987), 419–435.

[52] C. Lund, L. Fortnow, H. Karloff, N. Nisan, Algebraic methods for interactive proof systems; Proceedings of the 31st Symp. on Foundations of Computer Science (1990), 2–10.

[53] P. McKenzie, D. Thérien, Automata theory meets circuit complexity; Proceedings of the 16th International Colloquium on Automata, Languages and Programming (1989) LNCS 372, 589–602.

[54] P. McKenzie, P. Péladeau, D. Thérien, NC^{1}: The automatatheoretic viewpoint; Computational Complexity 1 (1991), 330–359.

[55] R. Niedermeyer, P. Rossmanith, Extended locally definable acceptance types; Proceedings of the 10th Symp. on Theoretical Aspects of Computer Science (1993), LNCS 665, 473–483.

[56] M. Ogiwara, L. Hemachandra, A complexity theory for feasible closure properties; Journal Comp. & System Sciences 46 (1993), 295–325.

[57] M. Ogiwara, T. Thierauf, S. Toda, O. Watanabe, On closure properties of #P in the context of PF∘#P; Proceedings of the 8th Structure in Complexity Theory Conference (1993), 139–146.

[58] C. Papadimitriou, D. Wolfe, The complexity of facets resolved; Proceedings of the 26th Symp. on Foundations of Computer Science (1985), 74–78.

[59] C. Papadimitriou, M. Yannakakis, The complexity of facets (and some facets of complexity); Proceedings of the 14th ACM Symp. on Theory of Computing (1982), 255–260.

[60] C. Papadimitriou, S. Zachos, Two remarks on the power of counting; Proceedings of the 6th GI Conference on Theoretical Computer Science (1983), LNCS 145, 269–276.

[61] E. L. Post, Introduction to a general theory of elementary propositions; American Journal of Math. 43 (1921), 163–185.

[62] E. L. Post, Two-valued iterative systems, Monographie (1941).

[63] F. P. Ramsey, On a problem of formal logic; Proceedings London Math. Soc. 30 (1930), 264–286.

[64] K. R. Reischuk, Einführung in die Komplexitätstheorie, Teubner (Stuttgart, 1990).

[65] U. Schöning, Complexity and Structure, Springer-Verlag, LNCS 211 (Berlin – Heidelberg, 1986).

[66] U. Schöning, The power of counting; Proceedings of the 3rd Structure in Complexity Theory Conference (1988), 2–18.

[67] A. Shamir, IP = PSPACE; Proceedings of the 31st Symp. on Foundations of Computer Science (1990), 11–15.

[68] M. Sipser, On relativization and the existence of complete sets; Proceedings of the 9th ICALP Conference (1982), LNCS 140, 523–531.

[69] L. Stockmeyer, The polynomial-time hierarchy; Theoretical Computer Science 3 (1977), 1–22.

[70] H. Straubing, Families of recognizable sets corresponding to certain varieties of finite monoids; Journal of Pure and Applied Algebra 15 (1979), 319–327.

[71] H. Straubing, The variety generated by finite nilpotent monoids; Semigroup Forum 24 (1982), 25–38.

[72] D. Thérien, Classification of finite monoids: The language approach; Theoretical Computer Science 14 (1981), 195–208.

[73] S. Toda, PP is as hard as the polynomial-time hierarchy, SIAM Journal on Computing 20 (1991), 865–877.

[74] S. Toda, M. Ogiwara, Counting classes are at least as hard as the polynomial-time hierarchy, Proceedings of the 6th Structure in Complexity Theory Conference (1991), 2–12, SIAM Journal on Computing 21:2 (1992), 316–328.

[75] J. Torán, Structural properties of the counting hierarchies; Dissertation (Barcelona, 1988).

[76] J. Torán, A combinatorial technique for separating counting complexity classes; Proceedings of the 16th ICALP Conference (1989), LNCS 372, –.

[77] L. Valiant, The relative complexity of checking and evaluating; Information Processing Letters 5 (1976), 20–23.

[78] L. Valiant, The complexity of computing the permanent, Theoretical Computer Science 8 (1979), 189–201.

[79] O. Verbitsky, Towards the Parallel Repetition Conjecture, Proceedings of the 9th Structure in Complexity Theory Conference (1994), 304–307.

[80] B. L. van der Waerden, Algebra I, 8. Auflage, Springer-Verlag (Berlin – Heidelberg – New York, 1971).

[81] B. L. van der Waerden, Algebra II, 5. Auflage, Springer-Verlag (Berlin – Heidelberg – New York, 1967).

[82] K. W. Wagner, The complexity of combinatorial problems with succinct input representation; Acta Informatica 23 (1986), 325–356.

[83] K. W. Wagner, More complicated questions about maxima and minima, and some closures of NP; Theoretical Computer Science 51 (1987), 53–80.

[84] K. W. Wagner, Bounded query classes; SIAM Journal on Computing 19:5 (1990), 833–846.

[85] K. W. Wagner, Alternating machines using partially defined “AND” and “OR”; Technical Report 39, Universität Würzburg (1992).

[86] K. W. Wagner, G. Wechsung, Computational Complexity, VEB Deutscher Verlag der Wissenschaften (Berlin, 1986) und Reidel Verlag (Dordrecht, 1986).

[87] G. Wechsung, K. W. Wagner, On the boolean closure of NP; Proceedings of the 5th Conference on Fundamentals of Computation Theory (1985), LNCS 199, 485–493.

[88] A. Yao, Separating the polynomial-time hierarchy by oracles; Proceedings of the 26th Symp. on Foundations of Computer Science (1985), 1–10.