Komplexitätsklassen

Bemerkung: Zur Wiederholung wird noch einmal definiert, was eine Rechnung einer Turingmaschine ist.

Rechnung:  Sei M eine Turingmaschine. Eine Rechnung von M bei Eingabe w ist eine Folge von Konfigurationen (α0,,αm) mit α0=Start(w) und αi1αi für i=1,,m. Die Berechnung ist erfolgreich, falls αmAccept.

Zeitbedarf:  Der Zeitbedarf der Berechnung (α0,,αm) ist m.
Der Zeitbedarf einer Turingmaschine M bei Eingabe w ist NN, falls jede Berechnung von M bei Eingabe w Zeitbedarf N hat.

Platzbedarf:  Der Platzbedarf der Berechnung (α0,,αm) ist maxi=0,,m|αi|.
Der Platzbedarf einer Turingmaschine M bei Eingabe w ist NN, falls jede Berechnung von M bei Eingabe w Platzbedarf N hat.

Komplexitätsklassen:  Seien t,s:N0N0 monoton steigende Funktionen.
Dann sind folgende Komplexitätsklassen definiert:

  • DTIME(t):={LΣ|es gibt eine det. TM M mit L=L(M),
    die auf allen Eingaben der Länge n Zeitbedarf max{t(n),n+1} hat}

  • NTIME(t):={LΣ|es gibt eine nicht-det. TM M mit L=L(M),
    die auf allen Eingaben der Länge n Zeitbedarf max{t(n),n+1} hat}

  • DSPACE(s):={LΣ|es gibt eine det. TM M mit L=L(M),
    die auf allen Eingaben der Länge n Platzbedarf s(n) hat}

  • NSPACE(s):={LΣ|es gibt eine nicht-det. TM M mit L=L(M),
    die auf allen Eingaben der Länge n Platzbedarf s(n) hat}

Für eine Komplexitätsklasse C ist CoC:={LΣ|ΣLC} die Komplexitätsklasse aller Komplemente.

Bemerkung: Für DTIME(t) und NTIME(t) werden nur Funktionen t:N0N0 mit t(n)n für alle nN betrachtet. Das erlaubt, die ganze Eingabe einzulesen (tatsächlich werden nämlich n+1 Schritte zugelassen).
Für DSPACE(s) und NSPACE(s) werden nur Funktionen s:N0N0 mit sΩ(log2n) betrachtet. Das erlaubt, eine Position i{1,,n} auf dem Arbeitsband abzuspeichern (in binärer Darstellung).

gebräuchliche Komplexitätsklassen: 

  • L:=DSPACE(logn)

  • NL:=NSPACE(logn)

  • P:=kNDTIME(nk)

  • NP:=kNNTIME(nk)

  • PSPACE:=kNDSPACE(nk)=kNNSPACE(nk)

Bemerkung: Die letzte Gleichung folgt aus dem Satz von Savitch, der weiter unten noch kommt.

Bemerkung: Es gelten die Beziehungen LNLPNPCoNPNPPSPACE.
Bei keiner von den Inklusionen ist jedoch bekannt, ob sie echt ist oder nicht.
Außerdem gilt NLkNDSPACE(log2kn)=kNNSPACE(log2kn)DSPACE(n)
NSPACE(n)=CoNSPACE(n)PSPACE(n). Bei DSPACE(n)NSPACE(n) ist ebenfalls nicht bekannt, ob diese Inklusion echt ist (1. LBA-Problem).

Beispiel:

  • Es gilt {anbncn|nN}L: Eine TM, die die Sprache erkennt, muss sich nur speichern, wie viele a’s am Anfang gelesen wurden. Dafür wird nur logarithmischer Platz benötigt.

  • Außerdem gilt {w$wR|wΣ},{wwR|wΣ}L: Bei der ersten Sprache geht man zunächst zum Dollarzeichen in der Mitte, anschließend vergleicht man die Zeichen von der Mitte ausgehend (also zunächst die neben dem Dollar, dann die Nachbarn von diesen usw.). Dafür muss man die aktuelle Position (logarithmischer Platz) abspeichern).
    Bei der zweiten Sprache ist das ein wenig schwieriger, aber hier prüft man zunächst, ob die Länge des Wortes ungerade ist, und läuft dann zur Mitte des Worts (dann verfährt man wie bei der anderen Sprache).

  • Es gilt {w$w|wΣ},{ww|wΣ}L: Hier geht man wie eben vor, nur dass die Buchstaben jeweils von vorne verglichen werden.

  • {p1{0,1}|p Binärdarstellung einer Primzahl} ist in P (das wurde erst 2002 mit der Entdeckung des AKS-Primzahltests gezeigt, vorher war nur Mitgliedschaft in NPCoNP bekannt).

Algorithmische Probleme

Traveling Salesman Problem (TSP):  Sei G=(V,E,γ) ein gerichteter, gewichteter Graph mit Knotenmenge V={1,,n}, Kantenmenge EV×V und Kantengewichtungsfunktion γ:EN (d. h. γ(e)>0 für alle eE).
Ein Rundweg W ist eine Folge W=(x0,,xn) mit x0=xn, xixj für ij und (xi1,xi)E für i=1,,n.
Die Kosten γ(W) des Rundwegs W sind γ(W)=i=1nγ(xi1,xi).
Dann sind folgende Varianten des Traveling Salesman Problems (TSP) definiert:

  • Entscheidungsvariante: Gegeben ist G und k0.
    Gefragt ist, ob ein Rundweg mit Kosten k exisiert.

  • Berechnungsvariante: Gegeben ist G und k0.
    Gesucht ist ein Rundweg W mit γ(W)k, falls ein solcher existiert.

  • Optimierungsproblem: Gegeben ist G.
    Gesucht ist ein Rundweg W mit kleinstmöglichen Kosten
    (d. h. γ(W)γ(W) für alle Rundwege W).

In allen drei Varianten ist die Eingabegröße bis auf einen konstanten Faktor gleich
|V|+eElog2γ(e)(+log2k).

Satz ((A)P(C)P): Ist (A) in Polynomialzeit lösbar, so auch (C).

Beweis:

  • Überprüfe, ob überhaupt ein Rundweg existiert. Dazu ruft man (A) mit kmax=eEγ(e) auf, denn jeder Rundweg hat Kosten kmax. Im Folgenden wird die Existenz eines Rundwegs vorausgesetzt.

  • Berechne kopt=min{γ(W)|W Rundweg} mittel binärer Suche:

    kmin:=0;while(kmin<kmax)dokmitte:=kmin+kmaxkmin2;if(Rundweg Wγ(W)kmitte)thenkmax:=kmitte;elsekmin:=kmitte+1;endifendwhilereturnkmin; Die Anzahl der Durchläufe der While-Schleife ist beschränkt durch
    log2kmax=log2(eEγ(e))eElog2γ(e).

  • Berechne einen optimalen Rundweg mit E={e1,,em} wie folgt:

    G0:=G;fori:=1tomdoif(Rundweg W in Gi1{ei}γ(W)kopt)thenGi:=Gi1{ei};elseGi:=Gi1;endifendforreturnGm;

  ƒ

Vertex Cover (VC):  Sei G=(V,E) ein ungerichteter Graph.
Eine Teilmenge CV heißt Knotenüberdeckung (oder Träger) von G, falls für jede Kante {u,v}E gilt, dass {u,v}C.
Dann sind folgende Varianten von Vertex Cover (VC) definiert:

  • Entscheidungsvariante: Gegeben ist G und k0.
    Gefragt ist, ob eine Knotenüberdeckung von G mit |C|k existiert.

  • Berechnungsvariante: Gegeben ist G und k0.
    Gesucht ist eine Knotenüberdeckung C von G mit |C|k, falls eine solche existiert.

  • Optimierungsproblem: Gegeben ist G.
    Gesucht ist eine kleinstmögliche Knotenüberdeckung C von G
    (d. h. |C||C| für alle Knotenüberdeckungen C von G).

Satz ((A)P(C)P): Ist (A) in Polynomialzeit lösbar, so auch (C).

Grapherreichbarkeitsproblem (GAP):  Das Grapherreichbarkeitsproblem (GAP) ist wie folgt definiert: Gegeben ist ein gerichteter Graph G=(V,E) und zwei Knoten s,tV.
Gefragt ist, ob ein Pfad in G von s nach t existiert.

