\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}
