\documentclass[11pt]{article} \input{style_guide.tex} \linespread{1.06} \setlength{\parskip}{0.5em} \title{\textbf{\Huge Das vollständige Fundament}\\[0.5em] \large Komplexitätstheorie und Approximation, ausführlich erklärt\\ \normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, SS 2026} \author{} \date{} \begin{document} \maketitle \thispagestyle{empty} \begin{center}\itshape\large Das gesamte Wissen der Vorlesung -- jedes Problem einzeln,\\ mit Idee statt Abkürzung, mit Bild wo es hilft. \end{center} \vfill \noindent\textbf{Was dieses Heft leistet.} Es erklärt den kompletten Stoff des Kurses, ohne etwas zu überspringen. Der Kern ist ein \emph{Katalog aller Probleme}. Zu jedem Problem findest du vier Dinge, jedes ausführlich: \begin{enumerate} \item die \textbf{Definition} -- was gefragt ist, mit Beispiel; \item \textbf{warum es in $\NP$ liegt} -- die Idee des Zertifikats, Schritt für Schritt erklärt; \item \textbf{woher seine Schwere kommt} -- die Reduktion, die es schwer macht, mit ihrer Konstruktions-Idee; \item \textbf{was daraus folgt} -- die Reduktionen, die von ihm ausgehen, jede mit eigener Idee. \end{enumerate} Danach folgen die untere-Schranken-Theorie (ETH) und die Approximation -- auch dort steht bei jedem Ergebnis die \emph{Idee} des Beweises. \medskip \noindent\textbf{Zwei Versprechen.} Erstens: Kein Problem wird mit einem anderen zusammengelegt, auch wenn sie sich ähneln -- jedes bekommt seinen eigenen, vollständigen Abschnitt. Zweitens: Nichts wird als \glqq trivial\grqq{} oder \glqq analog\grqq{} abgetan; jeder Nachweis wird wirklich ausgeführt. \medskip \noindent\textbf{Die farbigen Kästen.} \begin{center}\small \begin{tabular}{ll} \ding{72}~Intuition & die Idee in einfachen Worten\\ \ding{43}~Analogie & ein Bild aus dem Alltag\\ \ding{110}~Definition & die präzise Fassung\\ \ding{115}~Satz & ein Ergebnis mit erklärter Beweisidee\\ \ding{108}~Beispiel & durchgerechnet, mit echten Zahlen\\ \ding{43}~Idee & die Konstruktion hinter einer Reduktion oder einem Beweis\\ \ding{73}~Aha & die Pointe\\ \ding{55}~Stolperstein & der häufige Fehler\\ \ding{228}~Zusammenhang & wie es ins große Ganze passt\\ \end{tabular} \end{center} \vfill \newpage \tableofcontents \newpage % ################################################################## \part*{Teil A -- Die Grundlagen} \addcontentsline{toc}{section}{\textbf{Teil A -- Die Grundlagen}} % ################################################################## % ================================================================== \section{Ein Problem, das sich wehrt} % ================================================================== Bevor wir die Theorie aufbauen, brauchen wir einen Grund für sie. Diesen Grund liefert ein einzelnes Problem, das harmlos aussieht und trotzdem jeden Computer überfordert: das Cliquenproblem. Ein \emph{Graph} ist ein Netz aus Punkten (\emph{Knoten}) und Verbindungslinien (\emph{Kanten}). Eine \emph{Clique} ist eine Gruppe von Knoten, in der jeder mit jedem direkt verbunden ist. Das Cliquenproblem fragt: Gibt es in einem Graphen eine Clique aus mindestens $k$ Knoten? \begin{bsp}{Eine Clique erkennen} \setlength{\unitlength}{1cm} \begin{center} \begin{picture}(5,3)(-0.6,-0.5) \put(0,1){\circle*{0.15}}\put(-0.5,1){\small $1$} \put(1.2,2.4){\circle*{0.15}}\put(1.1,2.6){\small $2$} \put(2.4,1){\circle*{0.15}}\put(2.55,1){\small $3$} \put(1.6,-0.2){\circle*{0.15}}\put(1.5,-0.55){\small $4$} \put(3.6,0.3){\circle*{0.15}}\put(3.75,0.2){\small $5$} \qbezier(0,1)(0.6,1.7)(1.2,2.4) \put(0,1){\line(1,0){2.4}} \qbezier(1.2,2.4)(1.8,1.7)(2.4,1) \qbezier(2.4,1)(2.0,0.4)(1.6,-0.2) \qbezier(2.4,1)(3.0,0.65)(3.6,0.3) \end{picture} \end{center} Die Gruppe $\{1,2,3\}$ bildet ein Dreieck -- alle drei Kanten sind da, also eine Clique der Größe 3. Die Gruppe $\{2,3,4\}$ ist keine, weil zwischen 2 und 4 die Kante fehlt. \end{bsp} Der naheliegende Algorithmus probiert alle Gruppen aus $k$ Knoten durch. Bei $n$ Knoten und $k = n/2$ sind das mindestens $2^{n/2}$ Gruppen -- eine Zahl, die sich mit jedem zusätzlichen Knoten ungefähr verdoppelt. Schon bei hundert Knoten ist das jenseits des Machbaren, und kein schnellerer Rechner holt exponentielles Wachstum je ein. \begin{aha} Die Komplexitätstheorie fragt nicht \glqq wie löse ich die Clique schnell?\grqq, sondern \glqq ist die Clique \emph{überhaupt} schnell lösbar -- oder gehört sie zu einer großen Familie von Problemen, die alle gemeinsam schwer sind?\grqq{} Genau diese zweite, tiefere Frage beantwortet der ganze Kurs. Wir bauen dafür jetzt die Werkzeuge. \end{aha} % ================================================================== \section{Effizient lösbar: die Klasse P} % ================================================================== Wir müssen zuerst \glqq schnell\grqq{} präzise machen. Die Laufzeit eines Algorithmus misst man immer \emph{relativ zur Größe seiner Eingabe}, geschrieben $n$, und man betrachtet den schlechtesten Fall -- weil man eine Garantie will, keine Hoffnung. \begin{defn}{Klasse P} $\Pclass$ ist die Menge aller Entscheidungsprobleme, für die ein Algorithmus existiert, der sie in \emph{polynomieller} Zeit löst -- also mit Laufzeit $O(n^d)$ für eine feste Zahl $d$ (etwa $n$, $n^2$, $n^3$). \end{defn} \begin{intuition} Man setzt \glqq polynomiell\grqq{} mit \glqq effizient\grqq{} gleich. Das ist eine Konvention, aber eine gute: Der entscheidende Bruch verläuft zwischen polynomiell und exponentiell. Eine polynomielle Laufzeit wächst zahm, eine exponentielle explodiert. Und die Grenze bleibt dieselbe, egal welchen realistischen Rechnertyp man zugrunde legt. \end{intuition} Ein \emph{Entscheidungsproblem} ist eine Frage mit Antwort Ja oder Nein. Statt \glqq wie groß ist die größte Clique?\grqq{} fragt man \glqq gibt es eine Clique mit $\ge k$ Knoten?\grqq. Formal identifiziert man ein Problem mit der Menge seiner Ja-Eingaben. Beispiele in $\Pclass$: Sortieren, kürzeste Wege, minimale Spannbäume, Matching -- für all das kennt man schnelle Algorithmen. \begin{stolper} \textbf{Zahlen sind binär kodiert.} Eine Zahl $K$ steht als Eingabe nur mit ihren Ziffern da, also mit Länge $O(\log K)$. Ihr \emph{Wert} $K$ ist exponentiell größer als diese Länge. Ein Algorithmus, der \glqq bis $K$ zählt\grqq, macht $K$ Schritte und ist damit \emph{nicht} polynomiell in der Eingabelänge. An diesem Punkt hängt später die Schwere der Zahlprobleme. \end{stolper} % ================================================================== \section{Effizient überprüfbar: die Klasse NP} % ================================================================== Jetzt kommt die zweite, wichtigere Klasse. Sie beruht auf einer Beobachtung, die den ganzen Kurs trägt: \emph{Eine Lösung zu finden ist oft schwer -- eine vorgelegte Lösung zu prüfen ist leicht.} \begin{analogie} Ein schweres Sudoku zu lösen dauert eine halbe Stunde. Ein fertig ausgefülltes Gitter zu prüfen dauert eine Minute: Zeilen, Spalten, Blöcke abhaken. Genau diese Asymmetrie zwischen Lösen und Prüfen ist der Kern von $\NP$. \end{analogie} \subsection{Die erste Sicht: Zertifikat und Verifizierer} Die \glqq vorgelegte Lösung\grqq{} bekommt einen Namen. \begin{defn}{Verifizierer, Zertifikat} Ein \emph{Verifizierer} für ein Problem $L$ ist ein Algorithmus $A$, der zwei Eingaben bekommt: die eigentliche Instanz $x$ und einen Lösungsvorschlag $c$. Er erfüllt \[ x \in L \quad\Longleftrightarrow\quad \text{es gibt ein } c \text{ mit } A(x,c) = 1. \] Der Vorschlag $c$ heißt \emph{Zertifikat}. \end{defn} Lies die beiden Richtungen einzeln, beide sind wichtig. Ist $x$ eine Ja-Instanz, so \emph{gibt es} ein Zertifikat, das $A$ überzeugt. Ist $x$ eine Nein-Instanz, so überzeugt $A$ \emph{kein} Zertifikat -- man kann ihm vorlegen, was man will. \begin{defn}{Klasse NP} $\NP$ ist die Menge aller Probleme, die einen Verifizierer besitzen, der ein \emph{polynomiell langes} Zertifikat in \emph{polynomieller} Zeit prüft. \end{defn} \begin{intuition} $\NP$ heißt \glqq effizient \emph{überprüfbar}\grqq, nicht \glqq effizient \emph{lösbar}\grqq. Das Zertifikat ist die kurze Antwort auf die Frage \glqq und woher weiß ich, dass das stimmt?\grqq. Wer die Lösung schon in der Hand hält, kann sie billig kontrollieren -- sie zu \emph{finden} ist die eigentliche Arbeit. \end{intuition} \subsection{Die zweite Sicht: nichtdeterministisches Raten} Es gibt eine gleichwertige zweite Art, $\NP$ zu sehen. Stell dir einen Algorithmus vor, der an jeder Verzweigung nicht \emph{eine} Möglichkeit wählt, sondern sich in Kopien aufteilt und \emph{alle gleichzeitig} verfolgt. So ein Algorithmus heißt \emph{nichtdeterministisch}. Er \glqq akzeptiert\grqq, wenn \emph{irgendeine} Kopie ans Ziel kommt; für eine Nein-Instanz kommt keine an. Sein Arbeitsmuster ist immer dasselbe: \emph{rate die Lösung, dann prüfe sie}. Die Folge der Rate-Entscheidungen \emph{ist} genau das Zertifikat. Deshalb beschreiben \glqq richtig raten können\grqq{} und \glqq ein Zertifikat geschenkt bekommen\grqq{} dieselbe Fähigkeit -- und dieselbe Klasse $\NP$. Diese Rate-Sicht ist praktisch, wenn man einen NP-Nachweis in Worten führt: Man sagt, was die Maschine rät (das Zertifikat) und wie sie es danach deterministisch prüft. \subsection{P steckt in NP} \begin{satz}{$\Pclass \subseteq \NP$} Jedes effizient lösbare Problem ist auch effizient überprüfbar.\\[0.3em] \emph{Warum:} Wer ein Problem selbst schnell lösen kann, braucht das Zertifikat gar nicht. Er ignoriert es und rechnet die Antwort direkt aus. Der Löser ist damit ein besonders fauler Verifizierer. \end{satz} Die große offene Frage ist die Umkehrung: Gilt $\Pclass = \NP$? Ist alles, was man schnell prüfen kann, auch schnell lösbar? Niemand weiß es. Es ist eines der sieben Millennium-Probleme. Die meisten glauben $\Pclass \ne \NP$. Der ganze Rest des Kurses ist der Umgang mit dieser Unwissenheit. % ================================================================== \section{Reduktionen: Probleme vergleichen} % ================================================================== Jetzt das wichtigste Werkzeug. Mit einer \emph{Reduktion} vergleicht man zwei Probleme nach Schwierigkeit -- ohne für eines von beiden einen Algorithmus zu kennen. \begin{defn}{Polynomielle Reduktion $A \redp B$} Eine \emph{Reduktion} von $A$ auf $B$ ist eine Funktion $f$, die jede $A$-Eingabe $w$ in eine $B$-Eingabe $f(w)$ übersetzt, sodass die Antworten zusammenpassen: \[ w \in A \quad\Longleftrightarrow\quad f(w) \in B. \] Sie ist \emph{polynomiell}, wenn $f$ in polynomieller Zeit berechenbar ist. Man schreibt $A \redp B$. \end{defn} \begin{intuition} $A \redp B$ bedeutet: \glqq $B$ ist \emph{mindestens so schwer} wie $A$.\grqq{} Denn wer $B$ schnell lösen kann, löst über die billige Umformung $f$ auch $A$ schnell: erst $f(w)$ berechnen, dann den $B$-Löser fragen, dessen Antwort ist auch die für $w$. Die Schwierigkeit fließt entlang des Pfeils. \end{intuition} \begin{stolper} \textbf{Die Richtung ist der teuerste Fehler.} Um zu zeigen, dass ein \emph{neues} Problem $Y$ schwer ist, reduziert man ein \emph{bekannt schweres} $X$ \emph{auf} $Y$ -- also $X \redp Y$, \glqq bekannt $\redp$ neu\grqq. Die Reduktion nimmt eine $X$-Instanz und baut daraus eine $Y$-Instanz. Andersherum ($Y \redp X$) zeigt man nur, dass $Y$ \emph{höchstens} so schwer wie $X$ ist -- und das sagt über $Y$ nichts. \end{stolper} \begin{satz}{Transitivität} $A \redp B$ und $B \redp C$ ergeben zusammen $A \redp C$.\\[0.3em] \emph{Warum:} Man schaltet die beiden Umformungen hintereinander. Die Zwischenausgabe ist polynomiell groß, also bleibt die Verkettung polynomiell. \end{satz} Deshalb kann eine ganze \emph{Kette} von Reduktionen die Schwere Glied für Glied weitertragen. Genau diese Kette bauen wir im Problem-Katalog auf. % ================================================================== \section{NP-schwer, NP-vollständig, und der Anker} % ================================================================== Mit der Reduktion können wir \glqq die schwersten Probleme in $\NP$\grqq{} präzise fassen. \begin{defn}{NP-schwer, NP-vollständig} Ein Problem $L_0$ heißt \emph{NP-schwer}, wenn sich \emph{jedes} $L \in \NP$ auf $L_0$ reduzieren lässt ($L \redp L_0$). Es heißt \emph{NP-vollständig}, wenn es NP-schwer ist \textbf{und} selbst in $\NP$ liegt. \end{defn} \begin{intuition} Zwei Schranken treffen sich. \emph{NP-schwer} ist eine untere Schranke: mindestens so schwer wie alles in $\NP$. \emph{In $\NP$} ist eine obere Schranke: nicht schwerer als $\NP$. \emph{NP-vollständig} heißt beides -- die schwersten Probleme innerhalb von $\NP$. \end{intuition} \begin{satz}{Ein Algorithmus für eines löst alle} Ist $L_0$ NP-vollständig, dann gilt $\Pclass = \NP$ genau dann, wenn $L_0 \in \Pclass$.\\[0.3em] \emph{Warum:} Läge $L_0$ in $\Pclass$, könnte man jedes $L \in \NP$ lösen -- erst die Reduktion $L \redp L_0$ rechnen, dann den schnellen $L_0$-Löser. Damit läge ganz $\NP$ in $\Pclass$. \end{satz} Damit die Reduktionskette starten kann, braucht man ein \emph{erstes} NP-vollständiges Problem, das man von Hand als schwer nachweist. Das lieferten Cook und Levin. \begin{satz}{Cook (1971), Levin (1973)} \problem{SAT} ist NP-vollständig -- das erste solche Problem.\\[0.3em] \emph{Die Idee:} Man nimmt ein \emph{beliebiges} $L \in \NP$ mit seiner ratenden Maschine und gießt deren gesamte Rechnung in eine große logische Formel. Variablen beschreiben Aussagen wie \glqq zur Zeit $t$ ist die Maschine im Zustand $q$\grqq{} oder \glqq zur Zeit $t$ steht auf Feld $i$ das Symbol $a$\grqq. Teilformeln erzwingen einen gültigen Ablauf. Das Entscheidende: Eine erfüllende Belegung entspricht \emph{genau} einem akzeptierenden Rechenweg. Also ist die Formel erfüllbar genau dann, wenn $L$ die Eingabe akzeptiert. Da $L$ beliebig war, ist \problem{SAT} schwer für ganz $\NP$. \end{satz} \begin{idee}{Das Vererbungskorollar -- so wächst der Katalog} Um ein \emph{neues} Problem $Y$ als NP-vollständig nachzuweisen, genügen zwei Dinge: (1) eine Reduktion $X \redp Y$ von einem \emph{bereits bekannten} NP-vollständigen $X$, und (2) der Nachweis $Y \in \NP$. Denn dann gilt für jedes $L \in \NP$ die Kette $L \redp X \redp Y$ -- also ist $Y$ NP-schwer, und mit $Y \in \NP$ auch NP-vollständig. \end{idee} Ab hier braucht man nie wieder \glqq alle $L \in \NP$\grqq{} zu betrachten. Jedes neue Problem hängt sich über \emph{eine} Reduktion an ein schon bekanntes. Der folgende Katalog geht genau so vor: Er beginnt bei \problem{SAT} und hängt jedes Problem an ein früheres. Deshalb steht bei jedem Problem, \emph{woher} seine Schwere kommt (die eingehende Reduktion) und \emph{wohin} sie weiterfließt (die ausgehenden Reduktionen). \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(13,8.7)(0,-0.3) \put(5.1,7.7){\framebox(2.4,0.7){\textbf{\problem{SAT}}}} \put(6.3,7.7){\vector(-2,-1){2.6}} \put(6.3,7.7){\vector(0,-1){1.3}} \put(6.3,7.7){\vector(2,-1){2.6}} \put(2.6,5.7){\framebox(2.0,0.7){\problem{3-SAT}}} \put(5.3,5.7){\framebox(2.0,0.7){\problem{$k$-Clique}}} \put(8.0,5.7){\framebox(2.0,0.7){\problem{3-DM}}} \put(3.6,5.7){\vector(0,-1){1.3}} \put(6.3,5.7){\vector(0,-1){1.3}} \put(9.0,5.7){\vector(0,-1){1.3}} \put(2.4,3.7){\framebox(2.4,0.7){\problem{Color}, \problem{HK}}} \put(5.1,3.7){\framebox(2.4,0.7){\problem{IS}, \problem{VC}}} \put(8.0,3.7){\framebox(2.0,0.7){\problem{3-EC}}} \put(3.6,3.7){\vector(0,-1){1.3}} \put(6.3,3.7){\vector(0,-1){1.3}} \put(9.0,3.7){\vector(0,-1){1.3}} \put(2.2,1.7){\framebox(2.8,0.7){\problem{HK}$\to$\problem{TSP}; Hitting Set}} \put(5.1,1.7){\framebox(2.4,0.7){\problem{FVS}, $\Delta$-Cover}} \put(8.0,1.7){\framebox(2.0,0.7){\problem{SubSetSum}}} \put(9.0,1.7){\vector(0,-1){1.3}} \put(6.6,0.0){\framebox(3.8,0.7){\problem{Partition}, \problem{Knapsack}, $P\|\Cmax$}} \end{picture} \end{center} % ################################################################## \part*{Teil B -- Der Problem-Katalog} \addcontentsline{toc}{section}{\textbf{Teil B -- Der Problem-Katalog}} % ################################################################## \noindent Jetzt kommt das Herzstück. Wir gehen alle Probleme des Kurses durch -- jedes für sich, keines mit einem anderen zusammengelegt. Der Aufbau ist bei jedem gleich: erst die \textbf{Definition} mit Beispiel, dann \textbf{warum es in $\NP$ liegt}, dann \textbf{woher seine Schwere kommt} (die eingehende Reduktion) und schließlich \textbf{was daraus folgt} (die ausgehenden Reduktionen). Die Reihenfolge folgt der Reduktionskette: Jedes Problem wird an ein früheres gehängt, das du schon kennst. % ================================================================== \section{SAT} % ================================================================== \problem{SAT} steht am Anfang von allem -- es ist das erste NP-vollständige Problem und der Anker, an dem die ganze Kette hängt. Es geht um Formeln der Aussagenlogik in einer festen Form. \begin{defn}{SAT} Eine \emph{konjunktive Normalform} (KNF) ist ein UND von \emph{Klauseln}, wobei jede Klausel ein ODER von \emph{Literalen} ist; ein Literal ist eine Variable $x_j$ oder ihre Verneinung $\neg x_j$. \problem{SAT} fragt: Gegeben eine KNF-Formel $\alpha$, gibt es eine Belegung der Variablen mit wahr/falsch, die die ganze Formel wahr macht -- also jede Klausel erfüllt? \end{defn} \begin{bsp}{SAT von Hand} $\alpha = (x_1 \vee x_{10}) \wedge (x_1 \vee \neg x_{10}) \wedge (x_{10})$. Die dritte Klausel besteht nur aus $x_{10}$ und zwingt daher $x_{10} = \true$. Damit die zweite Klausel wahr wird -- $\neg x_{10}$ ist jetzt falsch -- muss $x_1 = \true$ sein. Mit beiden auf wahr ist auch die erste Klausel erfüllt. Die Formel ist also erfüllbar, ein Zeuge ist $x_1 = x_{10} = \true$. \end{bsp} \subsection*{Warum SAT in NP liegt} Wir führen den Nachweis vollständig, in vier Gedanken. \emph{Das Zertifikat.} Die \glqq Lösung\grqq{} einer erfüllbaren Formel ist eine Belegung $\psi$ -- für jede Variable ein Wahrheitswert. Man kodiert sie mit einem Bit pro Variable. Hat die Formel $v$ Variablen, so ist das Zertifikat $v$ Bits lang, also höchstens so lang wie die Formel selbst und damit polynomiell. \emph{Die Prüfung.} Der Verifizierer bekommt die Formel $\alpha$ und die Belegung $\psi$. Er setzt $\psi$ in $\alpha$ ein und wertet Klausel für Klausel aus: Eine Klausel ist wahr, sobald eines ihrer Literale wahr ist. Er akzeptiert genau dann, wenn \emph{alle} Klauseln wahr sind. \emph{Warum das korrekt ist -- beide Richtungen.} Ist $\alpha$ erfüllbar, so gibt es eine erfüllende Belegung; legt man genau sie als Zertifikat vor, macht sie jede Klausel wahr und der Verifizierer akzeptiert. Ist $\alpha$ dagegen unerfüllbar, so macht \emph{keine} Belegung alle Klauseln wahr -- egal, welches $\psi$ man vorlegt, mindestens eine Klausel bleibt falsch und der Verifizierer lehnt ab. Beide Richtungen stimmen also. \emph{Die Laufzeit.} Das Einsetzen und Auswerten geht die Formel einmal durch, kostet also lineare Zeit in der Formellänge. Damit ist der Verifizierer polynomiell, und es folgt $\problem{SAT} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{Cook--Levin: jede NDTM-Rechnung wird zu einer Formel} \problem{SAT} ist nicht über eine Reduktion von einem \emph{anderen} Problem schwer -- es ist der Startpunkt. Cook und Levin zeigen direkt, dass sich \emph{jedes} $L \in \NP$ auf \problem{SAT} reduziert. Zu einem $L$ mit ratender Maschine $M$ und Eingabe $u$ baut man eine KNF $\alpha_u$, deren Variablen die gesamte Rechnung von $M$ beschreiben: \glqq zur Zeit $t$ ist der Zustand $q$\grqq, \glqq zur Zeit $t$ steht auf Feld $i$ das Symbol $a$\grqq{} und so weiter. Teilformeln erzwingen einen korrekten Anfang, korrekte Übergänge und einen akzeptierenden Schluss. Dann gilt: $\alpha_u$ ist erfüllbar genau dann, wenn $M$ die Eingabe $u$ akzeptiert. Also $u \in L \iff \alpha_u \in \problem{SAT}$. \end{idee} \subsection*{Was daraus folgt} Von \problem{SAT} gehen mehrere Reduktionen aus -- sie machen die nächsten Probleme schwer. \begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: lange Klauseln aufspalten} Eine lange Klausel wird mit einer neuen Hilfsvariablen in zwei kürzere zerlegt, etwa $(y_1 \vee y_2 \vee y_3 \vee y_4)$ in $(y_1 \vee y_2 \vee x) \wedge (\neg x \vee y_3 \vee y_4)$. Ist ursprünglich ein $y_i$ wahr, lässt sich $x$ passend setzen; ist keines wahr, entsteht in der Kette ein Widerspruch. So schrumpfen alle Klauseln auf höchstens drei Literale, ohne die Erfüllbarkeit zu ändern. \end{idee} \begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten pro Literal} Man baut einen Graphen mit \emph{einem Knoten pro Literalvorkommen} und verbindet zwei Knoten genau dann, wenn sie aus verschiedenen Klauseln stammen und sich nicht widersprechen. Gesucht wird eine Clique der Größe $k = m$ (Zahl der Klauseln). Eine solche Clique wählt aus jeder Klausel ein widerspruchsfreies, wahres Literal -- also eine erfüllende Belegung. (Diese Reduktion zeichnen wir beim Cliquenproblem in Ruhe.) \end{idee} \begin{idee}{$\problem{SAT} \redp \problem{3-dim.\ Matching}$: Zahnrad und Garbage Collection} Pro Variable baut man eine \glqq Zahnrad\grqq-Struktur aus Tripeln, die nur zwei konsistente Auswahlen zulässt -- Variable wahr oder falsch. Klausel-Tripel prüfen, ob ein erfüllendes Literal gewählt wurde, und eine \glqq Garbage-Collection\grqq{} aus weiteren Tripeln räumt die übrig gebliebenen Literale weg. \end{idee} \begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: alle Belegungen durchprobieren} Zu einer Formel $\varphi$ baut man ein Programm, das der Reihe nach alle Belegungen durchprobiert und genau dann anhält, wenn es eine erfüllende findet. Dann hält das Programm genau dann, wenn $\varphi$ erfüllbar ist. (Mehr dazu beim Halteproblem am Ende des Katalogs.) \end{idee} % ================================================================== \section{3-SAT} % ================================================================== \problem{3-SAT} ist die \glqq handliche\grqq{} Version von \problem{SAT}. Kurze Klauseln lassen sich viel leichter in andere Probleme einbauen, deshalb starten fast alle späteren Reduktionen hier statt beim allgemeinen \problem{SAT}. \begin{defn}{3-SAT} Wie \problem{SAT}, aber jede Klausel hat \emph{höchstens drei} Literale. Frage: Ist die Formel erfüllbar? \end{defn} \begin{bsp}{3-SAT von Hand} $\alpha = (x_1 \vee x_2 \vee \neg x_3) \wedge (\neg x_1 \vee x_2)$. Setzt man $x_2 = \true$, so ist die zweite Klausel über $x_2$ erfüllt und die erste ebenfalls. Also erfüllbar, unabhängig von $x_1$ und $x_3$. \end{bsp} \subsection*{Warum 3-SAT in NP liegt} Wir führen den Nachweis eigenständig und vollständig -- auch wenn er dem von \problem{SAT} ähnelt. \emph{Das Zertifikat.} Wieder eine Belegung $\psi$, ein Bit pro Variable, also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer setzt $\psi$ in die Formel ein und wertet jede Klausel aus. Weil jede Klausel jetzt höchstens drei Literale hat, kostet das Auswerten einer Klausel sogar nur konstante Zeit; er akzeptiert, wenn alle Klauseln wahr sind. \emph{Warum das korrekt ist -- beide Richtungen.} Ist die Formel erfüllbar, wird die erfüllende Belegung akzeptiert. Ist sie unerfüllbar, bleibt bei jeder Belegung mindestens eine Klausel falsch, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Ein Durchlauf durch die Formel, also linear. Damit $\problem{3-SAT} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: lange Klauseln zerlegen} Man ersetzt jede zu lange Klausel durch eine \emph{Kette} kürzerer Klauseln, die durch neue Hilfsvariablen verbunden sind. Eine Klausel $(y_1 \vee y_2 \vee y_3 \vee y_4)$ wird etwa zu $(y_1 \vee y_2 \vee x) \wedge (\neg x \vee y_3 \vee y_4)$ mit einer neuen Variablen $x$. Bei längeren Klauseln setzt sich diese Kette fort: $(y_1 \vee y_2 \vee x_1) \wedge (\neg x_1 \vee y_3 \vee x_2) \wedge \dots$ \end{idee} Warum das die Erfüllbarkeit erhält -- beide Richtungen. Ist die ursprüngliche Klausel erfüllt, so ist eines ihrer Literale $y_i$ wahr; dann kann man die Hilfsvariablen der Kette so setzen, dass jede kurze Klausel wahr wird (vor $y_i$ die $x$-Literale wahr, danach die $\neg x$-Literale). Ist umgekehrt \emph{kein} $y_i$ wahr, so erzwingt die erste kurze Klausel, dass ihre Hilfsvariable wahr sein muss, diese erzwingt die nächste, und so fort -- am Ende der Kette entsteht ein Widerspruch, die kurze Formel ist also nicht erfüllbar. Erfüllbar bleibt genau erfüllbar. Da jede Klausel nur konstant vergrößert wird, ist die Umformung polynomiell. Weil \problem{SAT} NP-vollständig ist und $\problem{3-SAT} \in \NP$ gilt, ist auch \problem{3-SAT} NP-vollständig. \subsection*{Was daraus folgt} \begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Wahrheit als Farbe} Man baut ein Gadget mit den Knoten $x_i, \bar x_i, v_i$ pro Variable, einem Klauselknoten pro Klausel und einem Zentrum $z$. Die $v_i$ und $z$ bilden eine Clique und erzwingen $n+1$ Farben; dadurch bleibt jedem Paar $x_i, \bar x_i$ nur \glqq wahr\grqq{} oder \glqq falsch\grqq. Die Klauselknoten sind so verdrahtet, dass sie sich genau dann korrekt färben lassen, wenn die Klausel erfüllt ist. \end{idee} \begin{idee}{$\problem{3-SAT}' \redp \problem{Hamiltonkreis}$: A- und B-Komponenten} Für die Variante mit genau drei Literalen pro Klausel baut man \glqq A-Komponenten\grqq, die die Variablensetzung kodieren (zwei Durchlaufrichtungen = wahr/falsch), und \glqq B-Komponenten\grqq{} pro Klausel, die nur dann durchlaufbar sind, wenn mindestens ein Literal wahr ist. Ein Hamiltonkreis existiert genau dann, wenn eine erfüllende Belegung existiert. \end{idee} \begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$} Das Universum sind alle Literale $x_i, \bar x_i$. Pro Variable bildet man die Menge $\{x_i, \bar x_i\}$ (sie zwingt die Trefferwahl, genau ein Literal je Variable zu wählen), pro Klausel die Menge ihrer Literale (sie verlangt, dass ein erfüllendes Literal getroffen wird). Mit Schranke $k = n$ trifft eine Lösung genau dann alle Mengen, wenn die Formel erfüllbar ist. \end{idee} % ================================================================== \section{$k$-Clique} % ================================================================== Das Cliquenproblem aus der Einleitung, jetzt vollständig behandelt. \begin{defn}{$k$-Clique} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine \emph{Clique} ist eine Knotengruppe, in der alle paarweise durch eine Kante verbunden sind. Frage: Gibt es eine Clique der Größe $\ge k$? \end{defn} \begin{bsp}{Eine Clique} Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{1,3\}, \{2,3\}, \{3,4\}$ ist $\{1,2,3\}$ eine Clique der Größe 3, weil die drei Kanten zwischen ihnen existieren. $\{1,3,4\}$ ist keine Clique, weil zwischen 1 und 4 die Kante fehlt. \end{bsp} \subsection*{Warum $k$-Clique in NP liegt} \emph{Das Zertifikat.} Die Lösung ist die Knotengruppe $C \subseteq V$ selbst, etwa als Liste der gewählten Knoten. Sie hat höchstens $|V|$ Einträge, ist also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer bekommt $(G, k)$ und die Gruppe $C$. Er prüft zwei Dinge. Erstens, ob wirklich \emph{jedes} Paar $\{u,v\}$ aus $C$ durch eine Kante verbunden ist -- dazu geht er alle Paare aus $C$ durch und schlägt in der Kantenliste nach. Zweitens, ob $|C| \ge k$ gilt. Er akzeptiert, wenn beides zutrifft. \emph{Warum das korrekt ist -- beide Richtungen.} Gibt es eine $k$-Clique, so ist genau sie ein Zertifikat, bei dem alle Paare verbunden sind und die Größe stimmt; der Verifizierer akzeptiert. Gibt es keine, so hat jede vorgelegte Gruppe der Größe $\ge k$ mindestens ein unverbundenes Paar, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Es gibt höchstens $\binom{|C|}{2} = O(|V|^2)$ Paare, jeder Kantennachschlag kostet $O(1)$; die Größenprüfung kostet $O(|V|)$. Insgesamt $O(|V|^2)$, also polynomiell. Damit $\problem{$k$-Clique} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten pro Literal} Zu einer KNF $F = F_1 \wedge \dots \wedge F_m$ baut man den Graphen so: Für jedes Literalvorkommen -- das $j$-te Literal in Klausel $i$ -- setzt man einen Knoten $[i,j]$. Zwei Knoten werden verbunden, wenn sie aus \emph{verschiedenen} Klauseln stammen \emph{und} sich nicht widersprechen (nicht $x$ gegen $\neg x$). Gesucht ist eine Clique der Größe $k = m$. \end{idee} Warum das stimmt: Eine $m$-Clique muss aus jeder Klausel genau einen Knoten nehmen -- Knoten derselben Klausel sind nie verbunden, es passt also höchstens einer pro Klausel hinein, und bei $m$ Knoten ist es genau einer. Weil verbundene Knoten sich nicht widersprechen, wählt die Clique aus jeder Klausel ein widerspruchsfreies Literal. Setzt man diese Literale auf wahr, erfüllt man jede Klausel. Umgekehrt liefert jede erfüllende Belegung eine solche Clique. \begin{bsp}{$\problem{SAT} \redp \problem{Clique}$ am Beispiel} $F = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_1 \vee \neg x_2) \wedge (x_1 \vee \neg x_2 \vee \neg x_3)$, also $m = 3$ und $k = 3$. Es entstehen acht Knoten in drei Spalten (eine je Klausel). Fett die Lösungs-Clique $\{[1,1],[2,2],[3,1]\}$, die für $x_1, \neg x_2, x_1$ steht und die Belegung $x_1 = \true$, $x_2 = \false$ liefert. \setlength{\unitlength}{1cm} \begin{center} \begin{picture}(10,3.6)(-0.7,-0.4) \put(1.0,3.3){\small Klausel 1} \put(0.5,2.6){\circle*{0.17}}\put(-0.7,2.55){\small $[1,1]\,x_1$} \put(0.5,1.5){\circle{0.17}}\put(-0.05,1.42){\small $x_2$} \put(0.5,0.5){\circle{0.17}}\put(-0.05,0.42){\small $x_3$} \put(4.0,3.3){\small Klausel 2} \put(4.5,2.6){\circle{0.17}}\put(4.7,2.55){\small $\neg x_1$} \put(4.5,1.5){\circle*{0.17}}\put(4.7,1.42){\small $[2,2]\,\neg x_2$} \put(7.6,3.3){\small Klausel 3} \put(8.5,2.6){\circle*{0.17}}\put(7.15,2.55){\small $x_1\,[3,1]$} \put(8.5,1.5){\circle{0.17}}\put(8.7,1.42){\small $\neg x_2$} \put(8.5,0.5){\circle{0.17}}\put(8.7,0.42){\small $\neg x_3$} \linethickness{1.3pt} \put(0.5,2.6){\line(4,-1){4}} \put(4.5,1.5){\line(4,1){4}} \put(0.5,2.6){\line(1,0){8}} \end{picture} \end{center} Die drei fetten Kanten bilden das Dreieck (die 3-Clique). Die vielen dünnen Kanten zwischen anderen verträglichen Paaren sind der Übersicht halber weggelassen. \end{bsp} \subsection*{Was daraus folgt} \begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement} Aus $(G, k)$ mit $n = |V|$ macht man $(\bar G, n-k)$ -- Komplementgraph und Schranke $n-k$. Eine Clique der Größe $k$ in $G$ ist ein Independent Set in $\bar G$, und dessen Rest $V \setminus C$ ein Vertex Cover der Größe $n-k$. (Ausführlich beim Vertex Cover.) \end{idee} \begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Komplement} Aus $(G,k)$ macht man $(\bar G, k)$. Eine Clique in $G$ ist genau ein Independent Set im Komplementgraphen $\bar G$ -- dort fehlen genau die Kanten, die $G$ hat. \end{idee} \begin{idee}{$\problem{Clique} \redp \problem{Clique-Nomember}$: isolierter Dummy} \problem{Clique-Nomember} fragt nach einer $k$-Clique, die einen bestimmten Knoten $v$ \emph{nicht} enthält. Man fügt einfach einen neuen, isolierten Knoten $v$ hinzu -- er kann in keiner Clique liegen, also ändert die Zusatzbedingung nichts an der Antwort. \end{idee} \begin{idee}{$\problem{Clique} \redp \problem{Clique-Universal}$: universeller Knoten} \problem{Clique-Universal} verlangt, dass die Instanz einen \emph{universellen} Knoten enthält (mit allen verbunden). Man fügt einen solchen Knoten $u$ hinzu und erhöht die Schranke auf $k+1$. Jede $k$-Clique in $G$ wird mit $u$ zu einer $(k+1)$-Clique, und umgekehrt. \end{idee} % ================================================================== \section{Independent Set} % ================================================================== \problem{Independent Set} ist das genaue Gegenstück zur Clique: Dort sind alle verbunden, hier keiner. \begin{defn}{Independent Set (IS)} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Independent Set} ist eine Knotengruppe, in der \emph{keine} zwei Knoten verbunden sind. Frage: Gibt es ein Independent Set der Größe $\ge k$? \end{defn} \begin{bsp}{Ein Independent Set} Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{2,3\}, \{3,4\}$ ist $\{1,3\}$ ein Independent Set der Größe 2 -- zwischen 1 und 3 gibt es keine Kante. Auch $\{1,4\}$ ist eines. $\{1,2\}$ ist keines, weil 1 und 2 verbunden sind. \end{bsp} \subsection*{Warum Independent Set in NP liegt} \emph{Das Zertifikat.} Die Knotengruppe $I \subseteq V$, polynomiell lang. \emph{Die Prüfung.} Der Verifizierer geht alle Paare aus $I$ durch und prüft, dass \emph{keines} von ihnen durch eine Kante verbunden ist; außerdem prüft er $|I| \ge k$. Er akzeptiert, wenn beides zutrifft. \emph{Warum das korrekt ist -- beide Richtungen.} Gibt es ein Independent Set der Größe $\ge k$, wird es akzeptiert. Gibt es keines, enthält jede vorgelegte Gruppe der Größe $\ge k$ ein verbundenes Paar, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Wieder $O(|V|^2)$ Paare mit je $O(1)$-Kantennachschlag, plus $O(|V|)$ für die Größe. Insgesamt $O(|V|^2)$, also $\problem{IS} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Komplementgraph} Man bildet den Komplementgraphen $\bar G$ (dieselben Knoten, genau die fehlenden Kanten) und behält die Schranke $k$. Eine Knotengruppe $C$ ist genau dann eine Clique in $G$, wenn zwischen ihren Knoten in $\bar G$ \emph{keine} Kante liegt -- also ein Independent Set in $\bar G$. So wird aus der $k$-Clique-Frage in $G$ wörtlich die $k$-IS-Frage in $\bar G$. \end{idee} \subsection*{Was daraus folgt} \problem{Independent Set} ist im Kurs vor allem das Bindeglied der Dualität zwischen Clique, IS und Vertex Cover: Eine Menge $I$ ist genau dann ein Independent Set, wenn ihr Komplement $V \setminus I$ ein Vertex Cover ist. Diese Beziehung wird beim Vertex Cover benutzt. Eine eigenständige Reduktion \emph{von} Independent Set auf ein weiteres Kursproblem wird im Material nicht geführt. % ================================================================== \section{Vertex Cover} % ================================================================== \problem{Vertex Cover} ist das dritte Problem des engen Verwandtenkreises -- und der Startpunkt für mehrere weitere Reduktionen. \begin{defn}{Vertex Cover (VC)} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Vertex Cover} ist eine Knotenmenge, die \emph{jede} Kante berührt (von jeder Kante liegt mindestens ein Endpunkt in der Menge). Frage: Gibt es ein Vertex Cover der Größe $\le k$? \end{defn} \begin{bsp}{Ein Vertex Cover} Im Graphen mit $V = \{1,2,3,4\}$ und Kanten $\{1,2\}, \{2,3\}, \{3,4\}$ ist $\{2,3\}$ ein Vertex Cover der Größe 2: Kante $\{1,2\}$ berührt 2, $\{2,3\}$ berührt beide, $\{3,4\}$ berührt 3. Der einzelne Knoten $\{2\}$ genügt nicht -- $\{3,4\}$ bliebe unberührt. \end{bsp} \subsection*{Warum Vertex Cover in NP liegt} \emph{Das Zertifikat.} Die Knotenmenge $C \subseteq V$, polynomiell lang. \emph{Die Prüfung.} Der Verifizierer geht \emph{jede} Kante $\{u,v\} \in E$ durch und prüft, ob $u \in C$ oder $v \in C$ gilt -- ob die Kante also berührt wird. Zusätzlich prüft er $|C| \le k$. Er akzeptiert, wenn jede Kante berührt ist und die Größe stimmt. \emph{Warum das korrekt ist -- beide Richtungen.} Gibt es ein Vertex Cover der Größe $\le k$, wird es akzeptiert. Gibt es keines, bleibt bei jeder vorgelegten Menge dieser Größe mindestens eine Kante unberührt, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Ein Durchlauf durch alle Kanten, also $O(|E|)$, plus $O(|V|)$ für die Größe. Damit $\problem{VC} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement und $n-k$} Aus der Clique-Instanz $(G, k)$ mit $n = |V|$ bildet man den Komplementgraphen $\bar G$ und fragt nach einem Vertex Cover der Größe $\le n - k$. Der Grund für das $n-k$ steckt in der Dualität: Eine Clique der Größe $k$ in $G$ ist ein Independent Set der Größe $k$ in $\bar G$; das Komplement eines Independent Set ist ein Vertex Cover; also wird aus einem IS der Größe $k$ ein VC der Größe $n - k$. \end{idee} \begin{aha} \textbf{Das Dualitätsdreieck} fasst alle drei Probleme in einem Bild zusammen. Für einen Graphen $G$, seinen Komplementgraphen $\bar G$ und jede Knotenmenge $C$ gilt: \[ C \text{ Clique in } G \;\iff\; C \text{ Independent Set in } \bar G \;\iff\; V \setminus C \text{ Vertex Cover in } \bar G. \] \end{aha} \begin{bsp}{Ein Bild, drei Rollen} Links ein Graph $G$, in dem $\{1,2,3\}$ eine Clique ist; rechts sein Komplement $\bar G$, in dem dieselbe Menge ein Independent Set ist und der Knoten $\{4\}$ ein Vertex Cover. \setlength{\unitlength}{1cm} \begin{center} \begin{picture}(12,3.2)(0,-0.5) \put(1.3,2.6){\small $G$: $\{1,2,3\}$ ist Clique} \put(1,0){\circle*{0.15}}\put(0.6,-0.05){\small $1$} \put(1,1.7){\circle*{0.15}}\put(0.6,1.65){\small $2$} \put(2.5,0.85){\circle*{0.15}}\put(2.65,0.8){\small $3$} \put(3.9,0.85){\circle*{0.15}}\put(4.05,0.8){\small $4$} \put(1,0){\line(0,1){1.7}} \qbezier(1,0)(1.75,0.42)(2.5,0.85) \qbezier(1,1.7)(1.75,1.27)(2.5,0.85) \put(7.0,2.6){\small $\bar G$: $\{1,2,3\}$ ist IS, $\{4\}$ ist VC} \put(7,0){\circle*{0.15}}\put(6.6,-0.05){\small $1$} \put(7,1.7){\circle*{0.15}}\put(6.6,1.65){\small $2$} \put(8.5,0.85){\circle*{0.15}}\put(8.2,1.0){\small $3$} \put(10,0.85){\circle*{0.15}}\put(10.15,0.8){\small $4$} \qbezier(7,0)(8.5,0.42)(10,0.85) \qbezier(7,1.7)(8.5,1.27)(10,0.85) \put(8.5,0.85){\line(1,0){1.5}} \end{picture} \end{center} \end{bsp} \subsection*{Was daraus folgt} \begin{idee}{$\problem{VC} \redp \problem{Feedback Vertex Set}$: antiparallele Bögen} Man macht aus jeder ungerichteten Kante $\{u,v\}$ zwei entgegengesetzte Pfeile $u \to v$ und $v \to u$ -- einen gerichteten Kreis der Länge 2. Ein Knoten, der die Kante überdeckt, zerstört genau diesen Kreis. (Ausführlich beim FVS.) \end{idee} \begin{idee}{$\problem{VC} \redp \Delta\text{-Cover}$: Kante wird Dreieck} Man hängt an jede Kante $\{u,v\}$ einen neuen Knoten $v_e$ und bildet so das Dreieck $\{v_e, u, v\}$. Ein Knoten, der die Kante überdeckt, trifft auch dieses Dreieck. (Ausführlich beim $\Delta$-Cover.) \end{idee} % ================================================================== \section{Feedback Vertex Set} % ================================================================== Das erste Problem, das nicht mehr von der Clique-Familie kommt, sondern vom Vertex Cover. Es spielt auf \emph{gerichteten} Graphen. \begin{defn}{Feedback Vertex Set (FVS)} Gegeben ein \emph{gerichteter} Graph $G = (V,E)$ und eine Zahl $k$. Frage: Gibt es eine Knotenmenge $X \subseteq V$ mit $|X| \le k$, sodass $G \setminus X$ \emph{kreisfrei} ist (keinen gerichteten Kreis mehr enthält)? \end{defn} \begin{bsp}{Ein Feedback Vertex Set} Hat ein gerichteter Graph die Kreise $a \to b \to a$ und $b \to c \to b$, so zerstört das Entfernen von $b$ beide Kreise auf einmal -- $\{b\}$ ist ein Feedback Vertex Set der Größe 1. \end{bsp} \subsection*{Warum Feedback Vertex Set in NP liegt} \emph{Das Zertifikat.} Die Knotenmenge $X \subseteq V$, ein Bit pro Knoten, also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer prüft zuerst $|X| \le k$. Dann muss er feststellen, ob $G \setminus X$ kreisfrei ist. Dafür benutzt er einen bekannten Algorithmus aus der Vorlesung: die \emph{topologische Sortierung}. Sie findet genau dann eine Reihenfolge der Knoten, in der alle Kanten \glqq nach vorne\grqq{} zeigen, wenn der Graph kreisfrei ist. Der Verifizierer akzeptiert, wenn die Größe stimmt und die Sortierung gelingt. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein FVS der Größe $\le k$, so ist $G \setminus X$ kreisfrei, die topologische Sortierung gelingt, der Verifizierer akzeptiert. Existiert keines, so bleibt bei jeder Menge $X$ dieser Größe ein Kreis übrig, die Sortierung scheitert, der Verifizierer lehnt ab. \emph{Die Laufzeit.} Die topologische Sortierung läuft in $O(|V| + |E|)$, die Größenprüfung in $O(|V|)$. Damit $\problem{FVS} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{VC} \redp \problem{FVS}$: jede Kante wird ein 2-Kreis} Aus der ungerichteten VC-Instanz $(G, k)$ baut man einen gerichteten Graphen, indem man jede Kante $\{u,v\}$ durch \emph{zwei antiparallele Bögen} $u \to v$ und $v \to u$ ersetzt. Die Schranke bleibt $k$. \end{idee} \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(9,1.7)(0,-0.4) \put(0.6,0.5){\circle*{0.14}}\put(0.3,0.7){\small $u$} \put(2.6,0.5){\circle*{0.14}}\put(2.75,0.7){\small $v$} \put(0.6,0.5){\line(1,0){2}} \put(1.1,-0.05){\small ungerichtete Kante in $G$} \put(3.4,0.45){\small $\leadsto$} \put(5.0,0.5){\circle*{0.14}}\put(4.7,0.7){\small $u$} \put(7.0,0.5){\circle*{0.14}}\put(7.15,0.7){\small $v$} \put(5.15,0.68){\vector(1,0){1.7}} \put(6.85,0.32){\vector(-1,0){1.7}} \put(5.0,-0.05){\small zwei antiparallele Bögen in $G'$} \end{picture} \end{center} Warum das stimmt: Jeder gerichtete Kreis in diesem Graphen benutzt Bögen, die aus Original-Kanten entstanden sind. Der kleinste solche Kreis ist ein 2-Kreis $u \to v \to u$, der genau aus einer Kante $\{u,v\}$ stammt. Um ihn zu zerstören, muss man $u$ oder $v$ entfernen -- also die Kante \glqq überdecken\grqq. Ist $C$ ein Vertex Cover, so berührt es jede Kante und zerstört damit jeden 2-Kreis; der Graph wird kreisfrei. Ist umgekehrt $X$ ein FVS, so muss es jeden 2-Kreis treffen, also jede Kante überdecken -- $X$ ist ein Vertex Cover. \subsection*{Was daraus folgt} Von \problem{Feedback Vertex Set} geht im Kurs keine weitere Reduktion aus; es ist ein Endpunkt der Kette. % ================================================================== \section{$\Delta$-Cover (Dreiecksüberdeckung)} % ================================================================== Auch dieses Problem erbt seine Schwere vom Vertex Cover, über ein anderes Gadget. \begin{defn}{$\Delta$-Cover} Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{$\Delta$-Cover} ist eine Knotenmenge $C_\Delta \subseteq V$, die \emph{jedes Dreieck} (jede 3-Clique) von $G$ trifft -- von jedem Dreieck liegt also mindestens ein Knoten in $C_\Delta$. Frage: Gibt es ein $\Delta$-Cover der Größe $\le k$? \end{defn} \begin{bsp}{Ein $\Delta$-Cover} Besteht $G$ aus einem einzigen Dreieck $\{a,b,c\}$, so genügt ein beliebiger seiner Knoten, etwa $\{a\}$, um das Dreieck zu treffen -- ein $\Delta$-Cover der Größe 1. \end{bsp} \subsection*{Warum $\Delta$-Cover in NP liegt} \emph{Das Zertifikat.} Die Knotenmenge $C_\Delta \subseteq V$, polynomiell lang. \emph{Die Prüfung.} Der Verifizierer prüft $|C_\Delta| \le k$. Danach muss er sicherstellen, dass jedes Dreieck getroffen wird. Dazu geht er alle Knoten\emph{tripel} durch -- davon gibt es höchstens $\binom{|V|}{3} = O(|V|^3)$ -- und für jedes Tripel prüft er, ob es ein Dreieck bildet (alle drei Kanten vorhanden) und, falls ja, ob mindestens einer seiner Knoten in $C_\Delta$ liegt. Er akzeptiert, wenn die Größe stimmt und kein Dreieck ungedeckt bleibt. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein $\Delta$-Cover der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge dieser Größe ein Dreieck ungetroffen, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Es gibt $O(|V|^3)$ Tripel, jede Dreiecks- und Trefferprüfung kostet $O(|V|)$; insgesamt $O(|V|^4)$, also polynomiell. Damit $\Delta\text{-Cover} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{VC} \redp \Delta\text{-Cover}$: jede Kante wird ein Dreieck} Aus der VC-Instanz $(G,k)$ baut man $G'$: Für jede Kante $e = \{u,v\}$ fügt man einen neuen Knoten $v_e$ hinzu und die Kanten $\{v_e, u\}$ und $\{v_e, v\}$. So wird jede Kante zum Dreieck $\{v_e, u, v\}$ aufgeblasen. Die Schranke bleibt $k$. \end{idee} \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(9,2.2)(0,-0.4) \put(0.6,0.4){\circle*{0.14}}\put(0.3,0.55){\small $u$} \put(2.6,0.4){\circle*{0.14}}\put(2.75,0.55){\small $v$} \put(0.6,0.4){\line(1,0){2}} \put(1.0,-0.1){\small Kante $\{u,v\}$} \put(3.4,0.4){\small $\leadsto$} \put(5.0,0.2){\circle*{0.14}}\put(4.7,0.0){\small $u$} \put(7.0,0.2){\circle*{0.14}}\put(7.15,0.0){\small $v$} \put(6.0,1.5){\circle*{0.14}}\put(6.1,1.55){\small $v_e$} \put(5.0,0.2){\line(1,0){2}} \qbezier(5.0,0.2)(5.5,0.85)(6.0,1.5) \qbezier(7.0,0.2)(6.5,0.85)(6.0,1.5) \put(4.9,-0.35){\small Dreieck $\{v_e,u,v\}$} \end{picture} \end{center} Warum das stimmt: Ist $C$ ein Vertex Cover, so liegt von jeder Kante $\{u,v\}$ ein Endpunkt in $C$ -- damit ist auch das zugehörige Gadget-Dreieck getroffen. Umgekehrt kann man aus einem $\Delta$-Cover ein Vertex Cover machen. \begin{stolper} \textbf{Ein echter Punktabzug lauert hier.} In der Rückrichtung darf man \emph{nicht} behaupten, jedes Dreieck von $G'$ habe die Gadget-Form $\{v_e, u, v\}$. Denn $G'$ enthält alle Kanten von $G$ weiter -- also \emph{erbt} $G'$ auch jedes Dreieck, das $G$ selbst schon hatte (drei paarweise verbundene Original-Knoten). Diese geerbten Dreiecke muss der Beweis mitbehandeln: Auch sie werden von einem Vertex Cover getroffen, weil ihre Kanten überdeckt sind. Wer diesen Fall vergisst, verliert Punkte. \end{stolper} \subsection*{Was daraus folgt} Von \problem{$\Delta$-Cover} geht im Kurs keine weitere Reduktion aus. % ================================================================== \section{$k$-Color (Färbung)} % ================================================================== Ein Problem, das nicht von der Clique-Familie, sondern direkt von \problem{3-SAT} kommt. \begin{defn}{$k$-Color} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine \emph{$k$-Färbung} gibt jedem Knoten eine von $k$ Farben, sodass keine Kante zwei gleichfarbige Enden verbindet. Frage: Ist $G$ mit $k$ Farben färbbar? \end{defn} Man denkt an eine Landkarte, deren Länder so gefärbt werden, dass keine zwei Nachbarn dieselbe Farbe tragen. Schon $k = 3$ ist NP-vollständig. \begin{bsp}{Eine gültige 3-Färbung} \setlength{\unitlength}{1cm} \begin{center} \begin{picture}(4.5,2.6)(-0.3,-0.3) \put(0,0){\circle*{0.18}}\put(-0.35,-0.05){\small $r$} \put(2,0){\circle*{0.18}}\put(2.1,-0.05){\small $g$} \put(1,1.7){\circle*{0.18}}\put(1.1,1.7){\small $b$} \put(3.4,0.85){\circle*{0.18}}\put(3.5,0.8){\small $r$} \put(0,0){\line(1,0){2}} \qbezier(0,0)(0.5,0.85)(1,1.7) \qbezier(2,0)(1.5,0.85)(1,1.7) \qbezier(2,0)(2.7,0.42)(3.4,0.85) \end{picture} \end{center} Drei Farben $r,g,b$. Das Dreieck braucht alle drei; der rechte Knoten darf wieder $r$ sein, weil er nur mit $g$ benachbart ist. \end{bsp} \subsection*{Warum $k$-Color in NP liegt} \emph{Das Zertifikat.} Die Färbung selbst -- eine Farbe pro Knoten, also eine Zahl aus $\{1,\dots,k\}$ je Knoten. Das ist polynomiell lang. \emph{Die Prüfung.} Der Verifizierer geht jede Kante $\{u,v\} \in E$ durch und prüft, ob ihre beiden Enden verschiedene Farben haben. Er akzeptiert, wenn keine Kante gleichfarbig ist. \emph{Warum das korrekt ist -- beide Richtungen.} Ist $G$ färbbar, wird eine gültige Färbung akzeptiert. Ist $G$ nicht färbbar, hat jede vorgelegte Färbung eine gleichfarbige Kante, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Ein Durchlauf durch alle Kanten, also $O(|E|)$. Damit $\problem{$k$-Color} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Farben als Wahrheitswerte} Man baut pro Variable die Knoten $x_i, \bar x_i, v_i$, einen Knoten $F_j$ pro Klausel und ein Zentrum $z$. Die Knoten $v_1, \dots, v_n, z$ bilden eine Clique und erzwingen genau $n+1$ Farben; man kann $z$ die Farbe \glqq neutral\grqq{} geben und jedem $v_i$ eine eigene. Für jedes Paar $x_i, \bar x_i$ (verbunden) bleibt dann nur die Wahl zwischen \glqq wahr\grqq{} und \glqq falsch\grqq{} -- das kodiert die Belegung. Jeder Klauselknoten $F_j$ ist mit genau den Literalen verbunden, die \emph{nicht} in seiner Klausel stehen; er lässt sich genau dann korrekt färben, wenn ein Literal seiner Klausel wahr ist. Der Graph ist also mit $n+1$ Farben färbbar genau dann, wenn die Formel erfüllbar ist. \end{idee} \subsection*{Was daraus folgt} Von \problem{$k$-Color} geht im Kurs keine weitere Härte-Reduktion aus; es taucht später nur bei den ETH-Schranken wieder auf. % ================================================================== \section{Hamiltonkreis} % ================================================================== \begin{defn}{Hamiltonkreis (HK)} Gegeben ein Graph $G = (V,E)$. Frage: Gibt es einen Rundweg, der \emph{jeden} Knoten \emph{genau einmal} besucht und am Start wieder ankommt? (Die Aussage gilt für gerichtete wie ungerichtete Graphen.) \end{defn} \begin{bsp}{Ein Hamiltonkreis} \setlength{\unitlength}{1cm} \begin{center} \begin{picture}(4,2.8)(-0.4,-0.3) \put(0,0){\circle*{0.15}} \put(3,0){\circle*{0.15}} \put(3,2){\circle*{0.15}} \put(0,2){\circle*{0.15}} \put(1.5,2.6){\circle*{0.15}} \linethickness{1.2pt} \put(0,0){\line(1,0){3}} \put(3,0){\line(0,1){2}} \qbezier(3,2)(2.25,2.3)(1.5,2.6) \qbezier(1.5,2.6)(0.75,2.3)(0,2) \put(0,2){\line(0,-1){2}} \end{picture} \end{center} Der fette Weg besucht alle fünf Knoten genau einmal und schließt sich. \end{bsp} \subsection*{Warum Hamiltonkreis in NP liegt} \emph{Das Zertifikat.} Die Besuchsreihenfolge -- eine Permutation der Knoten, die den behaupteten Rundweg angibt. Sie ist genau $|V|$ Einträge lang, also polynomiell. \emph{Die Prüfung.} Der Verifizierer prüft zweierlei: erstens, dass jeder Knoten in der Reihenfolge genau einmal vorkommt; zweitens, dass zwischen je zwei aufeinanderfolgenden Knoten -- und zwischen dem letzten und dem ersten -- wirklich eine Kante existiert. Er akzeptiert, wenn beides zutrifft. \emph{Warum das korrekt ist -- beide Richtungen.} Gibt es einen Hamiltonkreis, so ist seine Reihenfolge ein akzeptiertes Zertifikat. Wird umgekehrt eine Reihenfolge akzeptiert, so besucht sie jeden Knoten einmal und benutzt nur echte Kanten -- sie ist also ein Hamiltonkreis. \emph{Die Laufzeit.} Die Verschiedenheit prüft man in $O(|V|)$ (etwa durch Abhaken), die Kantenbedingung in $O(|V|)$ Nachschlägen. Insgesamt $O(|V|+|E|)$. Damit $\problem{HK} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{3-SAT}' \redp \problem{HK}$: A- und B-Komponenten} Man baut für die Variante mit genau drei Literalen pro Klausel zwei Sorten von Gadgets. Die \glqq A-Komponenten\grqq{} (Leitergraphen) haben genau zwei mögliche Durchlaufrichtungen und kodieren so die Setzung einer Variablen auf wahr oder falsch. Die \glqq B-Komponenten\grqq{} -- eine pro Klausel -- sind so gebaut, dass sie sich für \emph{jede nichtleere} Auswahl ihrer Kanten durchlaufen lassen, aber \emph{nicht} für die leere. Die leere Auswahl entspricht \glqq alle Literale dieser Klausel falsch\grqq. Ein Hamiltonkreis existiert also genau dann, wenn jede Klausel mindestens ein wahres Literal hat -- wenn die Formel erfüllbar ist. \end{idee} \subsection*{Was daraus folgt} \begin{idee}{$\problem{HK} \redp \problem{TSP}$: Kanten als Distanzen} Man macht aus dem Graphen eine TSP-Instanz: Jede echte Kante bekommt Distanz 1, jede fehlende Kante die große Distanz $|V|+1$, und die Schranke ist $L = |V|$. Eine Rundreise der Länge $\le |V|$ kann nur echte Kanten benutzen -- sie ist also ein Hamiltonkreis. (Ausführlich beim TSP.) \end{idee} \begin{idee}{$\problem{HamiltonianCycle} \redp \problem{HamiltonianPath}$: Knoten aufspalten} Um aus der Kreis- eine Pfad-Frage zu machen, verdoppelt man einen Knoten $v$ zu $v$ und $v^*$ (mit gleicher Nachbarschaft) und hängt zwei neue Grad-1-Knoten $s$ (an $v$) und $t$ (an $v^*$) als Pfadenden an. Ein Hamiltonpfad von $s$ nach $t$ entspricht genau einem Hamiltonkreis durch $v$. (Die Gegenrichtung \problem{Path} $\redp$ \problem{Cycle} schließt den Pfad über einen universellen Knoten zum Kreis.) \end{idee} % ================================================================== \section{TSP (Traveling Salesman)} % ================================================================== \begin{defn}{TSP, Entscheidungsvariante} Gegeben Städte mit paarweisen Distanzen $d(i,j)$ und eine Schranke $L$. Frage: Gibt es eine Rundreise durch alle Städte (jede genau einmal) mit Gesamtlänge $\le L$? \end{defn} Der Unterschied zum Hamiltonkreis: Dort fragt man nur, \emph{ob} es eine Rundreise gibt; hier gibt es Distanzen und eine Längengrenze. Als Optimierungsproblem -- \glqq finde die kürzeste Rundreise\grqq{} -- ist TSP der Star des Approximationskapitels. \begin{bsp}{Eine kurze Rundreise} Vier Städte auf einem Quadrat, jede Seite Distanz 1, die Diagonalen Distanz 2. Die Rundreise entlang der vier Seiten hat Länge 4 und ist optimal; sie unterschreitet jede Schranke $L \ge 4$. \end{bsp} \subsection*{Warum TSP in NP liegt} \emph{Das Zertifikat.} Die Reihenfolge der Städte -- eine Permutation, die die Rundreise angibt. Polynomiell lang. \emph{Die Prüfung.} Der Verifizierer addiert die Distanzen entlang der Rundreise (inklusive der Rückkehr zum Start) und prüft, ob die Summe $\le L$ ist; außerdem prüft er, dass jede Stadt genau einmal vorkommt. Er akzeptiert bei beidem. \emph{Warum das korrekt ist -- beide Richtungen.} Gibt es eine Rundreise der Länge $\le L$, wird ihre Reihenfolge akzeptiert. Gibt es keine, überschreitet jede vorgelegte Reihenfolge die Schranke, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Das Aufsummieren der $n$ Distanzen kostet $O(n)$. Damit liegt die Entscheidungsvariante von TSP in $\NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{HK} \redp \problem{TSP}$: Kanten Distanz 1, Nicht-Kanten teuer} Aus einem Graphen $G$ für den Hamiltonkreis baut man die Städte $=$ Knoten und setzt $d(u,v) = 1$, wenn $\{u,v\}$ eine Kante von $G$ ist, sonst $d(u,v) = |V|+1$. Die Schranke ist $L = |V|$. Eine Rundreise der Länge $\le |V|$ besucht $|V|$ Städte und darf keine teure Nicht-Kante benutzen -- sie besteht also nur aus echten Kanten und ist ein Hamiltonkreis. Umgekehrt hat jeder Hamiltonkreis genau die Länge $|V|$. TSP bleibt sogar dann NP-vollständig, wenn man symmetrische Distanzen mit Dreiecksungleichung verlangt. \end{idee} \subsection*{Was daraus folgt} Von TSP geht keine Härte-Reduktion aus. Stattdessen ist es das zentrale Optimierungsproblem für die Approximation (Teil D): $\Delta$TSP$_1$ und Christofides. % ================================================================== \section{3-dimensionales Matching} % ================================================================== Ab hier verlassen wir die Graphen und arbeiten mit Mengen und Zahlen. Den Anfang macht ein Problem, das direkt von \problem{SAT} kommt. \begin{defn}{3-dimensionales Matching (3-DM)} Gegeben drei gleich große Mengen $U, V, W$ und eine Liste $T$ von \emph{Tripeln}, wobei jedes Tripel je ein Element aus $U$, aus $V$ und aus $W$ enthält. Frage: Gibt es eine Auswahl von Tripeln, die jedes Element aus $U$, $V$ und $W$ \emph{genau einmal} trifft? \end{defn} Man denkt an eine perfekte Zuordnung zu dritt: Jede Person aus $U$ soll mit genau einer Aufgabe aus $V$ und genau einem Termin aus $W$ zusammengebracht werden, und die erlaubten Kombinationen stehen in $T$. \begin{bsp}{Ein 3-dimensionales Matching} $U = \{a_1, a_2\}$, $V = \{b_1, b_2\}$, $W = \{c_1, c_2\}$ und die Tripel $(a_1,b_1,c_1)$, $(a_2,b_2,c_2)$, $(a_1,b_2,c_2)$. Die Auswahl der ersten beiden Tripel trifft jedes der sechs Elemente genau einmal -- ein gültiges Matching. \end{bsp} \subsection*{Warum 3-DM in NP liegt} \emph{Das Zertifikat.} Die ausgewählte Menge $M \subseteq T$ von Tripeln. Höchstens $|U|$ Tripel, also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer prüft, dass $M$ genau $|U|$ Tripel enthält und dass in $M$ keine zwei Tripel in irgendeiner ihrer drei Komponenten übereinstimmen -- dass also jedes Element aus $U$, $V$, $W$ höchstens (und damit genau) einmal vorkommt. Dazu zählt er für jedes Element seine Vorkommen. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Matching, wird es akzeptiert. Existiert keines, kommt bei jeder Auswahl ein Element doppelt oder gar nicht vor, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Das Zählen der Vorkommen über alle Tripel läuft in $O(|T|)$. Damit $\problem{3-DM} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnrad, Klauseln, Garbage Collection} Pro Variable baut man eine \glqq Zahnrad\grqq-Struktur aus Tripeln, die kreisförmig angeordnet sind. Ein perfektes Matching kann dieses Zahnrad nur auf zwei Arten abdecken -- die eine steht für \glqq Variable wahr\grqq, die andere für \glqq falsch\grqq. Pro Klausel gibt es ein Knotenpaar $v_j, w_j$, dessen Tripel nur dann matchbar sind, wenn ein erfüllendes Literal der Klausel \glqq frei\grqq{} geblieben ist. Weil dabei nicht alle Literale verbraucht werden, räumt eine \glqq Garbage Collection\grqq{} aus zusätzlichen Tripeln die übrig gebliebenen Literale weg, damit am Ende doch jedes Element genau einmal getroffen ist. \end{idee} \subsection*{Was daraus folgt} \begin{idee}{$\problem{3-DM} \redp \problem{3-Exact Cover}$: Tripel als 3er-Mengen} Man muss gar nichts umbauen: Fasst man jedes Tripel $(u,v,w)$ als die dreielementige Menge $\{u,v,w\}$ über dem Universum $U \cup V \cup W$ auf, so wird aus \glqq jedes Element genau einmal treffen\grqq{} wörtlich \glqq das Universum exakt überdecken\grqq. Jede 3-DM-Instanz ist also direkt eine 3-EC-Instanz. \end{idee} % ================================================================== \section{3-Exact Cover} % ================================================================== \begin{defn}{3-Exact Cover (3-EC)} Gegeben ein Universum $U$ mit $|U| = 3m$ und eine Familie $S_1, \dots, S_n$ von \emph{dreielementigen} Teilmengen von $U$. Frage: Gibt es eine Auswahl von Mengen, die $U$ \emph{exakt} überdeckt -- disjunkt und lückenlos, sodass jedes Element in genau einer gewählten Menge liegt? \end{defn} \begin{bsp}{Eine exakte Überdeckung} $U = \{1,2,3,4,5,6\}$ und die Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$, $S_3 = \{1,2,4\}$. Die Auswahl $\{S_1, S_2\}$ überdeckt jedes Element genau einmal. Die Auswahl $\{S_1, S_3\}$ dagegen nicht: 1 und 2 lägen doppelt, 5 und 6 gar nicht. \end{bsp} \subsection*{Warum 3-EC in NP liegt} \emph{Das Zertifikat.} Die ausgewählte Teilfamilie von Mengen. Da eine exakte Überdeckung genau $m$ Mengen braucht (jede deckt drei der $3m$ Elemente), ist sie polynomiell lang. \emph{Die Prüfung.} Der Verifizierer markiert für jede gewählte Menge ihre drei Elemente und kontrolliert, dass am Ende jedes Element aus $U$ \emph{genau einmal} markiert wurde -- keines doppelt, keines gar nicht. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine exakte Überdeckung, wird sie akzeptiert. Existiert keine, bleibt bei jeder Auswahl ein Element unbedeckt oder wird doppelt bedeckt, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Das Markieren und Kontrollieren läuft in $O(|U| + \text{Anzahl gewählter Mengen})$, also polynomiell. Damit $\problem{3-EC} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: dieselbe Instanz, anders gelesen} Man muss an der Instanz gar nichts umbauen -- man liest sie nur anders. Ein Tripel $(u,v,w)$ aus der 3-DM-Instanz fasst man als die dreielementige Menge $\{u,v,w\}$ auf, und als Universum nimmt man $U \cup V \cup W$. \end{idee} Warum das genau passt: Die 3-DM-Forderung \glqq jedes Element aus $U$, $V$ und $W$ wird von den gewählten Tripeln genau einmal getroffen\grqq{} ist wörtlich die 3-EC-Forderung \glqq jedes Element des Universums liegt in genau einer gewählten Menge\grqq. Eine Auswahl von Tripeln ist also genau dann ein 3-dimensionales Matching, wenn dieselbe Auswahl, als Mengenfamilie gelesen, eine exakte Überdeckung ist. Die Umformung kostet keine Rechenzeit über das Umschreiben hinaus, ist also polynomiell. Da \problem{3-DM} NP-vollständig und $\problem{3-EC} \in \NP$ ist, ist auch \problem{3-EC} NP-vollständig. \subsection*{Was daraus folgt} \begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Mengen werden Ziffern} Man schreibt jede Menge als Bitvektor über dem Universum und liest ihn als Zahl zur Basis $n+1$. Das Ziel ist die Zahl \glqq überall 1\grqq. Weil bei so großer Basis nie ein Übertrag entsteht, trifft eine Auswahl die Zielsumme genau dann, wenn sie jede Stelle genau einmal überdeckt -- eine exakte Überdeckung. (Ausführlich mit Zahlen beim SubSet Sum.) \end{idee} % ================================================================== \section{SubSet Sum} % ================================================================== \begin{defn}{SubSet Sum} Gegeben ganze Zahlen $c_1, \dots, c_n$ und ein Zielwert $K$. Frage: Gibt es eine Teilmenge dieser Zahlen mit Summe \emph{genau} $K$? \end{defn} \begin{bsp}{SubSet Sum ausprobiert} Zahlen $3, 7, 8, 4$ und Ziel $K = 15$. Es gilt $3 + 4 + 8 = 15$ -- die Teilmenge $\{3,4,8\}$ trifft das Ziel genau. Die Teilmenge $\{7,4\}$ ergäbe nur $11$. \end{bsp} \subsection*{Warum SubSet Sum in NP liegt} \emph{Das Zertifikat.} Die Teilmenge $S \subseteq \{1,\dots,n\}$, ein Bit pro Zahl, also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer addiert die Zahlen $c_j$ für $j \in S$ und vergleicht die Summe mit $K$. Er akzeptiert bei Gleichheit. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine Teilmenge mit Summe $K$, wird sie akzeptiert. Existiert keine, trifft keine Teilmenge den Zielwert, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Es sind höchstens $n$ Additionen, also $O(n)$ Arithmetikschritte. Damit $\problem{SubSet Sum} \in \NP$. (Beachte: \glqq $O(n)$ Additionen\grqq{} zählt Rechenschritte auf großen Zahlen; die Schwere des Problems steckt nicht in der Prüfung, sondern im \emph{Finden} der richtigen Teilmenge unter $2^n$ Möglichkeiten.) \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Ziffern zur Basis $n+1$} Man schreibt jede Menge $S_j$ als Bitvektor über dem Universum (eine 1 an jeder Stelle, die $S_j$ enthält) und liest diesen Bitvektor als Zahl zur \emph{Basis $n+1$}, wobei $n$ die Anzahl der Mengen ist. Das Ziel $K$ ist die Zahl zum Bitvektor \glqq überall 1\grqq. \end{idee} Warum die krumme Basis $n+1$? Damit beim Addieren \emph{kein Übertrag} entsteht. Es gibt nur $n$ Mengen, an jeder Stelle also höchstens $n$ Einsen -- das bleibt unter $n+1$, keine Stelle läuft über. Ohne Übertrag zählt jede Stelle für sich, und \glqq Summe trifft das Ziel\grqq{} bedeutet genau \glqq jede Stelle wird genau einmal überdeckt\grqq. \begin{bsp}{Die Ziffern-Reduktion mit Zahlen} $U = \{1,\dots,6\}$, Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$, $S_3 = \{1,2,4\}$, $S_4 = \{3,5,6\}$; also $n = 4$, Basis 5. \begin{center}\small \begin{tabular}{lll} \toprule Menge & Bitvektor & Zahl zur Basis 5\\ \midrule $S_1=\{1,2,3\}$ & $111000$ & $5^0+5^1+5^2 = 31$\\ $S_2=\{4,5,6\}$ & $000111$ & $5^3+5^4+5^5 = 3875$\\ $S_3=\{1,2,4\}$ & $110100$ & $5^0+5^1+5^3 = 131$\\ $S_4=\{3,5,6\}$ & $001011$ & $5^2+5^4+5^5 = 3775$\\ \midrule Ziel $K$ & $111111$ & $5^0+\dots+5^5 = 3906$\\ \bottomrule \end{tabular} \end{center} Es gilt $S_1 + S_2 = 31 + 3875 = 3906 = K$, und tatsächlich ist $\{S_1,S_2\}$ eine exakte Überdeckung. Ebenso $S_3 + S_4 = 3906$ mit exakter Überdeckung $\{S_3,S_4\}$. \end{bsp} Es gibt noch eine \emph{zweite}, direktere Reduktion auf \problem{SubSet Sum} -- diesmal von \problem{3-SAT} aus. Sie ist für die Praxis unwichtiger, aber für die unteren Schranken in Teil C zentral, weil sie besonders \emph{wenige} Zahlen erzeugt. \begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$: Ziffern zur Basis 10} Man kodiert jede Zahl als Dezimalzahl mit $n + m$ Ziffern -- eine Stelle pro Variable und eine pro Klausel. Der Aufbau hat drei Bausteine: \begin{itemize} \item \emph{Zwei Items pro Variable.} Für jede Variable $x_i$ gibt es zwei Zahlen: eine steht für \glqq $x_i$ wahr\grqq, die andere für \glqq $x_i$ falsch\grqq. Beide haben an der Variablen-Stelle $i$ eine 1 (genau eine der beiden wird gewählt) und an den Klausel-Stellen eine 1, wo das jeweilige Literal vorkommt. \item \emph{Der Zielwert} verlangt an jeder Variablen-Stelle genau eine 1 (also eine gültige Belegung) und an jeder Klausel-Stelle den Wert 3. \item \emph{Dummy-Items pro Klausel.} Da eine erfüllte Klausel ein bis drei wahre Literale haben kann, an der Klausel-Stelle aber genau die 3 stehen muss, füllt man mit zwei Füll-Zahlen (\glqq Dummies\grqq) pro Klausel den Rest auf 3 auf. \end{itemize} \end{idee} Der Trick der großen Ziffernabstände sorgt wieder dafür, dass es keine Überträge gibt, sodass jede Stelle für sich zählt. Entscheidend für Teil C: Diese Reduktion erzeugt nur $|A| = 2n + 2m = O(m)$ Zahlen. Deshalb liefert sie sogar eine $2^{o(n)}$-untere Schranke für \problem{SubSet Sum} und \problem{Partition} -- viel schärfer als die Kette über 3-EC. \subsection*{Was daraus folgt} \begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Zusatzzahlen} Man ergänzt die Zahlen um zwei geschickt gewählte Werte, sodass die \glqq halbe Gesamtsumme\grqq-Frage von \problem{Partition} genau die Zielsummen-Frage von SubSet Sum wird. (Ausführlich bei Partition.) \end{idee} \begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: Spezialfall} Setzt man beim Rucksack für jeden Gegenstand Gewicht gleich Profit ($w_j = p_j = c_j$) und Kapazität gleich Zielprofit ($B = P = K$), so fragt der Rucksack genau, ob eine Teilmenge die Summe $K$ trifft. SubSet Sum ist also ein Spezialfall von Knapsack. \end{idee} \begin{idee}{$\problem{SubSet Sum} \redp \problem{SubSet Sum Cardinality}$: Padding und Shift} Die Variante verlangt zusätzlich, dass die Teilmenge genau $n$ Zahlen enthält. Man erhöht jede Originalzahl um 1 (\glqq Shift\grqq) und fügt $n$ Einsen als \glqq Padding\grqq{} hinzu; das Ziel wird $K + n$. Die Einsen füllen die geforderte Anzahl auf, ohne die eigentliche Summe zu stören. \end{idee} % ================================================================== \section{Partition} % ================================================================== \begin{defn}{Partition} Gegeben ganze Zahlen $c_1, \dots, c_n$. Frage: Gibt es eine Teilmenge, deren Summe \emph{genau die Hälfte} der Gesamtsumme beträgt -- die die Zahlen also in zwei gleich schwere Hälften teilt? \end{defn} \begin{bsp}{Eine Partition} Zahlen $1, 5, 6, 2$ mit Gesamtsumme $14$, Hälfte also $7$. Die Teilmenge $\{1, 6\}$ hat Summe $7$, der Rest $\{5, 2\}$ ebenfalls -- eine gültige Zweiteilung. \end{bsp} \subsection*{Warum Partition in NP liegt} \emph{Das Zertifikat.} Die Teilmenge $S$, ein Bit pro Zahl, polynomiell lang. \emph{Die Prüfung.} Der Verifizierer berechnet die Gesamtsumme $N = \sum_j c_j$ und die Teilsumme $\sum_{j \in S} c_j$ und prüft, ob die Teilsumme gleich $N/2$ ist. Er akzeptiert bei Gleichheit. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine hälftige Teilmenge, wird sie akzeptiert. Existiert keine, trifft keine Teilmenge genau die Hälfte, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Zwei Summen über höchstens $n$ Zahlen, also $O(n)$. Damit $\problem{Partition} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Zusatzzahlen} Aus den Zahlen $c_1, \dots, c_n$ mit Ziel $K$ und $N = (\sum_j c_j) + 1$ bildet man eine neue Zahlenmenge: alle $c_j$ \emph{plus} zwei Zusatzzahlen $c_{n+1} = N - K$ und $c_{n+2} = K + 1$. \end{idee} Warum das stimmt: Die Gesamtsumme der neuen Menge ist $\sum c_j + (N-K) + (K+1) = 2N$, ihre Hälfte also $N$. Die beiden Zusatzzahlen summieren sich zu $(N-K)+(K+1) = N+1$ -- das ist schon \emph{mehr} als eine Hälfte, also können sie nie beide in derselben Hälfte liegen; sie werden immer getrennt. Trifft nun eine Teilmenge der Originalzahlen den Wert $K$, so ergänzt man sie um $c_{n+1} = N-K$ und erhält die Summe $N$ -- eine Halbierung. Umgekehrt enthält jede Halbierung genau eine Zusatzzahl; zieht man sie ab, bleibt eine Original-Teilmenge mit Summe $K$. \begin{bsp}{Die Zusatzzahlen mit Zahlen} Zahlen $3, 5, 8, 4$ (Summe $20$), Ziel $K = 12$. Dann $N = 21$, die Zusatzzahlen sind $N-K = 9$ und $K+1 = 13$. Neue Menge $\{3,5,8,4,9,13\}$, Gesamtsumme $42$, Hälfte $21$. Die Original-Teilmenge $\{8,4\}$ trifft $K = 12$; ergänzt um $9$ ergibt $\{8,4,9\}$ die Summe $21$ -- eine gültige Halbierung. \end{bsp} \subsection*{Was daraus folgt} \begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: Zahlen als Jobs} Man nimmt die Partition-Zahlen als Job-Laufzeiten und stellt zwei Maschinen bereit. Beide Maschinen exakt gleich auszulasten heißt, die Zahlen in zwei gleich schwere Hälften zu teilen. (Ausführlich beim Scheduling.) \end{idee} % ================================================================== \section{Knapsack (Rucksackproblem)} % ================================================================== \begin{defn}{Knapsack (Rucksack)} Gegeben $n$ Gegenstände, jeder mit Gewicht $w_i$ und Profit $p_i$, eine Kapazität $B$ und ein Zielprofit $P$. Frage: Gibt es eine Auswahl von Gegenständen mit Gesamtgewicht $\le B$ und Gesamtprofit $\ge P$? \end{defn} \begin{bsp}{Eine Rucksack-Füllung} Drei Gegenstände $(w,p) = (3,4), (4,5), (5,6)$, Kapazität $B = 7$, Zielprofit $P = 9$. Die ersten beiden zusammen haben Gewicht $3+4 = 7 \le B$ und Profit $4+5 = 9 \ge P$ -- sie erfüllen beide Schranken. \end{bsp} \subsection*{Warum Knapsack in NP liegt} \emph{Das Zertifikat.} Die Auswahl $S \subseteq \{1,\dots,n\}$, ein Bit pro Gegenstand. \emph{Die Prüfung.} Der Verifizierer berechnet $\sum_{i \in S} w_i$ und $\sum_{i \in S} p_i$ und prüft die beiden Schranken $\sum_{i \in S} w_i \le B$ und $\sum_{i \in S} p_i \ge P$. Er akzeptiert, wenn beide erfüllt sind. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine zulässige Auswahl mit genügend Profit, wird sie akzeptiert. Existiert keine, verletzt jede Auswahl eine der beiden Schranken, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Zwei Summen und zwei Vergleiche über $n$ Gegenstände, also $O(n)$. Damit $\problem{Knapsack} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: Gewicht gleich Profit} Aus einer SubSet-Sum-Instanz $(c_1,\dots,c_n, K)$ macht man eine Knapsack-Instanz, indem man für jeden Gegenstand $w_i = p_i = c_i$ setzt und $B = P = K$ wählt. Dann verlangt der Rucksack eine Auswahl mit Gewicht $\le K$ \emph{und} Profit $\ge K$ -- bei $w_i = p_i$ heißt das Summe genau $K$. SubSet Sum ist also der Spezialfall $w_i = p_i$ des Rucksacks. \end{idee} \subsection*{Was daraus folgt} Von \problem{Knapsack} geht keine Härte-Reduktion aus. Als Optimierungsproblem ist es in Teil D wichtig (Greedy, Modified Greedy, Sahni, FPTAS). % ================================================================== \section{$P\|\Cmax$ (Scheduling)} % ================================================================== \begin{defn}{$P\|\Cmax$ (Scheduling auf identischen Maschinen)} Gegeben $n$ Jobs mit Laufzeiten $p_1, \dots, p_n$ und $m$ gleiche Maschinen. Verteile die Jobs so auf die Maschinen, dass die \emph{höchste} Maschinenlast -- der \emph{Makespan} $\Cmax$ -- möglichst klein wird. (Entscheidungsvariante: Gibt es eine Verteilung mit Makespan $\le T$?) \end{defn} \begin{bsp}{Ein Schedule} Drei Jobs der Größen $2, 3, 3$ auf zwei Maschinen. Legt man den 2er und einen 3er auf $M_1$ (Last 5) und den anderen 3er auf $M_2$ (Last 3), so ist der Makespan 5. Besser: die beiden 3er auf getrennte Maschinen und den 2er dazu -- Makespan 5 bleibt, denn eine Maschine trägt mindestens $8/2 = 4$ und der 2er passt nicht ohne einen 3er. Optimal ist hier Makespan 5. \end{bsp} \subsection*{Warum $P\|\Cmax$ in NP liegt} \emph{Das Zertifikat.} Die Zuordnung \glqq welcher Job läuft auf welcher Maschine\grqq{} -- also eine Aufteilung der Jobs in $m$ Gruppen. \emph{Die Prüfung.} Der Verifizierer summiert für jede Maschine die Laufzeiten der ihr zugeordneten Jobs, nimmt das Maximum über alle Maschinen (den Makespan) und prüft, ob es $\le T$ ist. Er akzeptiert bei Erfolg. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert eine Verteilung mit Makespan $\le T$, wird sie akzeptiert. Existiert keine, überschreitet jede Verteilung die Schranke, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Das Aufsummieren geht jeden Job einmal an, also $O(n)$. Damit liegt die Entscheidungsvariante in $\NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: gleich lange Hälften} Man nimmt die Partition-Zahlen $c_1, \dots, c_n$ als Job-Laufzeiten und zwei Maschinen. Beide Maschinen tragen zusammen die Gesamtlast $N = \sum c_j$. Ein Makespan von genau $N/2$ ist nur möglich, wenn beide Maschinen exakt gleich ausgelastet sind -- also wenn sich die Zahlen in zwei gleich schwere Hälften teilen lassen. Damit ist $P\|\Cmax$ schon für $m = 2$ Maschinen NP-vollständig. \end{idee} \subsection*{Was daraus folgt} Von $P\|\Cmax$ geht keine Härte-Reduktion aus. Als Optimierungsproblem ist es in Teil D wichtig (List Scheduling, LPT). % ================================================================== \section{Hitting Set} % ================================================================== \begin{defn}{Hitting Set} Gegeben ein Universum $U$, eine Familie von Mengen $F_1, \dots, F_r \subseteq U$ und eine Zahl $k$. Ein \emph{Hitting Set} ist eine Menge $H \subseteq U$, die \emph{jede} der Mengen trifft ($H \cap F_i \ne \emptyset$ für alle $i$). Frage: Gibt es ein Hitting Set der Größe $\le k$? \end{defn} \begin{bsp}{Ein Hitting Set} $U = \{1,2,3,4\}$, Mengen $F_1 = \{1,2\}$, $F_2 = \{2,3\}$, $F_3 = \{3,4\}$. Das Element $\{2\}$ trifft $F_1$ und $F_2$, aber nicht $F_3$. Die Menge $\{2,3\}$ trifft alle drei -- ein Hitting Set der Größe 2. \end{bsp} \subsection*{Warum Hitting Set in NP liegt} \emph{Das Zertifikat.} Die Menge $H \subseteq U$, ein Bit pro Element, also polynomiell lang. \emph{Die Prüfung.} Der Verifizierer prüft $|H| \le k$ und geht dann jede der Mengen $F_i$ durch, um sicherzustellen, dass $H$ mindestens ein Element von $F_i$ enthält. Er akzeptiert, wenn die Größe stimmt und jede Menge getroffen ist. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Hitting Set der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge dieser Größe ein $F_i$ ungetroffen, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Für jede der $r$ Mengen ein Test gegen $H$, insgesamt $O(r \cdot |U|)$, also polynomiell. Damit $\problem{Hitting Set} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$} Das Universum sind alle Literale $x_1, \bar x_1, \dots, x_n, \bar x_n$. Für jede Variable $i$ bildet man die Menge $F_i = \{x_i, \bar x_i\}$ -- sie zwingt das Hitting Set, aus jedem solchen Paar (mindestens) ein Literal zu wählen, was einer Belegung entspricht. Für jede Klausel $j$ bildet man die Menge $F_{n+j}$ ihrer Literale -- sie verlangt, dass ein erfüllendes Literal getroffen wird. Mit Schranke $k = n$ existiert ein Hitting Set genau dann, wenn die Formel erfüllbar ist. \end{idee} \subsection*{Was daraus folgt} \begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: Rollen tauschen} Hitting Set und Set Cover sind dual zueinander: Vertauscht man die Rollen von \glqq Elementen\grqq{} und \glqq Mengen\grqq, wird aus dem einen das andere. Aus einem Hitting Set (wähle Elemente, die alle Mengen treffen) wird ein Set Cover (wähle Mengen, die alle Elemente überdecken). (Ausführlich beim Set Cover.) \end{idee} % ================================================================== \section{Set Cover} % ================================================================== \begin{defn}{Set Cover} Gegeben ein Universum $U$, eine Familie von Mengen $S_1, \dots, S_r \subseteq U$ und eine Zahl $k$. Frage: Gibt es eine Auswahl von höchstens $k$ Mengen, deren Vereinigung ganz $U$ ist (die also jedes Element überdeckt)? \end{defn} \begin{bsp}{Ein Set Cover} $U = \{1,2,3,4\}$, Mengen $S_1 = \{1,2\}$, $S_2 = \{2,3\}$, $S_3 = \{3,4\}$. Die Auswahl $\{S_1, S_3\}$ überdeckt $1,2$ und $3,4$ -- also ganz $U$, ein Set Cover der Größe 2. \end{bsp} \subsection*{Warum Set Cover in NP liegt} \emph{Das Zertifikat.} Die Auswahl der Mengen (welche der $S_i$ genommen werden). \emph{Die Prüfung.} Der Verifizierer prüft, dass höchstens $k$ Mengen gewählt sind, und markiert alle Elemente der gewählten Mengen; er kontrolliert, dass am Ende jedes Element aus $U$ markiert ist. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Set Cover der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Auswahl dieser Größe ein Element unüberdeckt, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Das Markieren läuft über alle Elemente der gewählten Mengen, also $O(r \cdot |U|)$, polynomiell. Damit $\problem{Set Cover} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: die duale Sicht} Man baut den bipartiten Inzidenzgraphen zwischen Elementen und Mengen und vertauscht die beiden Seiten: Aus einem Element wird eine Menge, aus einer Menge ein Element. Konkret wird aus \glqq Element $u$ liegt in Menge $F_i$\grqq{} die Beziehung \glqq neue Menge $u$ enthält neues Element $i$\grqq. Ein Hitting Set der Größe $k$ auf der einen Seite entspricht dann genau einem Set Cover der Größe $k$ auf der anderen. Die Reduktion ist \emph{involutorisch}: zweimal angewandt landet man wieder bei der Ausgangsinstanz. \end{idee} \subsection*{Was daraus folgt} \begin{idee}{$\problem{Set Cover} \redp \problem{Hitting Set}$: die Rollen zurücktauschen} Man macht denselben Tausch noch einmal, jetzt in die andere Richtung. Aus einer Set-Cover-Instanz mit Universum $U$ und Mengen $S_1, \dots, S_r$ baut man eine Hitting-Set-Instanz, deren Universum die \emph{Mengen-Indizes} $\{1, \dots, r\}$ sind. Für jedes Element $u \in U$ bildet man dort die Menge aller Indizes $i$, für die $u \in S_i$ gilt. \end{idee} Warum das passt: Eine Auswahl von Set-Cover-Mengen überdeckt genau dann jedes Element $u$, wenn sie für jedes $u$ mindestens eine der Mengen enthält, die $u$ abdecken -- also mindestens einen Index der neuen Menge zu $u$ trifft. Das ist wörtlich die Hitting-Set-Bedingung, und die Schranke $k$ bleibt gleich. Weil diese Reduktion \emph{involutorisch} ist -- zweimal angewandt landet man bei der Ausgangsinstanz --, sind Set Cover und Hitting Set exakt gleich schwer. Im Kurs dient das vor allem den ETH-Schranken für beide Probleme. % ================================================================== \section{Dominating Set} % ================================================================== \begin{defn}{Dominating Set} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Dominating Set} ist eine Knotenmenge $D \subseteq V$, sodass jeder Knoten entweder selbst in $D$ liegt oder einen Nachbarn in $D$ hat. Frage: Gibt es ein Dominating Set der Größe $\le k$? \end{defn} \begin{bsp}{Ein Dominating Set} In einem Stern mit einem Mittelknoten und vier Blättern genügt der Mittelknoten: $\{m\}$ ist ein Dominating Set, denn jedes Blatt hat $m$ als Nachbarn. \end{bsp} \subsection*{Warum Dominating Set in NP liegt} \emph{Das Zertifikat.} Die Knotenmenge $D \subseteq V$, ein Bit pro Knoten, Länge $O(|V|)$. \emph{Die Prüfung.} Der Verifizierer prüft zuerst $|D| \le k$. Dann geht er jeden Knoten $v \in V$ durch und prüft die \emph{Dominanzbedingung}: ob $v \in D$ liegt oder ob $v$ einen Nachbarn in $D$ hat -- dazu läuft er die Zeile von $v$ in der Adjazenzmatrix durch. Er akzeptiert, wenn die Größe stimmt und jeder Knoten dominiert wird. \emph{Warum das korrekt ist -- beide Richtungen.} Existiert ein Dominating Set der Größe $\le k$, wird es akzeptiert. Existiert keines, bleibt bei jeder Menge dieser Größe ein Knoten undominiert, und der Verifizierer lehnt ab. \emph{Die Laufzeit.} Die Größenprüfung kostet $O(|V|)$; die Dominanzprüfung geht für jeden der $|V|$ Knoten eine Matrixzeile durch, also $O(|V|^2)$. Insgesamt $O(|V|^2)$. Damit $\problem{Dominating Set} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{zushang} Im Material dieses Kurses wird für \problem{Dominating Set} nur die \emph{NP-Zugehörigkeit} behandelt -- es war eine Klausuraufgabe genau zu diesem Nachweis. Eine \emph{Härte-Reduktion} wird in den Vorlesungs- und Übungsquellen nicht geführt. \problem{Dominating Set} ist zwar bekanntlich NP-vollständig (Standardreduktion aus Vertex Cover), aber diese Reduktion gehört nicht zum gesicherten Kursstoff -- deshalb wird sie hier nicht als solche dargestellt. \end{zushang} % ================================================================== \section{Longest Path} % ================================================================== \begin{defn}{Longest Path} Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Frage: Gibt es einen \emph{einfachen} Pfad (kein Knoten doppelt) der Länge $\ge k$? \end{defn} \begin{bsp}{Ein langer Pfad} In einem Weg-Graphen $1 - 2 - 3 - 4 - 5$ ist die ganze Kette ein einfacher Pfad der Länge 4 (vier Kanten). Für $k = 4$ ist die Antwort also Ja. \end{bsp} \subsection*{Warum Longest Path in NP liegt} \emph{Das Zertifikat.} Eine Folge von $k+1$ paarweise verschiedenen Knoten $(v_0, v_1, \dots, v_k)$ -- der behauptete Pfad. Jeder Knoten braucht $O(\log|V|)$ Bits, die Folge also $O(k \log|V|)$ Bits, polynomiell. \emph{Die Prüfung.} Der Verifizierer prüft erstens, dass alle $v_i$ paarweise verschieden sind, und zweitens, dass zwischen je zwei aufeinanderfolgenden Knoten eine Kante liegt. Er akzeptiert bei beidem. \emph{Warum das korrekt ist -- beide Richtungen.} Hat $G$ einen einfachen Pfad der Länge $\ge k$, so bilden seine ersten $k+1$ Knoten ein akzeptiertes Zertifikat. Wird umgekehrt ein Zertifikat akzeptiert, so ist es eine Folge verschiedener Knoten mit lauter echten Kanten -- ein einfacher Pfad der Länge $k$. \emph{Die Laufzeit.} Die Verschiedenheit kostet $O(k^2)$ Vergleiche, die Kantenbedingung $O(k)$ Nachschläge; insgesamt $O(k^2) \subseteq O(|V|^2)$. Damit $\problem{Longest Path} \in \NP$. \subsection*{Woher die Schwere kommt} \begin{zushang} Wie bei \problem{Dominating Set} behandelt der Kurs für \problem{Longest Path} nur die \emph{NP-Zugehörigkeit} (Klausuraufgabe). Eine Härte-Reduktion steht nicht im Kursmaterial -- obwohl \problem{Longest Path} bekanntlich NP-vollständig ist (es verallgemeinert den Hamiltonpfad). Wir halten uns hier an das, was der Kurs gesichert liefert. \end{zushang} % ================================================================== \section{Das Halteproblem -- schwer, aber nicht in NP} % ================================================================== Zum Abschluss des Katalogs ein Problem, das die Grenzen aufzeigt: Es ist NP-schwer, liegt aber \emph{nicht} in $\NP$ -- weil es überhaupt nicht lösbar ist. \begin{defn}{Halteproblem} Gegeben die Beschreibung eines Programms $M$ und einer Eingabe $w$. Frage: Hält $M$ auf $w$ irgendwann an, oder läuft es für immer? \end{defn} Das Halteproblem ist \emph{unentscheidbar} -- kein Algorithmus löst es, mit keiner noch so großen Laufzeit. Das ist ein tiefes, bewiesenes Resultat (Turing). Deshalb kann es auch keinen Verifizierer geben, und das Halteproblem liegt \emph{nicht} in $\NP$. \subsection*{Woher die Schwere kommt} \begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$} Zu einer Formel $\varphi$ baut man ein Programm $M_\varphi$, das die Eingabe ignoriert, \emph{alle} Belegungen der Reihe nach durchprobiert und genau dann anhält, wenn es eine erfüllende findet -- sonst läuft es ewig weiter. Dann gilt: $M_\varphi$ hält genau dann, wenn $\varphi$ erfüllbar ist. Also $\varphi \in \problem{SAT} \iff \langle M_\varphi, \varepsilon\rangle \in \problem{Halteproblem}$. \end{idee} \begin{aha} Der Clou liegt im Zeitverhalten. $M_\varphi$ läuft im Nein-Fall \emph{ewig} -- aber die \emph{Konstruktion} von $M_\varphi$ aus $\varphi$ ist billig (polynomiell), und nur das zählt bei einer Reduktion. Also ist das Halteproblem mindestens so schwer wie \problem{SAT}, liegt aber nicht in $\NP$. Das zeigt: \textbf{NP-schwer ist nicht dasselbe wie NP-vollständig.} NP-vollständig verlangt zusätzlich die Zugehörigkeit zu $\NP$ -- die dem Halteproblem fehlt. \end{aha} % ################################################################## \part*{Teil C -- Untere Schranken: die ETH} \addcontentsline{toc}{section}{\textbf{Teil C -- Untere Schranken: die ETH}} % ################################################################## \noindent NP-Vollständigkeit sagt nur \glqq vermutlich nicht polynomiell\grqq. Sie sagt nicht, \emph{wie} exponentiell ein Problem ist. Die Exponentialzeit-Hypothese (ETH) ist eine schärfere Annahme, aus der man konkrete \emph{untere} Laufzeitschranken herleitet. In diesem Teil steht bei jedem Schritt die \emph{Idee}. % ================================================================== \section{Die Bausteine der ETH} % ================================================================== \subsection*{Die o-Notation} \begin{defn}{Klein-o} $f(x) = o(g(x))$ bedeutet: $f$ wächst \emph{echt langsamer} als $g$, formal $f(x)/g(x) \to 0$. Für jedes feste $\delta > 0$ gilt $\delta n \ne o(n)$ -- $\delta n$ wächst nicht langsamer als $n$, nur mit anderem Vorfaktor. \end{defn} Deshalb sind \glqq kein $2^{\delta n}$ für ein festes $\delta$\grqq{} und \glqq kein $2^{o(n)}$\grqq{} austauschbare Schreibweisen. Ein \glqq $2^{o(n)}$-Algorithmus\grqq{} hätte einen Exponenten, der langsamer als linear wächst -- er liefe \emph{subexponentiell}, etwa mit $2^{\sqrt n}$. \subsection*{Die Hypothese} \begin{defn}{Exponentialzeit-Hypothese (ETH)} Es gibt eine Konstante $\delta > 0$, sodass \problem{3-SAT} mit $n$ Variablen \emph{nicht} in Zeit $2^{\delta n}\cdot(n+m)^{O(1)}$ lösbar ist. Kurz: Es gibt keinen $2^{o(n)}$-Algorithmus für \problem{3-SAT}. \end{defn} Das ist eine \emph{Annahme}, stärker als $\Pclass \ne \NP$, aber breit geglaubt: Alle bekannten 3-SAT-Algorithmen brauchen $c^n$ (das kleinste bekannte $c$ liegt knapp über $1{,}3$). \subsection*{Das Sparsification-Lemma -- und warum $n$ gegen $m$} \begin{satz}{Sparsification-Lemma} Unter der ETH gibt es auch keinen $2^{o(m)}$-Algorithmus für \problem{3-SAT}, wobei $m$ die \emph{Klauselzahl} ist. \end{satz} \begin{intuition} Warum braucht man dieses Lemma überhaupt? Die ETH ist über die \emph{Variablen}zahl $n$ formuliert. Viele Reduktionen erzeugen ihre Zielgröße aber (auch) aus der \emph{Klausel}zahl $m$. Und $m$ kann viel größer als $n$ sein. Deshalb folgt \glqq kein $2^{o(m)}$\grqq{} \emph{nicht} automatisch aus \glqq kein $2^{o(n)}$\grqq{}. Das Sparsification-Lemma überträgt die Härte von $n$ auf $m$. Die Brücke zwischen beiden ist $n \le 3m$ (jede Variable kommt in einer Klausel vor, jede Klausel hat $\le 3$ Literale). \end{intuition} \subsection*{Das Beweisschema: Kontraposition} \begin{idee}{So beweist man eine untere Schranke} Man nimmt an, das Zielproblem hätte einen zu schnellen Algorithmus, und leitet daraus einen zu schnellen Algorithmus für \problem{3-SAT} ab -- ein Widerspruch. Der Textbaustein, in \emph{jedem} Teilpunkt zu wiederholen: \begin{quote}\itshape\small Angenommen, es gäbe einen Algorithmus, der [Zielproblem] in $2^{o(p)}\cdot|I|^{O(1)}$ löst. Weil der Parameter $p$ mit der Reduktionsgröße $O(f(m))$ zusammenhängt, ergäbe die Kombination aus Reduktion und Algorithmus einen $3$-SAT-Algorithmus in $2^{o(m)}\cdot|I|^{O(1)}$. Nach dem Sparsification-Lemma geht das nur, wenn die ETH nicht gilt -- Widerspruch. \end{quote} \end{idee} \begin{stolper} Entscheidend ist die Frage: \emph{Hängt der Parameter an $n$ oder an $m$?} Hängt er nur an der Variablenzahl $n$, argumentiert man \emph{direkt} mit der ETH und braucht das Lemma nicht. Hängt er (auch) an der Klauselzahl $m$, \emph{muss} man das Sparsification-Lemma zitieren. Es immer oder nie zu nennen, kostet Punkte. \end{stolper} \subsection*{Die Wurzel-Regel} Wächst der Zielparameter \emph{polynomiell} in $m$, etwa $p = O(m^c)$, so wird die Schranke zu $2^{o(\sqrt[c]{p})}$. Denn aus $q = o(\sqrt[c]{p})$ und $p = O(m^c)$ folgt $q = o(m)$. Beispiel: Erzeugt eine Reduktion $O(m^2)$ Kanten, so lautet die Schranke \glqq kein $2^{o(\sqrt{|E|})}$\grqq. % ================================================================== \section{Untere Schranken für die einzelnen Probleme} % ================================================================== Wendet man das Schema auf die Reduktionen des Katalogs an, bekommt man für jedes Problem eine untere Schranke -- mit dem Parameter, an dem sie hängt. Wir gehen die Probleme einzeln durch. \subsection*{Clique} Die Reduktion $\problem{3-SAT} \redp \problem{$k$-Clique}$ erzeugt einen Graphen mit $|V| = O(m)$ Knoten (ein Knoten pro Literalvorkommen), $|E| = O(m^2)$ Kanten und Cliquengröße $k = m$. Setzt man einen $2^{o(|V|)}$-Algorithmus für \problem{Clique} an, so wäre er wegen $|V| = O(m)$ ein $2^{o(m)}$-Algorithmus für \problem{3-SAT} -- ausgeschlossen nach dem Sparsification-Lemma. Also gibt es keinen $2^{o(|V|)}$-Algorithmus. Für die Kanten liefert die Wurzel-Regel wegen $|E| = O(m^2)$ die Schranke \glqq kein $2^{o(\sqrt{|E|})}$\grqq. Und wegen $k = m$ gibt es keinen $2^{o(k)}$-Algorithmus. \subsection*{Independent Set} Die Reduktion $\problem{Clique} \redp \problem{Independent Set}$ bildet nur den Komplementgraphen und lässt $k$ unverändert. Der Komplementgraph hat \emph{dieselbe} Knotenzahl $|V|$ und dieselbe Cliquengröße $k$; die Kantenzahl bleibt in der Größenordnung $O(|V|^2)$. Weil sich keiner der drei Parameter vergrößert, überträgt sich jede Schranke von \problem{Clique} wörtlich: kein $2^{o(|V|)}$, kein $2^{o(\sqrt{|E|})}$, kein $2^{o(k)}$ für \problem{Independent Set}. \subsection*{Vertex Cover} Auch \problem{Vertex Cover} bekommt man über den Komplementgraphen -- hier mit Schranke $k' = n - k$. Die Knoten- und Kantenzahl bleiben wie beim Independent Set unverändert, und $k' = n - k \le n = O(|V|)$. Deshalb gelten für \problem{Vertex Cover} dieselben unteren Schranken: kein $2^{o(|V|)}$, kein $2^{o(\sqrt{|E|})}$, kein $2^{o(k')}$. \subsection*{Hitting Set -- der Fall, an dem man beide Situationen sieht} Die Reduktion $\problem{3-SAT} \redp \problem{Hitting Set}$ liefert die Parameter $|U| = 2n$ (das Universum sind die Literale), $r = n + m$ (die Zahl der Mengen) und $k = n$. An diesen drei Parametern sieht man nebeneinander, wann man das Sparsification-Lemma braucht und wann nicht. \emph{Die Schranke in $|U| = 2n$.} Nimmt man einen $2^{o(|U|)}$-Algorithmus für \problem{Hitting Set} an, so ist er wegen $|U| = 2n$ ein $2^{o(n)}$-Algorithmus. Über die Reduktion ergäbe das einen $2^{o(n)}$-Algorithmus für \problem{3-SAT} -- das widerspricht \emph{direkt} der ETH. Hier braucht man das Sparsification-Lemma nicht, weil $|U|$ nur an der Variablenzahl $n$ hängt. \emph{Die Schranke in $r = n + m$.} Nimmt man einen $2^{o(r)}$-Algorithmus an, so ist er wegen $r = n + m$ und $n \le 3m$, also $r = O(m)$, ein $2^{o(m)}$-Algorithmus für \problem{3-SAT}. Dass es keinen solchen gibt, sagt \emph{nicht} die ETH selbst, sondern erst das Sparsification-Lemma -- weil der Parameter an der Klauselzahl $m$ hängt. Diesen Zusatzschritt muss man hier also zitieren. \emph{Die Schranke in $k = n$.} Nimmt man einen $2^{o(k)}$-Algorithmus an, so ist er wegen $k = n$ ein $2^{o(n)}$-Algorithmus und ergäbe wie im ersten Fall einen $2^{o(n)}$-Algorithmus für \problem{3-SAT} -- direkter Widerspruch zur ETH, ohne Sparsification-Lemma. \subsection*{SubSet Sum und Partition} Die gewöhnliche Kette bis \problem{SubSet Sum} erzeugt sehr viele Zahlen und gibt nur eine schwache Wurzel-Schranke. Die \emph{strenge} Reduktion $\problem{3-SAT} \redp \problem{SubSet Sum}$ (Ziffern zur Basis 10, siehe beim SubSet Sum) erzeugt dagegen nur $|A| = 2n + 2m \le 8m = O(m)$ Zahlen. Ein $2^{o(n)}$-Algorithmus für \problem{SubSet Sum} -- wobei $n$ hier die \emph{Anzahl der Zahlen} ist -- ergäbe über diese wenigen Zahlen einen $2^{o(m)}$-Algorithmus für \problem{3-SAT}, ausgeschlossen nach dem Sparsification-Lemma. Es gibt also keinen $2^{o(n)}$-Algorithmus für \problem{SubSet Sum}. Über die Reduktion $\problem{SubSet Sum} \redp \problem{Partition}$, die nur zwei Zahlen hinzufügt, überträgt sich dieselbe Schranke auf \problem{Partition}. \subsection*{3-Color} Für \problem{3-Color} benutzt man die eigene $O(n+m)$-Gadget-Konstruktion aus dem Katalog: Sie baut aus einer 3-SAT-Formel einen Graphen mit $|V| = O(n+m) = O(m)$ Knoten. Ein $2^{o(|V|)}$-Algorithmus für \problem{3-Color} wäre damit ein $2^{o(m)}$-Algorithmus für \problem{3-SAT} -- nach dem Sparsification-Lemma ausgeschlossen. Also gibt es keinen $2^{o(|V|)}$-Algorithmus für \problem{3-Color}. \subsection*{Set Cover} Für \problem{Set Cover} nutzt man die Dualität zu \problem{Hitting Set}: Der Rollentausch vertauscht Universum und Mengenzahl, macht also aus $|U|$ die Mengenzahl und aus der Mengenzahl das neue $|U|$. Damit übertragen sich die Hitting-Set-Schranken direkt: kein $2^{o(|U|)}$ und kein $2^{o(r)}$ für \problem{Set Cover}, wieder mit dem Sparsification-Lemma bei der $m$-abhängigen Mengenzahl. % ################################################################## \part*{Teil D -- Approximation} \addcontentsline{toc}{section}{\textbf{Teil D -- Approximation}} % ################################################################## \noindent Wenn ein Optimierungsproblem (vermutlich) keine schnelle exakte Lösung hat, berechnet man in Polynomialzeit eine \emph{beweisbar gute} Näherung. Bei jedem Algorithmus steht hier die Güte (exakt) und die \emph{Idee} des Güte-Beweises -- die zentrale Ungleichung. % ================================================================== \section{Der Gütebegriff} % ================================================================== \begin{defn}{Multiplikative Güte} Sei $\OPT(I)$ der optimale Wert einer Instanz $I$. Ein Algorithmus $A$ hat \emph{Güte $\alpha$}, wenn für \emph{alle} Instanzen gilt: bei Minimierung $A(I) \le \alpha\cdot\OPT(I)$; bei Maximierung $\OPT(I) \le \alpha\cdot A(I)$. Die Güte heißt \emph{scharf}, wenn Instanzen den Faktor beliebig genau erreichen. \end{defn} \begin{intuition} Güte $\alpha$ ist eine Garantie für den schlimmsten Fall. Güte 2 bei einem Minimierungsproblem heißt: Egal welche Eingabe, die Lösung ist nie mehr als doppelt so teuer wie die beste mögliche. Kleineres $\alpha$ ist besser; $\alpha = 1$ wäre exakt optimal. \end{intuition} Manche Probleme erlauben sogar eine \emph{einstellbare} Genauigkeit -- eine ganze Familie $(A_\varepsilon)$ mit Güte $1+\varepsilon$ für jedes $\varepsilon$. Je nach Laufzeit trägt so eine Familie einen eigenen Namen; wir betrachten die drei Stufen einzeln. \begin{defn}{PTAS} Eine Familie $(A_\varepsilon)$ mit Güte $1+\varepsilon$ heißt \emph{PTAS} (polynomielles Approximationsschema), wenn die Laufzeit für \emph{jedes feste} $\varepsilon$ polynomiell in $n$ ist. \end{defn} Der Haken: $\varepsilon$ darf im Exponenten von $n$ stecken, etwa $n^{1/\varepsilon}$. Für kleines $\varepsilon$ wird das schnell unpraktisch. \begin{defn}{EPTAS} Ein \emph{EPTAS} ist ein PTAS, dessen Laufzeit die Form $f(1/\varepsilon)\cdot \poly(n)$ hat -- $\varepsilon$ steht nicht mehr im Exponenten von $n$. \end{defn} \begin{defn}{FPTAS} Ein \emph{FPTAS} ist ein PTAS, dessen Laufzeit polynomiell in $n$ \emph{und} in $1/\varepsilon$ ist, etwa $O(n^3/\varepsilon)$. Das ist die stärkste Form. \end{defn} Ein verwandter Begriff: \emph{pseudopolynomiell} heißt eine Laufzeit, die polynomiell in den \emph{Zahlenwerten} der Eingabe ist (etwa in der Kapazität). Wegen der binären Kodierung (Kapitel 2) ist das \emph{nicht} dasselbe wie polynomiell in der Eingabelänge. % ================================================================== \section{TSP ist im Allgemeinen nicht approximierbar} % ================================================================== \begin{satz}{Kein Näherungsalgorithmus für allgemeines TSP} Für beliebige Distanzen gibt es \emph{keinen} Näherungsalgorithmus mit beschränkter Güte -- außer $\Pclass = \NP$.\\[0.3em] \emph{Die Idee:} Man reduziert \problem{Hamiltonkreis}. Echte Kanten bekommen Distanz 1, fehlende Kanten eine \emph{riesige} Distanz. Gäbe es einen Algorithmus mit fester Güte $\alpha$, müsste er die billige Hamilton-Tour (Länge $|V|$) von jeder teuren unterscheiden -- und könnte damit \problem{HK} exakt entscheiden. \end{satz} Der Ausweg ist eine realistische Zusatzannahme: das \emph{metrische} TSP mit symmetrischen Distanzen und der Dreiecksungleichung $d(i,j) \le d(i,k) + d(k,j)$. Dort funktionieren die folgenden zwei Algorithmen. % ================================================================== \section{$\Delta$TSP$_1$: der Algorithmus als Bilderfolge} % ================================================================== \begin{idee}{Der Dreisprung} Man baut zuerst ein billiges Gerüst, das alle Städte verbindet (einen minimalen Spannbaum), macht daraus einen Rundweg über alle Kanten (einen Eulerkreis, indem man alle Grade gerade macht) und kürzt diesen zur Tour ab. \end{idee} \noindent Wir gehen es an einem festen Beispiel durch: Städte $A,B,C,D,E$ mit $d(A,E)=1$, $d(B,C)=1$, $d(A,C)=2$, $d(C,D)=2$ (übrige Distanzen 2 oder 3). Das Layout bleibt in allen Bildern gleich. \medskip \noindent\textbf{Bild 1 -- die optimale Tour (zum Vergleich).} So sieht die beste Rundreise aus; sie hat Länge 8. Der Algorithmus kennt sie nicht, wir zeigen sie nur zum Vergleich. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \qbezier(2.6,1.3)(1.55,0.8)(0.5,0.3) \qbezier(0.5,0.3)(2.55,0.5)(4.6,1.3) \qbezier(4.6,1.3)(3.6,2.15)(2.6,3.0) \qbezier(2.6,3.0)(1.55,2.6)(0.5,2.2) \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3) \put(-0.2,-0.2){\small optimale Tour $[C,B,D,E,A,C]$, Länge $8$} \end{picture} \end{center} \noindent\textbf{Bild 2 -- Schritt 1: minimaler Spannbaum.} Der Algorithmus verbindet alle Städte so billig wie möglich zu einem Baum: Kanten $A$--$E\,(1)$, $B$--$C\,(1)$, $A$--$C\,(2)$, $C$--$D\,(2)$ mit Gewicht 6. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.3pt} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.3,2.75){\small $1$} \qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.3,0.55){\small $1$} \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.35,1.95){\small $2$} \put(2.6,1.3){\line(1,0){2.0}}\put(3.5,1.4){\small $2$} \put(0.0,-0.2){\small Spannbaum $T$, Gewicht $w(T)=6$} \end{picture} \end{center} \begin{intuition} Warum ein Spannbaum? Weil er \emph{garantiert billiger} ist als die optimale Tour: Nimm die optimale Tour und lösche eine Kante -- übrig bleibt ein Weg durch alle Städte, also ein Spannbaum. Der \emph{minimale} Spannbaum ist höchstens so teuer. Also $w(T) \le \OPT$. Das ist die erste der drei Ungleichungen des Güte-Beweises. \end{intuition} \noindent\textbf{Bild 3 -- Schritt 2 und 3: verdoppeln, dann Eulerkreis.} Jede Baumkante wird verdoppelt (im Bild \glqq $\times 2$\grqq). Dadurch hat jeder Knoten geraden Grad -- die Bedingung für einen Eulerkreis, der jede Kante genau einmal nutzt. Sein Gewicht ist $2 \cdot 6 = 12$. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.3pt} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.25,2.75){\small $\times 2$} \qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.25,0.5){\small $\times 2$} \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.3,1.9){\small $\times 2$} \put(2.6,1.3){\line(1,0){2.0}}\put(3.4,1.4){\small $\times 2$} \put(-0.2,-0.2){\small Multigraph, Gewicht $12$, alle Grade gerade} \end{picture} \end{center} Ein Eulerkreis ist z.\,B. $[C,A,E,A,C,B,C,D,C]$ mit Länge 12; manche Städte werden dabei mehrfach besucht. \noindent\textbf{Bild 4 -- Schritt 4: abkürzen zur Tour.} Eine echte Rundreise darf jede Stadt nur einmal besuchen. Man läuft den Eulerkreis ab und \emph{überspringt} bereits besuchte Städte. Aus $[C,A,E,A,C,B,C,D,C]$ wird die Tour $[C,A,E,B,D,C]$. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.1pt} \qbezier(2.6,1.3)(1.55,1.75)(0.5,2.2) \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0) \qbezier(2.6,3.0)(1.55,1.65)(0.5,0.3) \qbezier(0.5,0.3)(2.55,0.5)(4.6,1.3) \put(2.6,1.3){\line(1,0){2.0}} \put(-0.2,-0.2){\small Tour $[C,A,E,B,D,C]$, Länge $10 \le 2\cdot\OPT$} \end{picture} \end{center} \begin{idee}{Die Güte 2 -- drei Ungleichungen} $\Delta$TSP$_1$ hat Güte 2, und der Beweis besteht aus drei Schritten: (1) $w(T) \le \OPT$ (Spannbaum billiger als Tour, s.o.); (2) der Eulerkreis auf den verdoppelten Kanten hat Länge $2\,w(T) \le 2\,\OPT$; (3) das Abkürzen verlängert wegen der Dreiecksungleichung nicht, also $d(R) \le 2\,w(T) \le 2\,\OPT$. Im Beispiel: Länge 10, garantiert $\le 16$, tatsächlich nahe am Optimum 8. \end{idee} \begin{intuition} \textbf{Der schlimmste Fall} wird von einer Stern-Konstruktion erreicht: $n$ Städte, deren optimale Tour Länge $n$ hat, während $\Delta$TSP$_1$ auf Länge $2n-2$ kommt. Das Verhältnis geht gegen 2 -- die Schranke ist also (fast) scharf. Nötig sind Symmetrie und Dreiecksungleichung. \end{intuition} % ================================================================== \section{Christofides: schlauer verdoppeln} % ================================================================== $\Delta$TSP$_1$ verdoppelt \emph{alle} Kanten -- das kostet zusätzlich etwa $w(T) \approx \OPT$, daher die Güte 2. Christofides repariert nur die \emph{ungeraden} Knoten und kommt so auf Güte $1{,}5$. \begin{idee}{Nur die schiefen Knoten reparieren} Ein Eulerkreis braucht nur, dass jeder Knoten geraden Grad hat. Im Spannbaum haben ohnehin nur manche Knoten ungeraden Grad. Statt alles zu verdoppeln, verbindet Christofides genau diese ungeraden Knoten durch ein \emph{minimales perfektes Matching} -- die billigste Art, sie paarweise zu verkuppeln. \end{idee} \noindent\textbf{Bild 1 -- der minimale Spannbaum.} Christofides startet mit demselben Spannbaum wie $\Delta$TSP$_1$: Kanten $A$--$E\,(1)$, $B$--$C\,(1)$, $A$--$C\,(2)$, $C$--$D\,(2)$, Gewicht 6. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.45){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.3pt} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0) \qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3) \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3) \put(2.6,1.3){\line(1,0){2.0}} \put(0.0,-0.2){\small Spannbaum $T$, Gewicht 6} \end{picture} \end{center} \noindent\textbf{Bild 2 -- die ungeraden Knoten.} Man zählt die Grade im Baum: $A$ hat Grad 2 (gerade), alle anderen ungerade. Die ungeraden Knoten $X = \{B,C,D,E\}$ sind mit einem Ring markiert. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$}\put(0.5,0.3){\circle{0.34}} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$}\put(2.6,1.3){\circle{0.34}} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$}\put(4.6,1.3){\circle{0.34}} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$}\put(2.6,3.0){\circle{0.34}} \linethickness{1.3pt} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0) \qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3) \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3) \put(2.6,1.3){\line(1,0){2.0}} \put(-0.3,-0.2){\small ungerade Grade: $X=\{B,C,D,E\}$} \end{picture} \end{center} \noindent\textbf{Bild 3 -- das Matching.} Die billigste Paarung der vier Knoten ist $\{B\text{--}C, D\text{--}E\}$ mit Kosten $1+2 = 3$. Diese zwei Matching-Kanten (dünn) kommen zum Baum dazu -- jetzt haben alle Knoten geraden Grad. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.3pt} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0) \qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3) \qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3) \put(2.6,1.3){\line(1,0){2.0}} \linethickness{0.4pt} \qbezier(0.6,0.25)(1.65,0.72)(2.7,1.22)\put(1.7,0.35){\small $M$} \qbezier(4.6,1.3)(3.6,2.15)(2.6,3.0)\put(3.7,2.2){\small $M$} \put(-0.3,-0.2){\small $+$ Matching $\{B\text{--}C, D\text{--}E\}$, Kosten 3} \end{picture} \end{center} \noindent\textbf{Bild 4 -- Eulerkreis und abkürzen.} Aus $T + M$ gewinnt man einen Eulerkreis und kürzt ihn ab. Ergebnis: Tour $[C,B,A,E,D,C]$ mit Länge 9 -- besser als die 10 von $\Delta$TSP$_1$. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(5.2,3.4)(-0.3,-0.3) \put(0.5,2.2){\circle*{0.14}}\put(0.05,2.25){\small $A$} \put(0.5,0.3){\circle*{0.14}}\put(0.05,0.15){\small $B$} \put(2.6,1.3){\circle*{0.14}}\put(2.35,1.5){\small $C$} \put(4.6,1.3){\circle*{0.14}}\put(4.75,1.3){\small $D$} \put(2.6,3.0){\circle*{0.14}}\put(2.75,3.0){\small $E$} \linethickness{1.1pt} \qbezier(2.6,1.3)(1.55,0.8)(0.5,0.3) \put(0.5,0.3){\line(0,1){1.9}} \qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0) \qbezier(2.6,3.0)(3.6,2.15)(4.6,1.3) \put(4.6,1.3){\line(-1,0){2.0}} \put(0.1,-0.2){\small Tour $[C,B,A,E,D,C]$, Länge $9 \le 1{,}5\cdot\OPT$} \end{picture} \end{center} \begin{idee}{Die Güte $1{,}5$ -- warum das Matching $\le \OPT/2$ kostet} Die Tour hat Länge $w(T) + d(M) \le \OPT + d(M)$. Der Kern ist die Abschätzung $d(M) \le \OPT/2$: Betrachtet man die ungeraden Knoten $X$ in der Reihenfolge einer optimalen Tour, so bilden sie \emph{zwei} sich abwechselnde Matchings $M_1, M_2$. Wegen der Dreiecksungleichung ist $\OPT \ge d(M_1) + d(M_2) \ge 2\, d(M)$, da $M$ das \emph{minimale} perfekte Matching ist. Also $d(M) \le \OPT/2$ und die Tour $\le w(T) + \OPT/2 \le 1{,}5\,\OPT$. \end{idee} \begin{stolper} Zwei Dinge werden oft falsch gemacht: Das Matching läuft \emph{nur} über die ungerad-gradigen Knoten des Spannbaums, nicht über alle. Und ohne die Dreiecksungleichung bricht das Abkürzen zusammen. \end{stolper} % ================================================================== \section{Knapsack: Greedy} % ================================================================== Beim Rucksack als Optimierungsproblem packt man Gegenstände mit maximalem Gesamtprofit ein, ohne die Kapazität $B$ zu überschreiten. Wir behandeln vier Verfahren, jedes einzeln. \begin{idee}{Greedy} Sortiere die Gegenstände nach \glqq Profit pro Gewicht\grqq{} (Profitdichte $p_i/w_i$) und pack der Reihe nach ein, was noch passt. \end{idee} \begin{satz}{Greedy hat \emph{keine} beschränkte Güte} Das Verhältnis $\OPT/\mathrm{GA}$ kann beliebig groß werden.\\[0.3em] \emph{Gegenbeispiel:} Ein Gegenstand mit Gewicht 1 und Profit 1, ein anderer mit Gewicht $B$ und Profit $B-1$, Kapazität $B$. Greedy schaut auf die Dichte -- der kleine hat Dichte 1, der große $(B-1)/B < 1$ -- und nimmt den kleinen, Profit 1. Optimal wäre der große mit Profit $B-1$. Das Verhältnis $B-1$ wächst mit $B$ ins Unendliche. \end{satz} % ================================================================== \section{Knapsack: Modified Greedy} % ================================================================== \begin{idee}{Modified Greedy (MGA)} Rechne zwei Kandidaten aus -- das Greedy-Ergebnis \emph{und} \glqq nimm nur den einen profitabelsten Gegenstand\grqq{} -- und gib den besseren aus. \end{idee} \begin{satz}{MGA hat Güte 2} $\OPT \le 2\,\mathrm{MGA}$ für alle Instanzen.\\[0.3em] \emph{Die zentrale Ungleichungskette:} Man betrachtet die \emph{fraktionale} Relaxierung, in der man Gegenstände auch anteilig einpacken darf; ihr Optimum $\OPT_f$ ist mindestens $\OPT$. Die fraktionale Lösung packt die Gegenstände nach Dichte, bis das erste nicht mehr ganz passt -- dieses \glqq Split-Item\grqq{} $k+1$ wird anteilig genommen. Damit gilt \[ \OPT \le \OPT_f \le \mathrm{GA} + p_{k+1} \le \mathrm{GA} + p_{\max} \le 2\cdot\max\{\mathrm{GA}, p_{\max}\} = 2\,\mathrm{MGA}. \] Greedy verliert also seinen Rückstand nur an dem einen Split-Item, und dessen Profit fängt der zweite Kandidat (bestes Einzel-Item) ab. \end{satz} % ================================================================== \section{Knapsack: Sahni-Algorithmus} % ================================================================== \begin{idee}{Sahni ($k$-Enumeration)} Probiere \emph{alle} Vorauswahlen von höchstens $k$ Gegenständen durch. Fülle jede Vorauswahl mit Greedy auf und gib die beste Gesamtlösung aus. \end{idee} \begin{satz}{Sahni ist ein PTAS} Der Sahni-Algorithmus erreicht Güte $1 + 1/k$ bei Laufzeit $O(n^{k+1})$.\\[0.3em] Je größer $k$, desto besser die Garantie ($k=2$ gibt $3/2$, $k=3$ gibt $4/3$), aber desto teurer die Laufzeit. Für festes $k$ ist sie polynomiell -- also genau ein PTAS. Modified Greedy ist der Spezialfall, in dem man das beste Einzel-Item vorwählt. \end{satz} % ================================================================== \section{Knapsack: FPTAS} % ================================================================== \begin{idee}{FPTAS durch Profit-Skalierung} Runde die Profite auf gröbere Werte ab (teile durch ein passendes $K$ und runde), löse das gröbere Problem \emph{exakt} mit dynamischer Programmierung, und gib diese Lösung aus. \end{idee} \begin{satz}{FPTAS für Knapsack} Das Verfahren erreicht Güte $1 + \varepsilon$ bei Laufzeit $O(n^3/\varepsilon)$. \\[0.3em] \emph{Die zwei zentralen Ungleichungen:} Mit skalierten Profiten $p_i' = \lfloor p_i/K \rfloor$ gilt (1) $\OPT \le K\cdot\OPT(I_K) + Kn$ -- durch das Abrunden verliert jedes Item höchstens $K$, bei $\le n$ Items also $\le Kn$ gesamt; und (2) $K\cdot\OPT(I_K) \le A_K(I)$ -- die skalierte Lösung ist nicht schlechter. Zusammen $\OPT \le A_K + Kn$, und mit $\OPT \ge p_{\max}$ und der Wahl von $K$ folgt der relative Fehler $\le \varepsilon$. Das exakte DP ist pseudopolynomiell ($O(n^2 p'_{\max})$); durch das Abrunden werden die Werte klein genug, dass die Laufzeit $O(n^3/\varepsilon)$ wird. \end{satz} % ================================================================== \section{Scheduling: List Scheduling} % ================================================================== Zurück zu $P\|\Cmax$: $n$ Jobs auf $m$ Maschinen, minimiere die höchste Last. \begin{idee}{List Scheduling} Gehe die Jobs in ihrer gegebenen Reihenfolge durch und lege jeden Job auf die Maschine, die im Moment die \emph{kleinste} Last hat. \end{idee} Das folgende Gantt-Bild zeigt an drei Jobs der Größen $1,1,2$ auf zwei Maschinen, warum die Reihenfolge zählt. Oben List Scheduling (Makespan 3), unten die optimale Verteilung (Makespan 2). Die Balkenlänge ist die Zeit. \begin{center} \setlength{\unitlength}{1cm} \begin{picture}(9,4)(-1.6,-0.5) \put(0,-0.1){\vector(1,0){4.2}}\put(3.9,-0.5){\small Zeit} \multiput(0,-0.18)(1,0){4}{\line(0,1){0.12}} \put(-0.05,-0.5){\small 0}\put(0.95,-0.5){\small 1}\put(1.95,-0.5){\small 2}\put(2.95,-0.5){\small 3} \put(-1.6,3.1){\small \textbf{List Scheduling} (Reihenfolge $1,1,2$):} \put(-1.3,2.4){\small $M_1$} \put(0,2.2){\framebox(1,0.6){\small $1$}} \put(1,2.2){\framebox(2,0.6){\small $2$}} \put(-1.3,1.5){\small $M_2$} \put(0,1.3){\framebox(1,0.6){\small $1$}} \put(3.3,2.3){\small Makespan $3$} \put(-1.6,0.85){\small \textbf{optimal}:} \put(-1.3,0.3){\small $M_1$} \put(0,0.1){\framebox(2,0.6){\small $2$}} \put(2.3,0.2){\small Makespan $2$} \end{picture} \end{center} \begin{satz}{List Scheduling hat Güte $2 - \tfrac1m$ (scharf)} \emph{Die Idee:} Betrachte die Maschine mit der höchsten Last $L$ und den \emph{letzten} Job $J_k$, der auf ihr landete. In dem Moment, als $J_k$ zugewiesen wurde, war diese Maschine die \emph{leerste} -- also waren alle Maschinen mindestens so voll wie $L - p_k$. Daraus folgt $\sum p_i \ge m(L - p_k) + p_k$. Mit den beiden \emph{Universalschranken} $\OPT \ge \frac1m\sum p_i$ (die Last verteilt sich auf $m$ Maschinen) und $\OPT \ge p_k$ (der Job muss irgendwo laufen) ergibt sich $L = \mathrm{LS}(I) \le (2 - \frac1m)\,\OPT$. \end{satz} \begin{intuition} \textbf{Der schlimmste Fall:} $m(m-1)$ Jobs der Größe 1, danach \emph{ein} Job der Größe $m$. List Scheduling verteilt die Einsen gleichmäßig (je $m-1$) und setzt den großen Job obendrauf: Last $2m-1$. Optimal wäre $m$ (großer Job allein). Das Verhältnis $\frac{2m-1}{m} = 2 - \frac1m$ erreicht die Schranke exakt. \end{intuition} % ================================================================== \section{Scheduling: LPT} % ================================================================== \begin{idee}{LPT (Longest Processing Time first)} Sortiere die Jobs zuerst \emph{absteigend} nach Laufzeit -- die längsten zuerst -- und wende darauf List Scheduling an. \end{idee} Der einzige Unterschied zu List Scheduling ist die Sortierung. Sie sorgt dafür, dass die großen Jobs früh verteilt werden, solange die Maschinen noch leer sind. \begin{satz}{LPT hat Güte $\tfrac43 - \tfrac1{3m}$ (scharf)} \emph{Die Idee (minimales Gegenbeispiel):} Man betrachtet ein kleinstes Gegenbeispiel -- eine Instanz mit möglichst wenigen Jobs, bei der LPT die Schranke verletzt. In so einer minimalen Instanz muss der \emph{letzte} (also kleinste) Job $J_n$ den Makespan bestimmen; täte er es nicht, könnte man ihn weglassen und hätte ein noch kleineres Gegenbeispiel. \end{satz} Aus der Annahme, dass LPT die Schranke $\tfrac43 - \tfrac1{3m}$ verletzt, rechnet man dann $p_n > \OPT/3$ heraus. Das ist eine starke Aussage: Wenn schon der kleinste Job größer als ein Drittel des Optimums ist, kann im \emph{optimalen} Schedule keine Maschine mehr als zwei Jobs tragen (drei Jobs à $> \OPT/3$ ergäben $> \OPT$). Nun formt man den optimalen Schedule schrittweise in den LPT-Schedule um. Jeder Schritt ist ein \emph{Austausch} zweier Jobs zwischen zwei Maschinen -- man tauscht so, dass die Reihenfolge Stück für Stück der von LPT gleicht. Man weist für jeden solchen Austausch nach, dass der Makespan dabei \emph{nie steigt} (weil bei höchstens zwei Jobs pro Maschine ein Tausch die stärker belastete Maschine nur entlasten kann). Am Ende steht ein LPT-Schedule mit dem Makespan des Optimums, also $\mathrm{LPT} = \OPT$ -- im Widerspruch dazu, dass die Instanz ein Gegenbeispiel war. Damit kann es kein Gegenbeispiel geben, und die Schranke gilt. % ================================================================== \section{MAX-3-SAT: Güte 2 mit zwei Belegungen} % ================================================================== \begin{idee}{Zwei komplementäre Belegungen} Beim Optimierungsproblem MAX-3-SAT will man möglichst viele Klauseln erfüllen. Der Algorithmus wertet die Formel nur \emph{zweimal} aus -- einmal mit \glqq alle Variablen falsch\grqq{} ($\beta_0$), einmal mit \glqq alle wahr\grqq{} ($\beta_1$) -- und gibt die bessere zurück. \end{idee} \begin{satz}{Der Algorithmus hat Güte 2} $v(A(\varphi)) \ge \tfrac12\, v(\OPT(\varphi))$.\\[0.3em] \emph{Die zentrale Beobachtung:} Jede Klausel enthält mindestens ein Literal -- ist es positiv, wird die Klausel von $\beta_1$ erfüllt; ist es negativ, von $\beta_0$. Jede Klausel wird also von \emph{mindestens einer} der beiden Belegungen erfüllt, folglich $v(\beta_0) + v(\beta_1) \ge m$. Die bessere von beiden erfüllt somit $\ge m/2$ Klauseln. Da eine optimale Belegung höchstens alle $m$ Klauseln erfüllt ($\OPT \le m$), ist $v(A) \ge m/2 \ge \OPT/2$. \end{satz} \begin{intuition} \textbf{Der schlimmste Fall} baut man aus komplementären Klauseln, etwa $\varphi = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_0 \vee \neg x_2 \vee \neg x_3)$. Beide Klauseln sind gemeinsam erfüllbar ($\OPT = 2$), aber $\beta_1$ erfüllt nur die erste und $\beta_0$ nur die zweite -- der Algorithmus erreicht also nur $1 = \OPT/2$. \end{intuition} % ================================================================== \section{2-Approximation für Vertex Cover} % ================================================================== \begin{idee}{Unüberdeckte Kanten voll aufnehmen} Solange es eine noch unüberdeckte Kante gibt, nimm \emph{beide} ihre Endpunkte ins Vertex Cover auf. \end{idee} \begin{satz}{Der Algorithmus hat Güte 2} $|C| \le 2\,|C^*|$, wobei $C^*$ ein optimales Vertex Cover ist.\\[0.3em] \emph{Die Idee (Optimum von unten über ein Matching):} Sei $A$ die Menge der Kanten, für die der Algorithmus beide Endpunkte genommen hat; dann ist $|C| = 2|A|$. Die Kanten in $A$ sind paarweise \emph{knotendisjunkt} -- sobald eine Kante genommen wurde, waren ihre Endpunkte überdeckt, eine spätere Kante aus $A$ kann sie also nicht berühren. $A$ ist damit ein \emph{Matching}. Jedes Vertex Cover muss für jede Matching-Kante einen \emph{eigenen} Knoten stellen, also $|C^*| \ge |A|$. Zusammen: $|C| = 2|A| \le 2|C^*|$. \end{satz} \begin{intuition} Das Muster \glqq Optimum von unten durch ein Matching abschätzen\grqq{} ist eines der drei Standard-Argumente für Güte-Beweise. Die anderen beiden sind \glqq Widerspruch und Zählen\grqq{} (wie bei MAX-3-SAT) und \glqq die zwei Universalschranken\grqq{} (wie beim Scheduling). \end{intuition} % ================================================================== \section{Zum Schluss} % ================================================================== Du hast jetzt das gesamte Fundament der Vorlesung beisammen -- und zwar vollständig, nicht in Stichworten. Für jedes Problem des Katalogs weißt du, wie es definiert ist, warum es in $\NP$ liegt, woher seine Schwere kommt und welche Reduktionen von ihm ausgehen. Du kennst die ETH und das Schema, mit dem man untere Schranken herleitet. Und du kennst jeden Approximationsalgorithmus mit seiner Güte und der Idee des Güte-Beweises. \begin{aha} Der rote Faden war die \emph{Reduktion}. Sie verbindet alle Probleme zu einer einzigen Familie: Von \problem{SAT} aus fließt die Schwere über die ganze Landkarte, und dieselbe Idee -- \glqq bekannt $\redp$ neu\grqq{} -- trägt in der ETH sogar konkrete untere Schranken. Wo exakte Lösungen zu teuer werden, springt die Approximation ein und rettet mit beweisbaren Garantien, was zu retten ist. Das ist die ganze Geschichte des Kurses. \end{aha} \noindent\textbf{Der nächste Schritt.} Dieses Heft gibt dir das Verständnis. Um es in Können zu verwandeln, rechne die Präsenz-, Haus- und Klausuraufgaben und führe dort selbst aus, was hier als Idee steht: Reduktionen vollständig beweisen (beide Richtungen!), Güte-Schranken herleiten, Worst-Case-Instanzen bauen. Viel Erfolg. \end{document}