Bemerkung: GAP gehört zur Klasse P: GAP kann in Zeit O(|V|) mittels Breitensuche gelöst werden (mit der einfachsten Dijkstra-Variante).
Es gilt sogar die Verschärfung, dass GAP zur Klasse NL gehört (später wird NLP gezeigt):

v:=s;while(vt)dowähle einen Knoten wV mit (v,w)E;v:=w;endwhilereturn„es gibt einen Pfad in G von s nach t; Dieser nicht-det. Algorithmus kann man leicht auf einer nicht-det. TM implementieren. Der Algorithmus benötigt nur logarithmischen Platz, weil er sich zu jedem Zeitpunkt nur einen Knoten vV merken muss und dieser binär mit log2n vielen Bits abgespeichert werden kann (wenn man V mit {1,,n} identifiziert).

Bemerkung: Aus dem Satz von Savitch weiter unten folgt GAP DSPACE(log22n).
Man konnte 2004 zeigen, dass das Grapherreichbarkeitsproblem für ungerichtete Graphen
UGAP zur Klasse L gehört.

Beziehungen zwischen den Komplexitätsklassen

Komplexitätsklassen in Landau-Notation: 
Man definiert DTIME(O(f))=cNDTIME(cf)=gO(f)DTIME(g).
Analog sind NTIME(O(f)), DSPACE(O(f)) und NSPACE(O(f)) definiert.

Satz (Beziehungen zwischen den Komplexitätsklassen): Sei f:NN eine Funktion.

  • Für X{D,N} gilt XSPACE(O(f))=XSPACEEinband(f)
    (Bandreduktion mit Bandkompression).

  • Aus ε>0nNf(n)(1+ε)n folgt, dass DTIME(O(f))=DTIME(f)
    (deterministische Zeitkompression).

  • Es gilt NTIME(O(f))=NTIME(f)
    (nicht-deterministische Zeitkompression).

  • Es gilt DTIME(n)DTIME(O(n)).

Bemerkung: Der folgende Satz stellt einen Bandreduktionssatz für Zeitkomplexitätsklassen dar.

Satz (Satz von Hennie und Stearns): Seien kN und f:NN mit nNf(n)n.
Dann gilt DTIMEk-Band(f)DTIME2-Band(flogf).

Satz (NTIME(f)DSPACE(f)):
Für f(n)n gilt DTIME(f)NTIME(f)DSPACE(f).

Beweis: Die erste Inklusion ist klar, zu zeigen ist also NTIME(f)DSPACE(f).

Sei M=(Q,Σ,Γ,δ,q0,F,) eine nicht-deterministische TM, die durch f(n) zeitbeschränkt ist. Für eine Eingabe wΣ der Länge n kann man sich alle Rechnungen von M in einem Berechnungsraum T(M,w) vorstellen, dessen Knoten Konfigurationen sind. Die Wurzel ist gleich Start(w) und die Kinder einer Konfiguration α sind alle Konfigurationen β mit αMβ.
Diesen Baum T(M,w) untersucht man jetzt durch Breitensuche auf eine akzeptierende Konfiguration. Dabei merkt man sich nur die aktuelle Konfiguration und das Protokoll Pδ, mit dem man diese Konfiguration von der Wurzel Start(w) erreichen kann.

Die Konfiguration zu merken benötigt den Platz f(n), da man nach f(n) vielen Schritten höchstens f(n) viele Felder des Bands beschrieben haben kann. Das Protokoll für eine bei Start(w) beginnende Berechnung hat höchstens Länge f(n) und kann somit in Platz O(f) gespeichert werden. Also ergibt sich ein gesamter Platzbedarf von O(f).

Nach obigem Satz hat man also den Platzbedarf DSPACE(O(f))=DSPACE(f).   ƒ

Satz (NSPACE(f)DTIME(2O(f))):
Für f(n)logn gilt DSPACE(f)NSPACE(f)DTIME(2O(f)).

Beweis: Die erste Inklusion ist klar, zu zeigen ist also NSPACE(f)DTIME(2O(f)).

Sei M=(Q,Σ,Γ,δ,q0,F,) eine nicht-deterministische TM, die durch f(n) platzbeschränkt ist. Es gibt eine Konstante c>0, die nur von M abhängt, sodass die für eine Eingabe wΣ der Länge n die Anzahl der von Start(w) erreichbaren Konfigurationen durch cf(n) beschränkt ist. Hierbei ist f(n)logn wichtig.

Nun berechnet man die Menge R der von Start(w) aus erreichbaren Konfigurationen wie folgt (Markierungsalgorithmus oder Flutalgorithmus):

R:={Start(w)};whileα,β KonfigurationenαR,βR,αMβdoR:=R{β};endwhileifAcceptRthenreturnM akzeptiert w; R enthält maximal cf(n) Konfigurationen der Länge f(n). Der Test α,β Konfigurationen
αR,βR,αMβ kann somit in Zeit O(cf(n)cf(n)f(n))=O(c2f(n)f(n)) implementiert werden. Der gesamte Zeitbedarf des Algorithmus beträgt also O(c3f(n)f(n))2O(f).   ƒ

Folgerung:

  • LNLDTIME(2O(logn))=P

  • CS=LBA=NSPACE(n)DTIME(2O(n))
    (mit CS den kontextsensitiven und LBA den durch LBAs akzeptierten Sprachen)

  • DSPACE(n2)DTIME(2O(n2))

Der Satz von Savitch

platzkonstruierbar:  Sei f:NN eine Funktion mit fΩ(log(n)). Dann heißt f platzkonstruierbar, falls es eine deterministische Turingmaschine gibt, die bei Eingabe an (d. h. unäre Kodierung von n) genau f(n) Felder auf den Arbeitsbändern markiert, dann hält und bei der Berechnung diesen Platz nicht verlässt.

zeitkonstruierbar:  Sei f:NN eine Funktion mit fΩ(n). Dann heißt f zeitkonstruierbar, falls es eine deterministische Turingmaschine gibt, die bei Eingabe an (d. h. unäre Kodierung von n) nach genau f(n) Schritten hält.

Satz (Satz von  Savitch): Sei sΩ(logn). Dann gilt NSPACE(s)DSPACE(s2).

Beweis: Im Folgenden wird der Satz bewiesen unter der Annahme, dass s platzkonstruierbar ist. Der Satz ist auch für andere s beweisbar, allerdings ist dann der Beweis etwas schwieriger.

Sei also M eine durch s platzbeschränkte nicht-deterministische TM und w eine Eingabe für M. Sei außerdem Conf(M,w) die Menge aller Konfigurationen α, sodass auf dem Eingabeband die Eingabe w steht und |α|s(|w|). OBdA gebe es nur eine einzige akzeptierende Konfiguration αf. Für α,βConf(M,w) und iN0 ist das Prädikat Reach(α,β,i) definiert durch Reach(α,β,i)k2iαMkβ. Aus der Beschreibung von M kann man explizit eine Konstante c bestimmen, sodass es 2cs(|w|) Konfigurationen gibt, die nur s(|w|) viel Platz benötigen (insbesondere gilt Conf(M,w)2cs(|w|)). Damit gilt für alle Eingaben w, dass wL(M)Reach(Start(w),αf,cs(|w|)), denn keine Berechnung kann bei Eingabe w länger als 2cs(|w|) viel Zeit brauchen.

Das Ziel ist nun, das Prädikat Reach(α,β,i) für α,βConf(M,w) und i{0,,cs(|w|)} mit Platz O(s2) durch eine deterministische TM zu berechnen. Für i>0 verwendet man dabei das Rekursionsschema γConf(M,w)(Reach(α,γ,i1)Reach(γ,β,i1)). Das kann man in einen deterministischen Algorithmus umsetzen:

b:=false;ifi=0thenb:=((α=β)(αMβ));elseforallγConf(M,w)doif((¬b)Reach(α,γ,i1))thenb:=Reach(γ,β,i1);endforendifreturnb;

Zu zeigen ist, dass ein Aufruf von Reach(α,β,i) den Platz O((i+1)s(|w|)) benötigt. Man kann das induktiv zeigen: Für i=0 kann die Bedingung ((α=β)(αMβ)) in O(s(|w|)) geprüft werden. Für i>0 benötigt der erste Aufruf Reach(α,γ,i1) nach Induktionsvoraussetzung den Platz O(is(|w|)). Das gleiche gilt auch für den zweiten Aufruf Reach(γ,β,i1), aber hier kann der Platz, der für den ersten Aufruf benötigt wurde, wiederverwendet werden. Zusätzlich benötigt man noch den Platz s(|w|), um die Konfiguration γ zu speichern. Also benötigt man insgesamt den Platz O((i+1)s(|w|)).

Um wL(M) zu entscheiden, kann man noch obiger Bemerkung Reach(Start(w),αf,cs(|w|)) testen. s(|w|) kann man berechnen, weil s nach Annahme platzkonstruierbar ist. Also ist der gesamte Platzbedarf O(cs(|w|)s(|w|))=O(s(|w|)2).   ƒ

Bemerkung: Der Satz von Savitch besagt, dass eine nicht-deterministische platzbeschränkte TM unter quadratischem Mehraufwand deterministisch simuliert werden kann. Diese platzeffiziente Simulation wird durch einen extremen Mehraufwand an Rechenzeit realisiert.

Folgerung: GAP ist in DSPACE(log2n), da GAP in NL ist.
PSPACE=kNDSPACE(nk)=kNNSPACE(nk),
da NSPACE(nk)DSPACE(n2k). Daher wurde auch so etwas wie NPSPACE nicht definiert, weil das gleich PSPACE wäre.

Hierarchiesätze

Satz (Platzhierarchiesatz):
Seien s1,s2:NN Funktionen mit s2 platzkonstruierbar, s2Ω(logn) und s2O(s1).
Dann gilt DSPACE(s2)DSPACE(s1), d. h. DSPACE(s2)DSPACE(s1).

Beweis: Wegen s2O(s1) gilt ε>0nNs1(n)εs2(n).
Zu zeigen ist LDSPACE(s2)LDSPACE(s1).

Wähle zunächst eine berechenbare binäre Kodierung von deterministischen TM, d. h. eine berechenbare Funktion xMx, sodass zu jeder deterministischen TM M eine Kodierung x1{0,1} mit L(M)=L(Mx) existiert (jedes Wort x1{0,1} soll also als Kodierung einer TM Mx interpretiert werden können). Für beliebige x1{0,1} und kN gelte dabei M0kx:=Mx. Somit hat jede TM eine Kodierung in fast allen Längen. Im Folgenden wird eine TM M konstruiert mit L(M)DSPACE(s2)DSPACE(s1).

Dazu wird zunächst eine durch s2 platzbeschränkte TM M konstruiert, die auf Eingabe y mit |y|=n wie folgt arbeitet: Zuerst markiert M den Platz s2(n) auf den Arbeitsbändern (geht, da s2 platzkonstruierbar). Sobald danach der markierte Platz verlassen wird, stoppt M und akzeptiert y nicht – damit ist M automatisch s2-platzbeschränkt und es gilt L(M)DSPACE(s2). Jetzt führt M die Maschine My=Mx mit y=:0kx und x1{0,1} auf der Eingabe y aus. Danach akzeptiert M die Eingabe y genau dann, wenn Mx die Eingabe y akzeptiert (und dabei der markierte Platz nicht verlassen wird).

Da deterministische Platzklassen unter Komplement effektiv abgeschlossen sind, kann man eine TM M konstruieren mit L(M)={0,1}L(M)DSPACE(s2). Angenommen, es gelte L(M)DSPACE(s1). Es ist L(M)=L(Mx) für ein x1{0,1}. Sei sx die Platzfunktion von Mx. Wegen L(M)DSPACE(s1) gilt nNsx(n)s1(n). Es gibt eine Konstante cx, sodass die Simulation von Mx auf Eingabe y mit |y|=n den Platz cxsx(n) kostet. Wähle ε>0 mit cxε<1. Wenn man nN mit n>|x| und s1(n)εs2(n) wählt (geht nach der Voraussetzung s1Ω(s2)) und y:=0kx mit |y|:=n setzt, dann gilt cxs1(n)cxεs2(n)<s2(n), also reicht der Platz s2(n) aus.

Es gilt daher yL(M)yL(M)yL(Mx)=L(M), ein Widerspruch (für die zweite Äquivalenz benötigt man, dass der Platz s2(n) ausreicht).   ƒ

Folgerung: Aus dem Platzhierarchiesatz folgt LDSPACE(log2n)DSPACE(n)
NSPACE(n)DSPACE(n2.1)PSPACE.

Satz (Zeithierarchiesatz):
Seien t1,t2:NN Funktionen mit t2 zeitkonstruierbar, t2Ω(nlogn) und t2O(t1logt1).
Dann gilt DTIME(t2)DTIME(t1), d. h. DTIME(t2)DTIME(t1).

Folgerung: Aus dem Zeithierarchiesatz folgt DTIME(O(n))DTIME(O(n2))P
DTIME(O(2n)DTIME(O((2+ε)n)).

Lückensatz von Borodin

Bemerkung: Der Lückensatz von Borodin besagt, dass es in der Hierarchie von Komplexitätsklassen beliebig große Lücken gibt. Egal wie groß r im folgenden Satz gewählt wird, es gibt immer eine Funktion s, sodass vom Übergang von DTIME(s) zu DTIME(rs) keine neuen Elemente dazukommen, d. h. es gibt eine Lücke zwischen DTIME(s) und DTIME(rs). s kann nicht zeitkonstruierbar sein, denn sonst wäre das ein Widerspruch zum Zeithierarchiesatz.

Satz (Lückensatz von  Borodin):
Sei r:NN eine überall definierte, berechenbare Funktion mit nNr(n)n.
Dann gibt es effektiv eine überall definierte, berechenbare Funktion s:NN mit
nNs(n)n+1 und DTIME(s)=DTIME(rs).

Beweis: Seien M1,M2 eine Aufzählung aller deterministischen TM und tk(n)N{} der tatsächliche maximale Zeitbedarf einer Rechnung von Mk auf einer Eingabe der Länge n. Betrachte die Menge Nn:={tk(n)|1kn}. Diese Menge ist endlich, denn |Nn|n. Also gibt es für alle nN ein s(n) mit Nn[s(n),r(s(n))]=.

Einen passenden, berechenbaren Wert s(n) kann man durch folgenden Algorithmus ermitteln:

s:=n+1;dos:=s+1;untilkntk(n)[s,r(s)]returns; Somit ist s(n) überall definiert, berechenbar und es gilt nNs(n)n+1.

Es gilt DTIME(s)=DTIME(rs):
“: Wegen nNr(n)n gilt DTIME(s)DTIME(rs).
“: Sei LDTIME(rs). Dann gibt es ein kN mit L=L(Mk) und Mk einer durch rs zeitbeschränkten, deterministischen TM. Es gilt nNtk(n)r(s(n)), denn es ist n. V. L(Mk)DTIME(rs). Wegen tk(n)Nn für nk und Nn[s(n),r(s(n))]= gilt also nktk(n)<s(n). Es gilt daher tk(n)s(n) für fast alle nN. Für die endlich vielen Ausnahmen lässt sich eine zweite TM konstruieren, die diese Ausnahmen abfängt, d. h. es gibt ein kN mit L(Mk)=L(Mk) und nNtk(n)s(n).
Somit gilt L=L(Mk)=L(Mk)DTIME(s).   ƒ

Der Satz von Immerman und Szelepcsényi

Bemerkung: Die Klassen DTIME und DSPACE sind unter Komplement abgeschlossen. Ob dies auch für NSPACE gilt, war lange Zeit offen. 1964 stellte Kuroda die Frage, ob die kontextsensitiven Sprachen unter Komplement abgeschlossen sind (2. LBA-Problem). Äquivalent dazu ist NSPACE(n)=CoNSPACE(n). Diese Frage konnte nach 20 Jahren von Immerman und Szelepcsényi positiv beantwortet werden.

Satz (Satz von Immerman und Szelepcsényi):
Sei fΩ(logn). Dann gilt NSPACE(f)=CoNSPACE(f).

Polynomialzeit-Reduktionen

Bemerkung: Zur Wiederholung wird noch einmal die Definition einer Reduktion angegeben.

Reduktion:  Seien LΣ und LΣ Sprachen. Dann heißt eine überall definierte, berechenbare Abbildung f:ΣΣ Reduktion von L auf L, falls xLf(x)L für alle xΣ. A heißt auf B reduzierbar (LL), falls es eine Reduktion von L auf L gibt.

Polynomialzeit-Reduktion:  Eine Reduktion f:ΣΣ von L auf L heißt
Polynomialzeit-Reduktion, falls sich f durch eine deterministische polynomialzeit-beschränkte Turingmaschine berechnen lässt.

Satz (Übertragbarkeit bei Polynomialzeit-Reduktionen): Seien LΣ und LΣ Sprachen, sodass es eine Polynomialzeit-Reduktion von L auf L gibt. Wenn LP gilt, dann auch LP.

Beweis: Seien LDTIME(nk) und f eine Polynomialzeit-Reduktion, die in Zeit n berechnet werden kann. Ist xΣ eine Eingabe der Länge n, dann kann f(x) in Zeit n berechnet werden. Anschließend wird f(x)L überprüft, dies geht in Zeit (n)k=nk, weil f(x) höchstens Länge n haben kann. Wegen xLf(x)L wurde xL in polynomialer Zeit n+nk überprüft, d. h. LP.   ƒ

Matching und Fluss als Beispiel für eine Polynomialzeit-Reduktion

bipartiter Graph:  G=(A,B,E) heißt bipartiter Graph, wenn EA×B und AB=.

Matching:  Sei G=(A,B,E) ein bipartiter Graph. Ein Matching ME eine Teilmenge von E, sodass keine zwei verschiedene Kanten aus M denselben Endknoten haben.

Bemerkung: Das Problem, ein Matching maximaler Größe zu berechnen, kann sehr effizient auf die Berechnung eines maximalen Flusses in einem Netzwerk reduziert werden.

Netzwerk:  Ein Netzwerk ist ein 5-Tupel N=(V,E,s,t,c), wobei

  • (V,E) ein gerichteter Graph (d. h. EV×V) ist,

  • s,tV mit st (Quelle und Senke) gilt und

  • c:EN jeder Kante eE eine Kapazität c(e)>0 zuordnet.

Fluss:  Ein Fluss F ist eine Abbildung F:EN0 mit

  • vV{s,t}(x,v)EF(x,v)=(v,y)EF(v,y) (Flusserhaltung)

  • eEF(e)c(e) (Kapazitätskonformität)

|F|:=(s,y)EF(s,y) ist die Größe des Flusses F.

Bemerkung: Ein Fluss maximaler Größe kann in polynomialer Zeit mittels des Algorithmus von Ford-Fulkerson (Max-Flow-Min-Cut-Theorem) berechnet werden.

Satz (Reduktion von Matching auf Fluss): Das Problem, ein maximales Matching zu berechnen, kann auf das Problem, einen maximalen Fluss zu berechnen, reduziert werden.
Genauer gilt: Sei G=(A,B,E) ein bipartiter Graph. Definiere ein Netzwerk N:=(V,E,s,t,c) mit V:=AB{s,t} (s,tAB), E:=E{(s,a)|aA}{(b,t)|bB} und c(x,y):=1 für alle (x,y)E. Ist nun F:EN0 ein Fluss maximaler Größe in N, dann ist M:={eE|F(e)=1} ein Matching maximaler Größe in G.

Logspace-Reduktionen

Bemerkung: Viele in der Praxis wichtige Reduktionen lassen sich in logarithmischem Platz berechnen. Deswegen definiert man Logspace-Reduktionen.

Logspace-Transducer:  Ein logarithmisch platzbeschränkter Transduktor
(Logspace-Transducer)
ist eine deterministische Turingmaschine M mit

  • einem Eingabeband, von dem nur gelesen werden kann,

  • einem logarithmisch in der Eingabelänge platzbeschränkten Arbeitsband und

  • einem getrennten Ausgabeband, auf das nur geschrieben werden kann (und der Schreibkopf bewegt sich nur nach rechts).

in Logspace berechenbar:  Eine Abbildung f:ΣΣ heißt in Logspace berechenbar, falls es einen Logspace-Transducer M gibt, sodass für alle xΣ der Transduktor M bei Eingabe x anhält und f(x)Σ auf dem Ausgabeband steht.

Logspace-Reduktion:  Seien LΣ und LΣ Sprachen. Dann heißt eine überall definierte, in Logspace berechenbare Abbildung f:ΣΣ Logspace-Reduktion von L auf L, falls xLf(x)L für alle xΣ. L heißt auf L in Logspace reduzierbar (LmlogL), falls es eine Logspace-Reduktion von L auf L gibt.

Bemerkung: Der Index m steht für many-one, was bedeutet, dass mehrere wΣ auf ein Wort in Σ abgebildet werden können.
Jede in Logspace berechenbare Abbildung f:ΣΣ ist in polynomialer Zeit berechenbar.

Bemerkung: Eine analoge Aussage der folgenden gilt trivialerweise für Polynomialzeit-Reduktionen. Für Logspace-Reduktionen muss man etwas arbeiten, denn man kann das Ergebnis der ersten Reduktion nicht einfach auf das Arbeitsband schreiben (nicht in logarithmischem Platz).

Satz (mlog ist transitiv): Seien LΣ, LΣ und LΣ mit LmlogLmlogL.
Dann gilt LmlogL.

Beweis: Seien f:ΣΣ bzw. g:ΣΣ Logspace-Reduktionen von L auf L bzw. von L auf L und wΣ eine Eingabe mit |w|=n. Dann wird g(f(w)) in Platz O(logn) wie folgt berechnet:

  • Starte den Logspace-Transducer zur Berechnung von g (ohne f(w) vorher zu berechnen).

  • Wenn während der Berechnung von g das i-te Bit von f(w) benötigt wird, dann wird der Logspace-Transducer zur Berechnung von f(w) neugestartet, bis schließlich das i-te Bit von f(w) ausgegeben ist. Die Bits 1,,i1 von f(w) werden dabei nicht ausgegeben. Dazu wird ein Binärzähler jedesmal genau dann inkrementiert, wenn der Logspace-Transducer für f ein Ausgabebit produziert.

Der Binärzähler benötigt Platz O(log|f(w)|)=O(logn), denn es gilt |f(w)|nk für eine Konstante k. Also ist die Komposition gf eine Logspace-Reduktion von L auf L.   ƒ

Zusatz: Aussagenlogik

aussagenlogische Formel:  Sei Σ0:={¬,,,,,0,1,(,),x}. Dann ist AΣ0 die Menge aller aussagenlogischen Formeln über der Variablenmenge V:=x1{0,1} intuitiv definiert.

Bemerkung: AΣ0 ist deterministisch kontextfrei und gehört damit zu DTIME(n).

erfüllbare Formel:  Eine aussagenlogische Formel F heißt erfüllbar, falls es eine Belegung B:Var(F){true,false} der in F vorkommenden Variablen Var(F) mit Wahrheitswerten so gibt, sodass sich F zu true auswertet.

SAT:  Das Problem SAT ist definiert durch SAT:={FA|F erfüllbar}.

Literal:  Ein Literal ist eine aussagenlogische Variable oder die Negation einer aussagenlogischen Variablen. Statt ¬x kann man auch x¯ schreiben. Außerdem sei x¯¯:=x.

Konjunktion:  Die Konjunktion von zwei aussagenlogischen Formeln A und B ist AB.

Disjunktion:  Die Disjunktion von zwei aussagenlogischen Formeln A und B ist AB.

Klausel:  Eine Klausel ist eine Disjunktion A1An von Literalen A1,,An.

DNF und KNF:  Die Probleme DNF und KNF sind definiert durch
DNF:={FA|F ist Disjunktion von Konjunktionen von Literalen} und
KNF:={FA|F ist Konjunktion von Disjunktionen von Literalen}.

k-KNF und k-SAT:  Die Probleme k-KNF und k-SAT sind definiert durch
k-KNF:={FKNF|jede Klausel in F enthält genau k Literale} und
k-SAT:=k-KNFSAT.

Satz (Umformung in Normalform): Für jede aussagenlogische Formel F gibt es äquivalente Formeln DNF(F)DNF und KNF(F)KNF.

Beweis: Für die Konstruktion von DNF(F) geht man die Wahrheitstabelle von F zeilenweise durch. Bei jeder Zeile (also Belegung), für die die Formel wahr wird, erstellt man einen Ausdruck, der genau für diese Belegung wahr wird (z. B. wenn F für A=B=false und C=true wahr wird, ist der zugehörige Ausdruck A¯B¯C). All diese Klauseln werden nachher durch Disjunktionen zusammengefasst, womit man DNF(F) erhält.

KNF(F) erhält man analog, indem man die Zeilen betrachtet, für die die Formel falsch wird, und für diese Zeilen die Negation der entsprechenden Klausel aufstellt (z. B. wenn F für A=true und B=C=false falsch wird, dann ist die zugehörige Klausel A¯BC). Diese Klauseln werden dann durch Konjunktionen verbunden, womit man KNF(F) erhält.   ƒ

Horn-Formel:  Eine Horn-Klausel ist eine Klausel mit höchstens einem positiven Literal. Eine Horn-Formel ist eine Formel in KNF, bei der jeder Disjunktionsterm eine Horn-Klausel ist.

HORN und HORNSAT:  Die Probleme HORN und HORNSAT sind definiert durch
HORN:={FKNF|F Horn-Formel} und HORNSAT:=HORNSAT.

Schwierige und vollständige Probleme

schwierig:  Sei C eine Komplexitätsklasse. Dann heißt LΣ schwierig für C oder
C-schwierig (bzgl. Logspace-Reduktionen), falls KCKmlogL.

vollständig:  Sei C eine Komplexitätsklasse. Dann heißt LΣ vollständig für C oder C-vollständig (bzgl. Logspace-Reduktionen), falls L C-schwierig ist und LC gilt.

Satz (Abschluss unter Komplement): Wenn die Komplexitätsklasse C unter Komplement abgeschlossen ist (d. h. L¯C für alle LC), dann ist eine Sprache KΣ C-vollständig genau dann, wenn K¯ C-vollständig ist.

Beweis: Sei KΣ. Dann gilt KC genau dann, wenn K¯C gilt. Außerdem gilt K C-schwierig genau dann, wenn für alle LC gilt, dass LmlogK. Das ist äquivalent zu L¯mlogK für alle L¯C, da C unter Komplement abgeschlossen ist. Das gilt genau dann, wenn LmlogK¯ für alle LC (durch Komplementbildung auf beiden Seiten der Reduktion). Also ist K C-vollständig genau dann, wenn K¯ C-vollständig ist.   ƒ

NL-vollständige Probleme

Satz (GAP NL-vollständig): Das Grapherreichbarkeitsproblem GAP ist NL-vollständig.

Beweis: GAPNL wurde bereits gezeigt.

Seien LNL und M eine nicht-deterministische logarithmisch platzbeschränkte Turingmaschine mit L(M)=L. Für eine Eingabe wΣ wird eine Reduktion f definiert durch f(w):=(G,s,t) mit

  • G:=(V,E) der gerichtete Graph mit V:={α|α Konfiguration von M bei Eingabe w,
    |α|log|w|} und E:={(α,β)|α,βV,αMβ},

  • s:=Start(w) und

  • t:=die oBdA eindeutige akzeptierende Konfiguration von M.

Offensichtlich gilt wL(M)in G gibt es einen gerichteten Pfad von s nach t. Also ist f eine Reduktion von L auf GAP, die man in logarithmischem Platz berechnen kann.   ƒ

Satz (2-SAT NL-vollständig): 2-SAT ist NL-vollständig.

Beweis: Aufgrund des Satzes von Immerman und Szelepcsényi genügt es, die NL-Vollständigkeit von 2-NSAT:=2-KNFSAT zu zeigen, denn es gilt 2-NSAT¯=2-SAT (Komplement bzgl. 2-KNF) und NL ist unter Komplement abgeschlossen (nach dem Satz von Immerman und Szelepcsényi).

2-NSAT ist NL-schwierig: Dies kann man durch Reduktion GAPmlog2-NSAT des Grapherreichbarkeitsproblems GAP auf 2-NSAT zeigen. Sei G=(V,E) ein gerichteter Graph und s,tV. Für jeden Knoten uV erstellt man eine logische Variable und für jede Kante (u,v)E die Implikation uv, also die Klausel ¬uv. Außerdem werden die Klauseln s und ¬t hinzugefügt. Die so durch Konjunktionen zusammengesetzte Formel ist unerfüllbar, wenn in G ein Weg von s nach t existiert. Wenn kein Weg existiert, dann können alle Variablen, deren zugehörige Knoten von s aus erreichbar sind, zu true und alle anderen zu false gesetzt werden. Dies definiert eine die Formel erfüllende Belegung. Also ist die Formel erfüllbar genau dann, wenn in G ein Weg von s nach t existiert. Man hat also eine Reduktion von GAP auf 2-NSAT gefunden. GAP ist NL-schwierig, also ist auch 2-NSAT ist NL-schwierig.

2-NSAT liegt in NL: Gegeben sei eine Formel ϕ2-KNF in den Variablen x1,,xn. Nun wird ein Graph mit Knotenmenge V:={x1,,xn,x1¯,,xn¯} konstruiert. Jede Klausel αβ kann als Implikation interpretiert werden, denn es gilt (αβ)((α¯β)(β¯α)). Deswegen werden zwei Kanten α¯β und β¯α eingefügt. Behauptung: Es gibt genau dann einen Knoten x und Pfade xx¯ sowie x¯x, wenn ϕ unerfüllbar ist. Somit kann die Nichterfüllbarkeit von ϕ mithilfe des NL-Algorithmus für Grapherreichbarkeit überprüft werden.

Es reicht also, die Behauptung zu zeigen. Das kann man wie folgt beweisen:

“: Wenn es einen Knoten x und Pfade xx¯ sowie x¯x gibt, dann gelten die Implikationen xx¯ und x¯x, d. h. weder x noch x¯ kann wahr sein. ϕ ist also nicht erfüllbar.

“: Für jeden Knoten x existiere nun höchstens einer der Pfade xx¯ oder x¯x. Man kann annehmen, dass genau einer der Pfade existiert, ansonsten füge die Kante xx¯ hinzu.
Dies erzeugt keinen neuen Kreis: Angenommen, durch die neue Kante xx¯ wurde ein Kreis mit α und α¯ erzeugt. Dann benutzt dieser Kreis die Kante xx¯, d. h. es gilt αxx¯α¯αx oder αxx¯α¯xx¯α ( benutzt nur alte Kanten). Damit hätte der ursprüngliche Graph einen Pfad x¯x, im Widerspruch zur Annahme. Somit kann immer eine Kante neu hinzugefügt werden, sodass immer genau einer der Pfade xx¯ oder x¯x existiert.
Nun wird x auf true gesetzt, wenn x¯x existiert und false sonst. Diese Belegung ist erfüllend: Sei αβ eine beliebige Klausel mit β=false (sonst ist αβ ohnehin schon wahr). Dann gibt es nach Konstruktion einen Pfad ββ¯. Außerdem gibt es wegen der Klausel αβ die Kanten α¯β und β¯α. Somit erhält man den Weg α¯ββ¯α. Also gilt α=true und die Klausel ist erfüllt.
Es sind also alle Klauseln von ϕ erfüllt und damit ϕ selbst.   ƒ

NP-vollständige Probleme

Satz (NP-vollständige Sprache): Wenn es eine NP-vollständige Sprache L gibt, dann gibt es eine NP-vollständige Sprache LNTIME(n).

Beweis: Für eine Eingabe wΣ der Länge |w|=n produziert eine Turingmaschine zunächst w$nk in der Zeit nk mit $Σ (nnk ist zeitkonstruierbar).

Setze nun L:={w$|w|k|wL}. Es gilt LmlogL durch f:Σ(Σ{$}), f(w):=w$|w|k, d. h. L ist NP-vollständig, weil L auch NP-vollständig ist. Es gilt LNTIME(n).   ƒ

Satz (Satz von Cook (und Levin)): SAT ist NP-vollständig.

Beweis: Es gilt SATNP: Für FΣ0 überprüft man FSAT?, indem man zunächst in Zeit O(|F|) prüft, ob F überhaupt eine gültige aussagenlogische Formel ist, also FA (geht, weil A deterministisch kontextfrei ist, d. h. ADTIME(n)). In diesem Fall rät man eine Belegung B:Var(F)true,false der in F vorkommenden Variablen Var(F) mit Wahrheitswerten und man akzeptiert, wenn F sich unter B zu true auswertet (kann in polynomieller Zeit geprüft werden).

Um die NP-Schwierigkeit von SAT zu zeigen, reduziert man eine beliebige Sprache LNP auf SAT, d. h. man konstruiert eine Logspace-Reduktion φ:ΣΣ0 mit
wLφ(w) erfüllbar. Dazu seien M=(Q,Σ,Γ,δ,q0,F,) eine durch das Polynom p(n) zeitbeschränkte Turingmaschine mit L=L(M) und w=w1wnΣ eine Eingabe der Länge n. OBdA stellt man folgende Forderungen an M:

  • M hat nur ein les- und schreibbares Band, auf dem zu Beginn die Eingabe steht.

  • F={qf}, es gibt also nur einen Endzustand.

  • Bei jeder Eingabe wΣ hält M nie, aber nach p(n) Schritten ist M im Endzustand genau dann, wenn wL(M).

  • Nach p(n) Schritten ist der Lese- und Schreib-Kopf wieder auf der Ausgangsposition.

  • Aus (q,a,q,a,D)δ und (q,b,p,b,D)δ folgt a=b, a=b und D=D, d. h. nur der resultierende neue Zustand wird nicht-deterministisch festgelegt (hängt nicht vom Zeichen auf dem Band ab). Dazu kann man zum Beispiel die Zustandsmenge Q umdefinieren zu Q:={qa,a,D|qQ,a,aΓ,D{L,R,N}} und die Übergangsrelation δ zu
    δ:={(qa,a,D,a,qb,b,D,a,D)|(q,a,q,a,D)δ,b,bΓ,D{L,R,N}}.

Somit können die Konfigurationen als Conf:={uqv|qQ,u,vΓ,|uv|=p(n)} aufgefasst werden (nach 1.). Die Startkonfiguration ist q0wp(n)n+1 und die akzeptierende Konfigurationen sind aus qfΓp(n) (nach 2. und 4.). Man kann eine Konfiguration αConf auch schreiben als α=α1α0αp(n)αp(n)+1 mit α1=, α0,,αp(n)QΓ und αp(n)+1= (dabei ist natürlich genau ein α0,,αp(n) in Q und die anderen sind in Γ).

Man definiert nun eine Menge von 4-Tupeln, nämlich die Menge der lokalen Bandinhalte:
Δ:={(a,b,c,b)|a,b,cΓ}
{(c,b,q,p),(b,q,a,b),(q,a,d,a)|(q,a,p,a,L)δ,c,b,dΓ}
{(c,b,q,b),(b,q,a,p),(q,a,d,a)|(q,a,p,a,N)δ,c,b,dΓ}
{(c,b,q,b),(b,q,a,a),(q,a,d,p)|(q,a,p,a,R)δ,c,b,dΓ}.
Wegen 5. gilt dann für alle α,α(QΓ) mit |α|=|α|, dass α,αConf und αMα genau dann, wenn αConf und (αi1,αi,αi+1,αi)Δ für alle i=0,,p(n).

Falls zum Beispiel (q,a,p,a,L)δ gilt, so ist folgende lokale Bandänderung für alle bΓ möglich: α=αi2bqaαi+2Mα=αi2pbaαi+2.

Eine Rechnung (α0,α1,,αp(n)) von M kann damit als Matrix beschrieben werden:

α0=α0,0α0,1α0,p(n)α1=α1,0α1,1α1,p(n)αp(n)=αp(n),0αp(n),1αp(n),p(n) Für jedes Tripel (a,i,t) mit aQΓ, i{1,0,,p(n),p(n)+1} und t{0,,p(n)} sei nun x(a,i,t) eine aussagenlogische Variable. Die Interpretation der Variable ist, dass x(a,i,t) wahr sein soll genau dann, wenn zum Zeitpunkt t das i-te Zeichen der aktuellen Konfiguration ein a ist.

Man definiert folgende Hornformeln:

  • Konsistenzformel: C(n):=itab(¬x(a,i,t)¬x(b,i,t))
    (an der i-ten Stelle kann zu einem Zeitpunkt nur ein Zeichen stehen)

  • Randformel: R(n):=t(x(,1,t)x(,p(n)+1,t))
    (es darf nicht über den polynomiell beschränkten Platz hinausgegangen werden)

  • Startformel: S(w):=X(q0,0,0)i=1,,nx(ai,i,0)i>nx(,i,0)
    (Startkonfiguration ist q0wp(n)n+1)

  • Akzeptierungsformel: A(n):=x(qf,0,p(n))
    (akzeptierende Konfigurationen sind aus qfΓp(n))

Anschließend definiert man die Übergangsformel D(n):=it(a,b,c)(ΓQ)3
((x(a,i1,t1)x(b,i,t1)x(c,i+1,t1))((a,b,c,d)Δx(d,i,t))).
Die Endformel ist damit φ(n):=C(n)R(n)S(w)A(n)D(n).

Diese Formel ist in KNF. Sie ist eine Hornformel genau dann, wenn M deterministisch ist. Dabei sind die Klauseln, die nur negative Literale enthalten, genau die Klauseln in C(n) und die Klauseln in D(n), bei denen die Disjunktion leer ist.

Die Formel φ(w):=C(n)R(n)S(w)D(n) ist immer erfüllbar. Die erfüllenden Belegungen entsprechen nämlich genau den Rechnungen von M. Am Wert von A(n) kann man einer solchen Belegung ansehen, ob sie erfolgreich ist. Damit ist φ(w) erfüllbar genau dann, wenn wL.   ƒ

Bemerkung: Aus dem Beweis ergibt sich unmittelbar folgendes Korollar.

Folgerung: HORNSAT ist P-vollständig.

Satz (KNFSAT NP-vollständig): KNFSAT ist NP-vollständig.

Beweis: Siehe Beweis vom Satz von Cook (und Levin), denn φ(n) ist in KNF.   ƒ

Satz (3-SAT NP-vollständig): 3-SAT ist NP-vollständig.

Beweis: 3-SATNP gilt, weil die Prüfung der syntaktischen Korrektheit und der Anzahl an Literalen pro Klausel deterministisch in polynomieller Zeit möglich ist. Anschließend kann eine Belegung nicht-deterministisch geraten und in polynomieller Zeit auf Erfüllung geprüft werden.

Für die NP-Schwierigkeit von 3-SAT zeigt man KNFSAT3-SAT. Sei also F eine Formel, die schon in KNF ist. Dann unterscheidet man drei Fälle:

  • F enthält eine Klausel (x~) mit nur einem Literal. In diesem Fall führt man eine neue Variable z ein und ersetzt (x~) durch (x~z)(x~z¯). (Natürlich wird für jede solche Klausel mit nur einem Literal jeweils eine neue Variable eingeführt.)

  • F enthält eine Klausel (x~y~) mit zwei Literalen. In diesem Fall führt man eine neue Variable z ein und ersetzt (x~y~) durch (x~y~z)(x~y~z¯).

  • F enthält eine Klausel c:=(x~1x~k) mit k4 Literalen. In diesem Fall führt man k3 neue Variablen z3,,zk1 ein und ersetzt c durch c:=
    (x~1x~2z3)(z¯3x~3z4)(z¯4x~4z5)(z¯k2x~k2zk3)(z¯k1x~k1x~k).

Diese Umwandlungen ändert nichts an der Erfüllbarkeit von F. Für die ersten beiden Fälle ist das klar, für den dritten Fall gilt auch:

  • Sei σ eine erfüllende Belegung für c. Dann gilt σ(x~j)=1 für ein j{1,,k}. Wenn man σ zu σ erweitert durch σ(zi):=1 für i=3,,j und σ(zi):=0 für i=j+1,,k1, dann ist σ eine erfüllende Belegung für c.

  • Sei σ eine erfüllende Belegung für c. Angenommen, es gelte σ(x~i)=0 für alle i=1,,k. Dann muss σ(z3)=1 gelten (wegen der ersten Klausel (x~1x~2z3)). Induktiv folgt dann σ(zi)=1 für alle k=3,,k1. Dann gilt aber σ((z¯k1x~k1x~k))=0, ein Widerspruch (es müssen alle Klauseln erfüllt werden). Also ist die Einschränkung σ von σ auf x~1,,x~k eine erfüllende Belegung von c.

Somit hat man F auf eine Formel in 3-KNF abgebildet, die erfüllbar ist genau dann, wenn F erfüllbar ist.   ƒ

LinProg(Z):  LinProg(Z) ist definiert durch
LinProg(Z):={A,b|AZm×n,bZm,xZnAxb}.

Satz (LinProg(Z) NP-vollständig): LinProg(Z) ist NP-vollständig.

Beweis: LinProg(Z)NP ist der schwierige Teil des Beweises und wird hier ausgelassen. Man kann nämlich nicht einfach nicht-deterministisch ein xZn raten, da das evtl. nicht in polynomieller Zeit geht (wenn x groß genug ist).

LinProg(Z) NP-schwierig zeigt man durch 3-SATmlogLinProg(Z). Sei F=c1cm eine Formel in 3-KNF mit Variablen x1,,xn. Dazu wird das folgende System von ganzzahligen Ungleichungen über den Variablen xi,x¯i, i=1,,n gebildet:

  • xi0 für i=1,,n

  • xi¯0 für i=1,,n

  • xi+xi¯1 für i=1,,n

  • xixi¯1 für i=1,,n

  • x~j1+x~j2+x~j31 für jede Klausel cj=(x~j1x~j2x~j3), j=1,,m

Dieses System ist lösbar genau dann, wenn F erfüllbar ist.   ƒ

Bemerkung: Zur Wiederholung wird nochmal definiert, was Vertex Cover (VC) ist.

Vertex Cover (VC):  Sei G=(V,E) ein ungerichteter Graph.
Eine Teilmenge CV heißt Knotenüberdeckung (oder Träger) von G, falls für jede Kante {u,v}E gilt, dass {u,v}C. Dann ist Vertex Cover (VC) wie folgt definiert:
Gegeben ist G und k0. Gefragt ist, ob eine Knotenüberdeckung von G mit |C|k existiert.

Satz (VC NP-vollständig): VC ist NP-vollständig.

Beweis: VCNP: Rate eine Teilmenge CV mit |C|k und prüfe in Polynomialzeit, ob C eine Knotenüberdeckung ist.

VC NP-schwierig kann man durch 3-SATmlogVC zeigen. Sei F=c1cm eine Formel in 3-KNF mit cj=(x~j1x~j2x~j3), j=1,,m. Man konstruiert zu F einen ungerichteten Graphen G(F) wie folgt: Für jedes Literal in jeder Klausel erstellt man einen Knoten (d. h. es gibt insgesamt 3m Knoten). Kanten werden zwischen den Literalen einer Klausel eingefügt (sodass man lauter disjunkte „Dreiecke“ erhält) und zusätzlich noch zwischen allen x und x¯ für alle Variablen x aus F.

In G(F) muss jede Knotenüberdeckung C mindestens 2m Knoten haben, weil in jedem der m Dreiecke mindestens zwei Knoten zu C gehören müssen.

Es gilt nun: F3-SATG(F) hat eine Knotenüberdeckung C mit |C|=2m.

": Sei F erfüllbar. Dann wird in jeder Klausel cj mindestens ein Literal x~ji wahr. Sei C die Knotenmenge, die für jedes Dreieck die anderen beiden Literale enthält. Dann enthält C genau 2m Elemente und C ist eine Knotenüberdeckung.

“: Sei C eine Knotenüberdeckung mit |C|=2m. Dann enhält C in jedem Dreieck genau zwei Knoten. Definiere eine Belegung σ von F durch
σ(x):=1, falls eine Kopie von x nicht zu C gehört,
σ(x):=0, falls eine Kopie von x¯ nicht zu C gehört, und
σ(x):=0, falls alle Kopien von x und x¯ zu C gehören.
Weil C eine Knotenüberdeckung ist und alle Kanten (x,x¯) in G(F) vorhanden sind, wird keine Variable gleichzeitig auf 0 und 1 gesetzt. Es gilt σ(F)=1.   ƒ

NAE-k-SAT:  Das Problem NAE-k-SAT ist definiert durch
NAE-k-SAT:={Fk-KNF|Belegung σF(σ)=1=F(1σ)}.
Zur Abkürzung definiert man NAE-SAT:=NAE-3-SAT.

Bemerkung: FNAE-k-SAT heißt F=c1cm mit cj=(x~1jx~kj) Klausel mit k Literalen, sodass es eine Belegung σ gibt, für die in jeder Klausel ein Literal wahr und eins falsch ist.

Satz (NAE-SAT NP-vollständig): NAE-SAT ist NP-vollständig.

Beweis: Es gilt NAE-SATNP, da man σ nicht-deterministisch raten und
F(σ)=F(1σ)=1 in polynomieller Zeit verifizieren kann.

Für NAE-SAT NP-schwierig zeigt man zunächst 3-SATmlogNAE-4-SAT.
Dazu sei F3-KNF (dafür muss zuerst die syntaktische Korrektheit überprüft werden). Sei z eine neue Variable. Ersetze nun jede Klausel cj in F durch cj:=(cjz), d. h. aus
F=(c1cm) wird F:=(c1cm). Es gilt F3-SATFNAE-4-SAT, denn:

“: Sei F3-SAT, d. h. es gibt eine Belegung σ, sodass F(σ)=1. Erweitere nun σ zu σ durch σ(z):=0. Dann gilt immer noch F(σ)=1 (die cj sind weiterhin alle wahr), aber auch F(1σ)=1, da z in der Belegung 1σ zu wahr ausgewertet wird.

“: Sei FNAE-4-SAT, d. h. es gibt eine Belegung σ, sodass F(σ)=F(1σ)=1. Gilt σ(z)=0, dann werten alle Klauseln cj zu wahr aus (weil die cj=(cjz) zu wahr auswerten, aber z falsch ist), d. h. die Einschränkung von F auf die Variablen von F ist eine erfüllende Belegung von F. Gilt σ(z)=1, so ersetzt man σ durch 1σ.

Nun zeigt man NAE-4-SATmlogNAE-SAT wie oben: Für F4-KNF mit F=(c1cm) ersetzt man cj=(x~1jx~2jx~3jx~4j) durch cj:=(x~1jx~2jzj)(zj¯x~3jx~4j) (dabei sind die zj, j=1,,m neue Variablen). Somit erhält man F:=c1cm.

Es gilt FNAE-4-SATFNAE-SAT:

“: Sei FNAE-4-SAT, d. h. es gibt eine Belegung σ mit F(σ)=F(1σ)=1.
Man erweitert σ zu σ wie folgt:
Wenn σ(x~1j)=σ(x~2j) gilt, dann setze σ(zj):=1σ(x~1j).
Wenn σ(x~3j)=σ(x~4j) gilt, dann setze σ(zj):=σ(x~3j).
(Beide Fälle können in Kombination mit σ(x~1j)=σ(x~3j) nicht auftreten, da ein mindestens Literal wahr und mindestens eins falsch sein muss.)
Für σ(x~1j)σ(x~2j) und σ(x~3j)σ(x~4j) setze σ(zj) beliebig.
Damit gilt F(σ)=F(1σ)=1 und FNAE-SAT.

“: Sei FNAE-SAT, d. h. es gibt eine Belegung σ mit F(σ)=F(1σ)=1. Sei σ die Einschränkung von σ auf die Variablen von F.
Wenn σ(x~1j)σ(x~2j) oder σ(x~3j)σ(x~4j) gilt, dann gilt F(σ)=F(1σ)=1.
Sei also σ(x~1j)=σ(x~2j) und σ(x~3j)=σ(x~4j). Dann muss σ(x~2j)σ(x~3j) gelten, denn sonst wäre eine der beiden Klauseln aus cj bei σ oder 1σ nicht erfüllt (z. B. wenn σ(zj)=σ(x~1j) gilt, dann wäre die erste Klausel aus cj für σ nicht erfüllt, wenn σ(zj)=1, und nicht für 1σ, wenn σ(zj)=0). Damit ist aber ebenfalls F(σ)=F(1σ)=1, d. h. FNAE-4-SAT.   ƒ

2-4-SAT:  Das Problem 2-4-SAT ist definiert durch 2-4-SAT:=
{F4-KNF|Belegung σin jeder Klausel sind zwei Literale wahr und zwei falsch}.

Satz (2-4-SAT NP-vollständig): 2-4-SAT ist NP-vollständig.

Beweis: Man zeigt NAE-SATmlog2-4-SAT, indem man die Klauseln cj=(x~1jx~2jx~3j) ersetzt durch cj:=(cjzj).   ƒ

3-Färbbarkeit:  Sei G=(V,E) ein ungerichteter Graph mit V={1,,n} und
E(V2):={{u,v}|u,vV,uv}.
Das Problem 3-Färbbarkeit ist damit wie folgt definiert: Gegeben sei G=(V,E).
Gefragt ist, ob es eine Abbildung c:V{r,g,b} gibt, sodass {x,y}Ec(x)c(y).

Satz (3-Färbbarkeit NP-vollständig): 3-Färbbarkeit ist NP-vollständig.

Beweis: 3-FärbbarkeitNP ist klar (Raten einer Abbildung c und Überprüfung der Bedingung).

Für 3-Färbbarkeit NP-schwierig zeigt man NAE-SATmlog3-Färbbarkeit. Sei also F3-KNF mit F=(c1cm) eine Formel mit Variablen x1,,xn und Klauseln cj=(x~1jx~2jx~3j). Erstelle nun einen Graphen G(F) wie folgt:

  • Führe für jede Variable xi und der Negation xi¯ einen Knoten ein, d. h. zunächst 2n Knoten. Führe außerdem einen separaten „Wurzelknoten“ ein. Verbinde jedes xi mit xi¯ und alle xi und xi¯ jeweils mit dem Wurzelknoten. Der Wurzelknoten soll im Folgenden immer blau gefärbt sein. Damit können die anderen Knoten im bisherigen Graphen nur rot oder grün gefärbt sein. Die 3-Färbungen des Teilgraphen entsprechen den möglichen Belegungen.

  • Füge nun für jede Klausel cj=(x~1jx~2jx~3j) jeweils ein disjunktes Dreieck ein. Verbinde in den Dreiecken alle Literale mit ihrem komplementären Literal aus dem 1. Schritt.

Es gilt FNAE-SATG(F) 3-färbbar:

“: Sei σ eine Belegung von F mit F(σ)=F(1σ)=1. In den Dreiecken wird ein Knoten rot gefärbt, dessen entsprechendes Literal in der Klausel für σ wahr wird. Ein Knoten, dessen Literal falsch ist (bzw. wahr für 1σ), wird grün gefärbt und der verbleibende Knoten blau. Die Knoten im 1. Teilgraph werden dann entsprechend gefärbt (xi rot und xi¯, falls σ(xi)=1, sonst andersherum).

“: Sei G(F) 3-färbbar, oBdA sei der Wurzelknoten blau gefärbt. Pro Dreieck müssen in jedem Fall alle Farben rot, grün und blau verwendet werden. Definiere σ(xi):=1, falls xi im 1. Teilgraphen rot ist, und σ(xi):=0, falls xi im 1. Teilgraphen grün ist. Das ist eine erfüllende Belegung, denn wenn z. B. σ(cj)=0 wäre, dann wären alle Knoten des entsprechenden Dreiecks mit grünen Knoten verbunden. Analog muss ein Literal pro Klausel falsch sein.   ƒ

planar:  Ein Graph G=(V,E) heißt planar, falls G kreuzungsfrei in die Ebene R2 eingebettet werden kann.

Bemerkung: Jeder planare Graph ist 4-färbbar.

Satz (planare 3-Färbbarkeit NP-vollständig):
3-Färbbarkeit für planare Graphen ist NP-vollständig.

Rucksack-Problem:  Das Problem Rucksack ist wie folgt definiert:
Gegeben seien (si,pi) und s mit si,pi,sN, i=1,,n. Gesucht ist I{1,,n}, sodass iIsis gilt und unter dieser Bedingung iIpi maximal wird.

Bemerkung: Bei der Entscheidungsvariante ist zusätzlich ein pN gegeben.
Gefragt ist, ob I{1,,n} existiert, sodass iIsis und iIpip.
Mit binärer Suche (startend bei pmax:=i=1npi) kann man zeigen:
Wenn die Entscheidungsvariante in P liegt, dann auch die Optimierungsvariante.
In der Kryptografie geht es oft nur um einen Spezialfall von Rucksack.

Subset-Sum:  Das Problem Rucksack ist wie folgt definiert:
Gegeben seien si,sN, i=1,,n. Gesucht ist I{1,,n}, sodass iIsi=s.

Satz (Rucksack/Subset-Sum NP-vollständig):
Rucksack (sogar schon Subset-Sum) ist NP-vollständig.

Beweis: Subset-SumNP ist klar (rate I und verifiziere).

Subset-Sum NP-schwierig kann man mit 2-4-SATmlogSubset-Sum zeigen.
Sei also F=(c1cm) eine Formel in 4-KNF mit Klauseln cj=(x~1jx~2jx~3jx~4j). Aus dieser Formel werden 2n Werte s~i (ein Paar für jede Variable xi, die in F vorkommt) wie folgt erzeugt: s~i:=00100. Dabei stehen vorne 2m Bits (also m Paare), danach folgt ein Trennbit und hinten befinden sich n Bits, wobei die 1 an der i-ten Position von hinten ist. Die vorderen Bits bestimmen sich folgendermaßen:
Das j-te vordere Paar von si ist 00, falls xicj, und 01, falls xicj.
Das j-te vordere Paar von si¯ ist 00, falls xi¯cj, und 01, falls xi¯cj.
Das Trennbit ist beliebig, z. B. 0.

Wenn man nun s:=1010100111 setzt, dann gilt F2-4-SAT genau dann, wenn es ein I{1,,n} gibt mit iIsi=s.   ƒ

Bemerkung: Rucksack und Subset-Sum sind pseudo-polynomiell lösbar, d. h. die Probleme liegen in P, falls die Zahlen unär kodiert werden (zum Lösen benötigt man also polynomiell viel Zeit, wobei das Polynom nicht von der Länge von s, sondern von s selbst abhängt).

Die Lösung erfolgt dabei mit dynamischem Programmieren:
Sei S[j]:={iIsi|I{1,,j},iIsis}. Ausgehend von S[0]=0 kann man S[j] aus S[j1] für j=1,,n berechnen durch S[j]={sj+k|kS[j1],sj+ks}S[j1]. Es gilt S[0]S[1]S[n]{0,s}, d. h. |S[j]|s+1 für alle j=0,,n. Falls |S[n]| polynomiell begrenzt bleibt, so ist das Problem polynomiell lösbar, denn die Laufzeit ist O(nslogs).

PSPACE-vollständige Probleme

quantifizierte Boolesche Formel (QBF):  Eine quantifizierte Boolesche Formel (QBF) entsteht folgendermaßen:

  • Jede Aussagenvariable x ist eine QBF. In dieser Formel x tritt x frei auf.

  • ¬φ, (φψ) und (φψ) sind QBF, falls φ und ψ QBF sind. Eine Aussagenvariable x aus φ oder ψ ist frei in den Formeln, falls x frei in φ oder frei in ψ ist.

  • xφ und xφ sind QBF, falls φ QBF und x eine Aussagenvariable ist. Der Gültigkeitsbereich von x bzw. x erstreckt sich auf jedes freie Vorkommen von x in φ. x ist in der entstehenden Formel nicht mehr frei, alle anderen Aussagenvariablen dagegen schon.

pränexe Normalform:  Eine QBF F ist in pränexer Normalform, falls
F=Qx1(1)Qxn(n)φ(x1,,xn) mit Q(1),,Q(n){,} und
φ(x1,,xn) aussagenlogische Formel ohne Quantoren in den Variablen x1,,xn.

Satz (Existenz der pränexen Normalform): Jede QBF kann in eine äquivalente pränexe Normalform gebracht werden (in polynomieller Zeit).

QBF:  Das Problem QBF ist definiert durch
QBF:={F|F quantifizierte Boolesche Formel, die sich zu wahr auswertet}.

Satz (QBF PSPACE-schwierig): QBF ist PSPACE-schwierig.