\documentclass[11pt]{article}
\input{style_guide.tex}

\linespread{1.06}
\setlength{\parskip}{0.5em}

\title{\textbf{\Huge Komplexität von Grund auf}\\[0.5em]
\large Alle Probleme, alle Reduktionen, alle Ideen -- ausführlich\\
\normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, SS 2026}
\author{}
\date{}

\begin{document}
\maketitle
\thispagestyle{empty}

\begin{center}\itshape\large
Jedes Problem für sich. Jede Reduktion mit ihrer Idee.\\
Nichts abgekürzt, nichts zusammengelegt.
\end{center}

\vfill

\noindent\textbf{Worum es geht.}
Dieses Heft enthält das komplette Fundament der Vorlesung. Sein Kernstück ist
ein Katalog, der jedes Problem des Kurses in vier Schritten behandelt:
\begin{enumerate}
\item \textbf{Was gefragt ist} -- die Definition, mit einem kleinen Beispiel;
\item \textbf{warum das Problem in $\NP$ liegt} -- als ausgeschriebene
Erklärung: welches Zertifikat, wie geprüft wird, warum das in beide Richtungen
stimmt, wie lange es dauert;
\item \textbf{wo die Schwere herkommt} -- die Reduktion, die das Problem hart
macht, samt der Idee ihrer Konstruktion;
\item \textbf{wohin die Schwere weiterfließt} -- jede Reduktion, die vom Problem
ausgeht, mit ihrer eigenen Idee.
\end{enumerate}
Danach folgen die unteren Schranken (ETH) und die Approximationsalgorithmen --
beides ebenfalls mit den Beweis-Ideen, Problem für Problem und Algorithmus für
Algorithmus.

\medskip
\noindent\textbf{Zwei Grundsätze.}
Ähnliche Dinge werden hier trotzdem \emph{getrennt} behandelt -- jedes Problem
hat seinen eigenen Abschnitt, jeder Nachweis wird eigenständig geführt. Und
nichts wird mit \glqq das sieht man leicht\grqq{} übergangen: Wo eine Idee
gebraucht wird, steht sie auch da.

\medskip
\noindent\textbf{Die Kästen im Heft.}
\begin{center}\small
\begin{tabular}{ll}
\ding{72}~Intuition & der Gedanke hinter dem Formalen\\
\ding{43}~Analogie & ein Alltagsbild\\
\ding{110}~Definition & die präzise Fassung\\
\ding{115}~Satz & ein Ergebnis samt erklärter Beweisidee\\
\ding{108}~Beispiel & konkret durchgerechnet\\
\ding{43}~Idee & die Konstruktion hinter einer Reduktion oder einem Beweis\\
\ding{73}~Aha & die Pointe\\
\ding{55}~Stolperstein & wo Fehler passieren\\
\ding{228}~Zusammenhang & die Verbindung zum Rest\\
\end{tabular}
\end{center}

\vfill
\newpage
\tableofcontents
\newpage

% ##################################################################
\part*{Teil A -- Die Grundlagen}
\addcontentsline{toc}{section}{\textbf{Teil A -- Die Grundlagen}}
% ##################################################################

% ==================================================================
\section{Der Ausgangspunkt: ein widerspenstiges Problem}
% ==================================================================

Jede Theorie braucht einen Anlass. Unserer ist ein Problem, das sich mit einem
Satz erklären lässt und trotzdem seit Jahrzehnten jedem schnellen Algorithmus
widersteht.

Ein \emph{Graph} besteht aus Punkten -- den \emph{Knoten} -- und
Verbindungslinien dazwischen, den \emph{Kanten}. Eine \emph{Clique} ist eine
Gruppe von Knoten, in der jeder mit jedem verbunden ist. Die Frage \glqq Gibt es
im Graphen eine Clique aus $k$ Knoten?\grqq{} ist das \emph{Cliquenproblem}.

\begin{bsp}{Cliquen in einem kleinen Graphen}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(5,2.9)(-0.6,-0.5)
\put(0,0.9){\circle*{0.15}}\put(-0.5,0.85){\small $a$}
\put(1.3,2.2){\circle*{0.15}}\put(1.2,2.4){\small $b$}
\put(2.6,0.9){\circle*{0.15}}\put(2.75,0.85){\small $c$}
\put(1.3,-0.2){\circle*{0.15}}\put(1.2,-0.55){\small $d$}
\put(3.9,1.8){\circle*{0.15}}\put(4.05,1.75){\small $e$}
\qbezier(0,0.9)(0.65,1.55)(1.3,2.2)
\put(0,0.9){\line(1,0){2.6}}
\qbezier(1.3,2.2)(1.95,1.55)(2.6,0.9)
\qbezier(0,0.9)(0.65,0.35)(1.3,-0.2)
\qbezier(2.6,0.9)(3.25,1.35)(3.9,1.8)
\end{picture}
\end{center}
Die Knoten $a$, $b$, $c$ sind paarweise verbunden -- eine Clique der Größe 3.
Die Gruppe $\{a, c, d\}$ dagegen nicht: Zwischen $c$ und $d$ fehlt die
Verbindung. Eine Clique aus vier Knoten gibt es in diesem Graphen nicht.
\end{bsp}

Wie findet ein Computer eine $k$-Clique? Der offensichtliche Weg: alle
Knotengruppen der Größe $k$ durchgehen und jede prüfen. Das funktioniert -- aber
die Anzahl der Gruppen explodiert. Bei $n$ Knoten und $k = n/2$ sind es
mindestens $2^{n/2}$ Stück. Jeder weitere Knoten \emph{verdoppelt} den Aufwand
ungefähr. Diese Wachstumsart heißt \emph{exponentiell}, und sie ist durch keine
Hardware der Welt einzuholen: Ein doppelt so schneller Rechner schafft genau
\emph{einen} Knoten mehr.

\begin{bsp}{Was exponentiell bedeutet}
\begin{center}
\begin{tabular}{rrl}
\toprule
Knoten $n$ & Gruppen (mind.) & Einordnung\\
\midrule
$20$ & rund tausend & sofort fertig\\
$40$ & rund eine Million & unter einer Sekunde\\
$100$ & rund $10^{15}$ & Wochen bis Monate\\
$200$ & rund $10^{30}$ & länger als das Alter des Universums\\
\bottomrule
\end{tabular}
\end{center}
Zwischen $n = 100$ und $n = 200$ liegt kein Faktor 2, sondern ein Faktor
$10^{15}$.
\end{bsp}

\begin{aha}
Niemand hat je einen schnellen Algorithmus für die Clique gefunden -- aber
niemand hat bewiesen, dass es keinen gibt. Die Komplexitätstheorie macht aus
dieser Verlegenheit ein Programm. Sie fragt nicht \glqq wie knackt man dieses
eine Problem?\grqq, sondern \glqq welche Probleme hängen so zusammen, dass sie
alle gemeinsam stehen oder fallen?\grqq{} Auf diese Frage gibt es präzise
Antworten, und sie füllen diesen Kurs.
\end{aha}

% ==================================================================
\section{Die Klasse P: was \glqq schnell\grqq{} heißen soll}
% ==================================================================

Bevor man über schwere Probleme redet, muss man festlegen, was \glqq leicht\grqq{}
ist. Zwei Vereinbarungen tragen alles Weitere.

\emph{Erstens:} Laufzeit misst man in Abhängigkeit von der Eingabegröße $n$ --
zehn Zahlen sortieren ist etwas anderes als zehn Millionen. Und man nimmt den
\emph{schlimmsten Fall} über alle Eingaben einer Größe, denn eine Garantie, die
nur \glqq meistens\grqq{} hält, ist keine.

\emph{Zweitens:} Als \glqq schnell\grqq{} gilt eine Laufzeit, die höchstens wie
eine feste Potenz von $n$ wächst.

\begin{defn}{Die Klasse P}
$\Pclass$ ist die Menge aller Entscheidungsprobleme, die sich durch einen
Algorithmus mit \emph{polynomieller} Laufzeit lösen lassen -- also $O(n^d)$ für
eine Konstante $d$.
\end{defn}

\begin{intuition}
Warum ausgerechnet \glqq polynomiell\grqq? Weil an dieser Grenze der
qualitative Sprung passiert. Polynome wachsen zahm: $n^2$ bei doppelter Eingabe
vervierfacht sich nur. Exponentialfunktionen wie $2^n$ \emph{verdoppeln} sich
bei jedem einzelnen Schritt von $n$. Außerdem ist die Grenze robust -- sie
bleibt dieselbe, egal ob man einen realen Rechner, eine Turingmaschine oder ein
anderes vernünftiges Maschinenmodell zugrunde legt.
\end{intuition}

Ein \emph{Entscheidungsproblem} verlangt als Antwort nur Ja oder Nein. Aus
\glqq finde die größte Clique\grqq{} wird \glqq gibt es eine Clique mit
mindestens $k$ Knoten?\grqq{} -- wer diese Frage für jedes $k$ beantworten kann,
kennt auch das Maximum. Formal ist ein Problem einfach die Menge seiner
Ja-Eingaben. In $\Pclass$ liegen zum Beispiel: Sortieren, kürzeste Wege,
minimale Spannbäume, Matchings.

\begin{stolper}
\textbf{Vorsicht bei Zahlen in der Eingabe.} Eine Zahl $K$ belegt als Eingabe
nur etwa $\log K$ Zeichen -- ihre Ziffern. Ihr \emph{Wert} ist demgegenüber
exponentiell groß. Ein Verfahren, das $K$-mal iteriert, braucht also
exponentiell viele Schritte \emph{gemessen an der Eingabelänge}. Dieser
unscheinbare Punkt erklärt später, warum Probleme über Zahlen (SubSet Sum,
Partition, Knapsack) schwer sein können, obwohl man dort \glqq nur addiert\grqq.
\end{stolper}

% ==================================================================
\section{Die Klasse NP: Lösungen prüfen statt finden}
% ==================================================================

Die zweite Klasse entsteht aus einer Alltagsbeobachtung: Es ist etwas völlig
anderes, eine Lösung zu \emph{suchen}, als eine vorgelegte Lösung zu
\emph{kontrollieren}.

\begin{analogie}
Denk an ein Kreuzworträtsel. Es auszufüllen kann einen Abend dauern. Aber wenn
dir jemand ein fertig ausgefülltes Gitter zeigt, siehst du in zwei Minuten, ob
alles passt -- du liest jede Zeile und vergleichst mit den Fragen. Suchen ist
teuer, Kontrollieren ist billig. $\NP$ ist die Klasse der Probleme, bei denen
wenigstens das \emph{Kontrollieren} billig ist.
\end{analogie}

\subsection{Zertifikate und Verifizierer}

Die vorgelegte Lösung heißt in der Theorie \emph{Zertifikat}; der Kontrolleur
heißt \emph{Verifizierer}.

\begin{defn}{Verifizierer und Zertifikat}
Ein \emph{Verifizierer} für ein Problem $L$ ist ein Algorithmus $A$ mit zwei
Eingaben -- der Instanz $x$ und einem Vorschlag $c$ --, für den gilt:
\[
x \in L \iff \text{es existiert ein } c \text{ mit } A(x,c) = 1.
\]
Ein solches $c$ heißt \emph{Zertifikat} für $x$.
\end{defn}

Beide Richtungen dieser Gleichwertigkeit tragen Gewicht. Für eine Ja-Instanz
\emph{muss es} einen Vorschlag geben, den $A$ gutheißt. Für eine Nein-Instanz
darf $A$ sich von \emph{keinem} Vorschlag überzeugen lassen -- sonst würde er
falsche Ja-Antworten produzieren.

\begin{defn}{Die Klasse NP}
$\NP$ enthält genau die Probleme mit einem \emph{polynomiellen} Verifizierer:
Für jede Ja-Instanz $x$ gibt es ein Zertifikat, mit dem der Verifizierer in
polynomieller Zeit -- gemessen an $|x|$ -- akzeptiert.
\end{defn}

\subsection{Dieselbe Klasse über das Raten}

Es gibt eine zweite Beschreibung von $\NP$, die in Beweisen oft bequemer ist.
Man stellt sich eine Maschine vor, die an jeder Weggabelung \emph{beide} Wege
gleichzeitig weiterverfolgt -- eine \emph{nichtdeterministische} Maschine. Sie
akzeptiert eine Eingabe, sobald auch nur \emph{einer} ihrer vielen parallelen
Rechenwege akzeptiert; bei einer Nein-Instanz scheitern alle Wege.

Der Zusammenhang zur ersten Sicht ist eng: Das Protokoll der Rate-Entscheidungen
eines akzeptierenden Weges \emph{ist} ein Zertifikat, und umgekehrt kann die
Maschine ein Zertifikat einfach \glqq erraten\grqq{} und danach deterministisch
prüfen. \glqq Rate die Lösung, prüfe sie\grqq{} -- nach diesem Muster laufen alle
NP-Nachweise über Maschinen. Beide Sichtweisen beschreiben exakt dieselbe
Klasse.

\subsection{Das Verhältnis von P und NP}

\begin{satz}{$\Pclass \subseteq \NP$}
Jedes Problem aus $\Pclass$ liegt auch in $\NP$.\\[0.3em]
\emph{Warum:} Ein Algorithmus, der das Problem selbst löst, kann als
Verifizierer arbeiten, der seinen Vorschlag gar nicht ansieht -- er berechnet
die Antwort einfach selbst. Schneller prüfen als lösen kann man immer.
\end{satz}

Ob umgekehrt $\NP \subseteq \Pclass$ gilt -- ob also alles effizient
Kontrollierbare auch effizient lösbar ist -- ist die berühmteste offene Frage
der Informatik: das $\Pclass$-gegen-$\NP$-Problem, eines der sieben
Millennium-Probleme. Die verbreitete Vermutung lautet $\Pclass \ne \NP$. Der
gesamte restliche Kurs ist eine Antwort auf die Frage, wie man \emph{trotz}
dieser Ungewissheit belastbare Aussagen über schwere Probleme trifft.

% ==================================================================
\section{Reduktionen: das Vergleichswerkzeug}
% ==================================================================

Wie vergleicht man zwei Probleme, für die man beide keinen schnellen
Algorithmus kennt? Man zeigt, dass das eine im anderen \emph{steckt}.

\begin{analogie}
Wer Temperaturen nur in Fahrenheit messen kann, beantwortet trotzdem jede
Celsius-Frage: erst umrechnen, dann messen. Die Umrechnung ist billig; die
eigentliche Arbeit macht das Fahrenheit-Thermometer. Wenn sich \emph{jede} Frage
vom Typ $A$ billig in eine Frage vom Typ $B$ umrechnen lässt, dann ist $B$
mindestens so mächtig -- und mindestens so schwer -- wie $A$.
\end{analogie}

\begin{defn}{Polynomielle Reduktion $A \redp B$}
Eine \emph{Reduktion} von $A$ auf $B$ ist eine in Polynomialzeit berechenbare
Übersetzung $f$, die jede $A$-Instanz $w$ in eine $B$-Instanz $f(w)$ verwandelt
und dabei die Antwort erhält:
\[
w \in A \iff f(w) \in B.
\]
Man schreibt $A \redp B$.
\end{defn}

Die Erhaltung der Antwort umfasst beide Richtungen: Ja wird zu Ja \emph{und}
Nein wird zu Nein. Nur dann kann man einen $B$-Löser als $A$-Löser
weiterverwenden.

\begin{intuition}
Lies $A \redp B$ als \glqq $B$ ist mindestens so schwer wie $A$\grqq. Denn ein
schneller Algorithmus für $B$ ergäbe sofort einen für $A$ (Übersetzung
vorschalten). Die Härte wandert \emph{in Pfeilrichtung}: Ist $A$ hart, kann $B$
nicht leicht sein.
\end{intuition}

\begin{stolper}
\textbf{Die Richtung entscheidet über alles.} Willst du zeigen, dass ein neues
Problem $Y$ hart ist, dann übersetzt du ein \emph{bekannt hartes} Problem $X$
\emph{in} $Y$: $X \redp Y$. Merksatz: \emph{vom Bekannten zum Neuen}. Die
umgekehrte Richtung $Y \redp X$ würde nur belegen, dass $Y$ höchstens so schwer
wie $X$ ist -- eine wertlose Aussage über $Y$. Dieser Richtungsfehler ist der
häufigste Fehler in Klausuren.
\end{stolper}

\begin{satz}{Reduktionen verketten sich}
Aus $A \redp B$ und $B \redp C$ folgt $A \redp C$.\\[0.3em]
\emph{Warum:} Die Hintereinanderausführung zweier polynomieller Übersetzungen
ist wieder polynomiell -- die erste Übersetzung liefert eine polynomiell große
Zwischeninstanz, auf die die zweite polynomiell viel Zeit verwendet.
\end{satz}

Diese Verkettung ist der Grund, warum wir gleich eine ganze \emph{Kette} von
Problemen aufbauen können: Die Härte des ersten Glieds erreicht über die Pfeile
jedes spätere Glied.

% ==================================================================
\section{NP-Vollständigkeit: die härtesten Probleme in NP}
% ==================================================================

\begin{defn}{NP-schwer}
Ein Problem $H$ heißt \emph{NP-schwer}, wenn sich \emph{jedes} Problem aus
$\NP$ auf $H$ reduzieren lässt: $L \redp H$ für alle $L \in \NP$.
\end{defn}

\begin{defn}{NP-vollständig}
Ein Problem heißt \emph{NP-vollständig}, wenn es NP-schwer ist \emph{und} selbst
in $\NP$ liegt.
\end{defn}

\begin{intuition}
NP-schwer ist die \emph{Mindest}härte -- so schwer wie alles in $\NP$ zusammen.
Die Mitgliedschaft in $\NP$ ist die \emph{Höchst}härte -- nicht schwerer als
prüfbar. NP-vollständige Probleme erfüllen beides zugleich: Sie markieren exakt
die Spitze innerhalb von $\NP$. Es gibt übrigens NP-schwere Probleme, die gar
nicht in $\NP$ liegen -- das Halteproblem am Ende des Katalogs ist so eines.
\end{intuition}

\begin{satz}{Alles hängt an einem Faden}
Sei $H$ NP-vollständig. Dann gilt: $H \in \Pclass$ genau dann, wenn
$\Pclass = \NP$.\\[0.3em]
\emph{Warum:} Hätte $H$ einen polynomiellen Algorithmus, könnte jedes
$L \in \NP$ zuerst nach $H$ übersetzt und dann dort gelöst werden -- ganz $\NP$
fiele in $\Pclass$. Die Gegenrichtung ist unmittelbar, da $H \in \NP$.
\end{satz}

Ein einziges NP-vollständiges Problem mit schnellem Algorithmus würde also die
gesamte Klasse kollabieren lassen. Solange das niemandem gelingt, ist
\glqq NP-vollständig\grqq{} das stärkste verfügbare Indiz für \glqq praktisch
nicht exakt lösbar\grqq.

\subsection{Cook--Levin: das erste harte Problem}

Die Definition von NP-schwer verlangt Reduktionen von \emph{allen} Problemen in
$\NP$ -- unendlich vielen. Für das allererste harte Problem muss man diese Hürde
direkt nehmen. Cook und Levin haben es für \problem{SAT} getan, das
Erfüllbarkeitsproblem der Aussagenlogik.

\begin{satz}{Satz von Cook und Levin}
\problem{SAT} ist NP-vollständig.\\[0.3em]
\emph{Die Idee:} Sei $L$ ein beliebiges Problem aus $\NP$, akzeptiert von einer
ratenden Maschine $M$ in Polynomialzeit. Die gesamte Arbeit von $M$ auf einer
Eingabe $u$ -- Band, Kopf, Zustand, zu jedem Zeitpunkt -- lässt sich durch
endlich viele Wahrheitswerte beschreiben: \glqq zum Zeitpunkt $t$ steht die
Maschine im Zustand $q$\grqq, \glqq zum Zeitpunkt $t$ trägt Feld $i$ das Zeichen
$a$\grqq. Aus diesen Aussagen baut man eine Formel, deren Klauseln erzwingen,
dass der Start korrekt ist, jeder Schritt einer echten Maschinenregel folgt und
das Ende akzeptierend ist. Eine erfüllende Belegung dieser Formel ist dann
nichts anderes als ein \emph{Protokoll eines akzeptierenden Rechenwegs}. Die
Formel ist erfüllbar genau dann, wenn $M$ die Eingabe akzeptiert -- und sie ist
in Polynomialzeit konstruierbar. Da $L$ beliebig war, reduziert ganz $\NP$ auf
\problem{SAT}.
\end{satz}

\subsection{Der Dominoeffekt}

\begin{idee}{Das Vererbungsprinzip}
Sobald \emph{ein} NP-vollständiges Problem existiert, wird der Nachweis für
jedes weitere Problem $Y$ dramatisch einfacher. Es genügen zwei Schritte:
\begin{enumerate}
\item Zeige $X \redp Y$ für irgendein \emph{bereits} NP-vollständiges $X$.
\item Zeige $Y \in \NP$ (Zertifikat und Verifizierer angeben).
\end{enumerate}
Dann reduziert jedes $L \in \NP$ über die Kette $L \redp X \redp Y$ auch auf
$Y$ -- also ist $Y$ NP-schwer, und mit $Y \in \NP$ NP-vollständig.
\end{idee}

Genau nach diesem Prinzip ist der folgende Katalog organisiert: \problem{SAT}
steht am Anfang, und jedes weitere Problem wird über eine Reduktion an ein schon
behandeltes angeschlossen. Die Landkarte zeigt, wer an wem hängt.

\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(3.0,0.7){\problem{TSP}; \problem{Hitting Set}}}
\put(5.4,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 Katalog aller Probleme}
\addcontentsline{toc}{section}{\textbf{Teil B -- Der Katalog aller Probleme}}
% ##################################################################

\noindent Jetzt zum Herzstück. Jedes Problem bekommt einen eigenen Abschnitt mit
denselben vier Stationen: \textbf{Definition und Beispiel} -- \textbf{warum in
NP} -- \textbf{woher die Härte} -- \textbf{wohin die Härte weiterfließt}. Die
Reihenfolge folgt der Landkarte, sodass jede eingehende Reduktion von einem
Problem kommt, das du bereits kennst.

% ==================================================================
\section{SAT}
% ==================================================================

Am Anfang steht die Logik. \problem{SAT} fragt, ob eine logische Formel
überhaupt wahr werden \emph{kann}.

\begin{defn}{SAT}
Eine Formel in \emph{konjunktiver Normalform} (KNF) ist ein UND über
\emph{Klauseln}; jede Klausel ist ein ODER über \emph{Literale}, und ein Literal
ist eine Variable $x_j$ oder ihre Negation $\neg x_j$. Gefragt ist: Existiert
eine Belegung der Variablen mit wahr und falsch, unter der \emph{jede} Klausel
wahr wird?
\end{defn}

\begin{bsp}{Eine Formel entscheiden}
Betrachte $\alpha = (x_1 \vee x_2) \wedge (\neg x_1 \vee x_2) \wedge (\neg x_2
\vee x_3)$. Wähle $x_2 = \true$: Damit sind die ersten beiden Klauseln erfüllt.
Die dritte verlangt nun $x_3 = \true$ (denn $\neg x_2$ ist falsch). Mit
$x_2 = x_3 = \true$ und beliebigem $x_1$ sind alle drei Klauseln wahr -- die
Formel ist erfüllbar.
\end{bsp}

\subsection*{Warum SAT in NP liegt}

Wir gehen den Nachweis in Ruhe durch.

\emph{Was das Zertifikat ist.} Der natürliche Beleg für \glqq erfüllbar\grqq{}
ist eine erfüllende Belegung: für jede der $v$ Variablen ein Wahrheitswert.

\emph{Wie geprüft wird.} Der Verifizierer erhält die Formel und die Belegung.
Er ersetzt jede Variable durch ihren Wert und geht dann Klausel für Klausel
durch: Eine Klausel gilt als erfüllt, sobald mindestens eines ihrer Literale
wahr ist. Findet er eine unerfüllte Klausel, lehnt er ab; andernfalls, wenn alle
Klauseln bestanden haben, akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Wenn die Formel erfüllbar ist,
existiert eine Belegung, die jede Klausel wahr macht -- reicht man genau diese
ein, akzeptiert der Verifizierer. Wenn die Formel dagegen unerfüllbar ist, lässt
\emph{jede} denkbare Belegung mindestens eine Klausel falsch, und der
Verifizierer lehnt jeden Vorschlag ab. Er sagt also nie fälschlich Ja und nie
fälschlich Nein.

\emph{Wie lange es dauert.} Einsetzen und Auswerten berühren jedes Literal der
Formel einmal -- lineare Zeit. Der Verifizierer ist polynomiell, folglich
$\problem{SAT} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{Cook--Levin: Rechenwege werden Formeln}
\problem{SAT} bezieht seine Härte nicht aus einer Reduktion von einem anderen
Katalogproblem -- es ist der Ursprung. Der Satz von Cook und Levin (Teil A)
zeigt direkt: Die Rechnung \emph{jeder} ratenden Polynomialzeit-Maschine lässt
sich als KNF-Formel kodieren, sodass erfüllende Belegungen exakt den
akzeptierenden Rechenwegen entsprechen. Jedes Problem aus $\NP$ reduziert
dadurch auf \problem{SAT}.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

Vier Reduktionen gehen von \problem{SAT} aus; jede wird beim jeweiligen
Zielproblem vollständig ausgeführt, hier steht ihre Grundidee.

\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: Ketten aus Hilfsvariablen}
Lange Klauseln werden in Ketten kurzer Klauseln zerlegt, die über frische
Hilfsvariablen aneinandergekoppelt sind. Die Kopplung ist so gebaut, dass die
Kette genau dann komplett erfüllbar ist, wenn die Originalklausel ein wahres
Literal enthält.
\end{idee}

\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: Literale als Knoten}
Jedes Literalvorkommen wird ein Knoten; verbunden werden nur Knoten aus
verschiedenen Klauseln, deren Literale einander nicht widersprechen. Eine Clique
der Größe \glqq Klauselzahl\grqq{} pickt dann aus jeder Klausel ein Literal, und
alle gepickten vertragen sich -- eine erfüllende Belegung.
\end{idee}

\begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnräder und Aufräumtripel}
Pro Variable entsteht ein ringförmiges \glqq Zahnrad\grqq{} aus Tripeln, das
sich nur auf zwei Arten abdecken lässt -- wahr oder falsch. Klausel-Tripel
docken an wahre Literale an, und Aufräumtripel (\glqq Garbage Collection\grqq)
entsorgen die unbenutzten Literale, damit die Zählung exakt aufgeht.
\end{idee}

\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: Suchen bis zum Erfolg}
Zu jeder Formel lässt sich ein Programm bauen, das stur alle Belegungen
durchprobiert und exakt dann stoppt, wenn es eine erfüllende findet. Ob dieses
Programm jemals hält, ist damit dieselbe Frage wie die Erfüllbarkeit.
\end{idee}

% ==================================================================
\section{3-SAT}
% ==================================================================

\problem{3-SAT} ist \problem{SAT} mit einer Formatvorschrift. Diese kleine
Einschränkung macht es zum beliebtesten Startpunkt für weitere Reduktionen:
Klauseln mit höchstens drei Literalen lassen sich viel leichter in Gadgets
verbauen als beliebig lange.

\begin{defn}{3-SAT}
Gegeben eine KNF-Formel, in der jede Klausel \emph{höchstens drei} Literale
enthält. Gefragt ist: Ist die Formel erfüllbar?
\end{defn}

\begin{bsp}{Eine 3-SAT-Formel}
$(x_1 \vee \neg x_2 \vee x_3) \wedge (x_2 \vee \neg x_3)$: Mit $x_1 = \true$ und
$x_2 = \true$ sind beide Klauseln wahr, egal wie $x_3$ steht. Erfüllbar.
\end{bsp}

\subsection*{Warum 3-SAT in NP liegt}

Auch wenn der Nachweis dem für \problem{SAT} ähnelt, führen wir ihn hier für
sich durch.

\emph{Was das Zertifikat ist.} Eine Belegung der Variablen -- ein Wahrheitswert
pro Variable.

\emph{Wie geprüft wird.} Der Verifizierer setzt die Belegung ein und
kontrolliert die Klauseln nacheinander. Da jede Klausel höchstens drei Literale
hat, ist der Test einer einzelnen Klausel eine Sache konstanter Zeit; insgesamt
läuft er einmal über die Formel. Findet er eine falsche Klausel, lehnt er ab,
sonst akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Für eine erfüllbare Formel führt
die erfüllende Belegung zur Annahme. Für eine unerfüllbare bleibt unter jeder
Belegung eine Klausel falsch, und jeder Vorschlag wird abgelehnt.

\emph{Wie lange es dauert.} Ein Durchgang über die Formel, linear. Also
$\problem{3-SAT} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$: die Kettenkonstruktion im Detail}
Eine Klausel mit vielen Literalen, etwa $(y_1 \vee y_2 \vee y_3 \vee y_4 \vee
y_5)$, wird durch eine Kette ersetzt:
\[
(y_1 \vee y_2 \vee h_1) \wedge (\neg h_1 \vee y_3 \vee h_2) \wedge
(\neg h_2 \vee y_4 \vee y_5),
\]
mit neuen Hilfsvariablen $h_1, h_2$, die nur in dieser Kette vorkommen. Kurze
Klauseln bleiben unverändert.
\end{idee}

Warum die Kette die Erfüllbarkeit bewahrt, sieht man an beiden Richtungen. Ist
in der Originalklausel ein $y_i$ wahr, dann setzt man alle Hilfsvariablen
\emph{vor} der Position von $y_i$ auf wahr und alle danach auf falsch: Jedes
Kettenglied vor $y_i$ wird durch sein $h$-Literal wahr, das Glied mit $y_i$
durch $y_i$ selbst, und jedes Glied danach durch sein negiertes $h$-Literal. Ist
dagegen \emph{kein} $y_i$ wahr, dann zwingt das erste Glied $h_1$ auf wahr, das
zweite daraufhin $h_2$ auf wahr, und so weiter -- bis das letzte Glied nur noch
falsche Literale enthält. Die Kette ist dann unerfüllbar, genau wie die
Originalklausel. Die Umformung vergrößert die Formel nur linear und ist damit
polynomiell. Zusammen mit $\problem{3-SAT} \in \NP$ folgt: \problem{3-SAT} ist
NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Farben als Wahrheitswerte}
Ein Gadget aus Variablen-, Klausel- und Hilfsknoten erzwingt, dass jede
Variable eine von zwei Rollen-Farben (\glqq wahr\grqq/\glqq falsch\grqq) trägt
und jeder Klauselknoten nur dann färbbar ist, wenn seine Klausel ein wahres
Literal hat. Details beim Färbungsproblem.
\end{idee}

\begin{idee}{$\problem{3-SAT}' \redp \problem{Hamiltonkreis}$: Touren als Belegungen}
Spezielle Bausteine übersetzen \glqq Variable wahr oder falsch\grqq{} in
\glqq Baustein links- oder rechtsherum durchlaufen\grqq{} und blockieren jede
Tour, die eine Klausel komplett falsch ließe. Details beim Hamiltonkreis.
\end{idee}

\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$: Literale treffen}
Die Literale bilden das Universum. Paar-Mengen $\{x_i, \bar x_i\}$ erzwingen
eine Belegung, Klausel-Mengen verlangen ein getroffenes wahres Literal. Details
beim Hitting Set.
\end{idee}

\begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$ (streng): Dezimalstellen}
Eine besonders sparsame Kodierung über Ziffern zur Basis 10 erzeugt nur $O(m)$
Zahlen -- wichtig für die unteren Schranken. Details beim SubSet Sum.
\end{idee}

% ==================================================================
\section{$k$-Clique}
% ==================================================================

Das Problem aus der Einleitung bekommt jetzt seine vollständige Behandlung.

\begin{defn}{$k$-Clique}
Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Eine
\emph{Clique} ist eine Menge von Knoten, zwischen denen \emph{sämtliche} Kanten
vorhanden sind. Gefragt ist: Enthält $G$ eine Clique mit mindestens $k$ Knoten?
\end{defn}

\begin{bsp}{Clique ja, Clique nein}
Nimm die Knoten $p, q, r, s$ mit den Kanten $\{p,q\}$, $\{q,r\}$, $\{p,r\}$ und
$\{r,s\}$. Die Menge $\{p,q,r\}$ ist eine Clique der Größe 3 -- alle drei
möglichen Kanten sind da. Die Menge $\{q,r,s\}$ ist keine Clique, denn $q$ und
$s$ sind nicht verbunden.
\end{bsp}

\subsection*{Warum $k$-Clique in NP liegt}

\emph{Was das Zertifikat ist.} Der Beleg für eine Ja-Antwort ist die
Knotenmenge $C$ selbst.

\emph{Wie geprüft wird.} Der Verifizierer nimmt sich alle Paare von Knoten aus
$C$ vor. Für jedes Paar schlägt er nach, ob die Kante im Graphen existiert.
Fehlt auch nur eine, lehnt er ab. Bestehen alle Paare den Test, zählt er noch
$|C|$ und vergleicht mit $k$; ist $|C| \ge k$, akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Besitzt der Graph eine Clique mit
$k$ Knoten, dann besteht genau diese Menge alle Paartests und die Größenprüfung
-- der Verifizierer akzeptiert sie. Besitzt er keine, dann hat jede eingereichte
Menge mit $\ge k$ Knoten irgendwo ein unverbundenes Paar, und der Verifizierer
weist sie zurück. Falsche Ja-Antworten sind ausgeschlossen.

\emph{Wie lange es dauert.} Bei $|C| \le |V|$ Knoten sind es höchstens
$O(|V|^2)$ Paare, jeder Nachschlag in einer Adjazenzmatrix kostet konstante
Zeit; die Größenprüfung ist billig. Insgesamt $O(|V|^2)$ -- polynomiell, also
$\problem{$k$-Clique} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SAT} \redp \problem{$k$-Clique}$: ein Knoten je Literalvorkommen}
Gegeben eine KNF $F$ mit Klauseln $F_1, \dots, F_m$. Der Graph entsteht so:
Für das $j$-te Literal der Klausel $i$ gibt es einen Knoten $[i,j]$. Eine Kante
verbindet $[i,j]$ und $[i',j']$ genau dann, wenn erstens $i \ne i'$ (verschiedene
Klauseln) und zweitens die beiden Literale \emph{nicht} komplementär sind (nicht
$x$ und $\neg x$ derselben Variablen). Gesucht wird eine Clique der Größe
$k = m$.
\end{idee}

Weshalb die Übersetzung funktioniert: Innerhalb einer Klausel gibt es keine
Kanten, also kann eine Clique aus jeder Klausel höchstens einen Knoten enthalten
-- eine $m$-Clique enthält demnach aus jeder Klausel \emph{genau} einen. Ihre
Literale vertragen sich paarweise (sonst fehlte eine Kante), man kann sie also
alle zugleich wahr machen; das erfüllt jede Klausel. Umgekehrt: Erfüllt eine
Belegung die Formel, wählt man aus jeder Klausel ein wahres Literal -- die
zugehörigen $m$ Knoten stammen aus verschiedenen Klauseln und widersprechen sich
nicht, sind also paarweise verbunden: eine $m$-Clique. Der Graphaufbau berührt
jedes Literalpaar einmal und ist polynomiell.

\begin{bsp}{Die Übersetzung an einer Formel}
$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)$ mit $m = 3$ Klauseln, gesucht also eine
3-Clique. Der Graph hat acht Knoten in drei Spalten. Fett hervorgehoben: die
Clique aus $x_1$ (Klausel 1), $\neg x_2$ (Klausel 2) und $x_1$ (Klausel 3).
\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.45,2.55){\small $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 $\neg x_2$}
\put(7.6,3.3){\small Klausel 3}
\put(8.5,2.6){\circle*{0.17}}\put(8.7,2.55){\small $x_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 fette 3-Clique liefert die Belegung $x_1 = \true$, $x_2 = \false$ ($x_3$
frei) -- und die erfüllt tatsächlich alle drei Klauseln. Dünne Kanten zwischen
anderen verträglichen Paaren sind zur Übersicht weggelassen.
\end{bsp}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{Clique} \redp \problem{Independent Set}$: Kanten umklappen}
Man ersetzt den Graphen durch sein \emph{Komplement} -- vorhandene Kanten
verschwinden, fehlende erscheinen -- und behält $k$. Aus \glqq alle
verbunden\grqq{} wird \glqq keiner verbunden\grqq. Details beim Independent Set.
\end{idee}

\begin{idee}{$\problem{Clique} \redp \problem{Vertex Cover}$: Komplement plus Restmenge}
Ebenfalls über den Komplementgraphen, aber mit Schranke $n - k$: Das
\emph{Komplement der Cliquenmenge} wird dort zum Vertex Cover. Details beim
Vertex Cover.
\end{idee}

\begin{idee}{$\problem{Clique} \redp$ Varianten: Dummy- und Universalknoten}
Für \problem{Clique-Nomember} (Clique ohne einen bestimmten Knoten) fügt man
einen \emph{isolierten} Knoten hinzu -- er kann ohnehin in keiner Clique liegen.
Für \problem{Clique-Universal} (Instanz muss einen mit allen verbundenen Knoten
haben) fügt man einen \emph{universellen} Knoten hinzu und erhöht $k$ um eins --
er vergrößert jede Clique um genau ein Mitglied.
\end{idee}

% ==================================================================
\section{Independent Set}
% ==================================================================

Die Clique verlangt maximale Nähe -- das Independent Set verlangt maximale
Distanz.

\begin{defn}{Independent Set (IS)}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Independent Set} ist
eine Knotenmenge, innerhalb derer \emph{keine einzige} Kante verläuft. Gefragt
ist: Enthält $G$ ein Independent Set mit mindestens $k$ Knoten?
\end{defn}

\begin{bsp}{Unabhängige Knoten finden}
Ein Pfad $p - q - r - s$ (drei Kanten). Die Menge $\{p, r\}$ ist unabhängig --
$p$ und $r$ sind nicht direkt verbunden. Auch $\{p, s\}$ und $\{q, s\}$ sind
unabhängig. $\{q, r\}$ ist es nicht, denn die Kante $\{q,r\}$ verläuft mitten
durch die Menge.
\end{bsp}

\subsection*{Warum Independent Set in NP liegt}

\emph{Was das Zertifikat ist.} Die Knotenmenge $I$.

\emph{Wie geprüft wird.} Der Verifizierer betrachtet jedes Knotenpaar aus $I$
und schlägt nach, ob es im Graphen verbunden ist. Findet er auch nur eine Kante
innerhalb von $I$, lehnt er ab. Andernfalls zählt er $|I|$; bei $|I| \ge k$
akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Existiert ein Independent Set der
verlangten Größe, dann übersteht genau diese Menge alle Paartests -- Annahme.
Existiert keines, dann trägt jede eingereichte Menge dieser Größe mindestens
eine innere Kante -- Ablehnung. Der Verifizierer irrt sich in keiner Richtung.

\emph{Wie lange es dauert.} Höchstens $O(|V|^2)$ Paare mit konstantem
Nachschlag, dazu die Größenprüfung: insgesamt $O(|V|^2)$. Also
$\problem{IS} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{Clique} \redp \problem{IS}$: der Komplementgraph}
Aus der Clique-Instanz $(G, k)$ wird die IS-Instanz $(\bar G, k)$, wobei
$\bar G$ dieselben Knoten hat und \emph{genau die} Kanten, die in $G$ fehlen.
\end{idee}

Die Übersetzung ist ein reiner Perspektivwechsel: Eine Menge $C$ ist Clique in
$G$ genau dann, wenn zwischen ihren Knoten in $G$ alle Kanten liegen -- also in
$\bar G$ \emph{gar keine}. Das ist wortwörtlich die Definition eines Independent
Set in $\bar G$. Ja-Instanzen entsprechen sich eins zu eins, ebenso
Nein-Instanzen. Das Komplement zu bilden kostet $O(|V|^2)$ und ist polynomiell.
Da \problem{Clique} NP-vollständig ist und $\problem{IS} \in \NP$, ist
\problem{IS} NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

Im Kursmaterial tritt \problem{Independent Set} vor allem als Zwischenstation
der Dualität auf: Eine Menge ist genau dann unabhängig, wenn ihr Komplement alle
Kanten berührt -- also ein Vertex Cover ist. Diese Beziehung nutzt die nächste
Reduktion. Eine eigene ausgehende Reduktion auf ein weiteres Problem führt der
Kurs nicht ein.

% ==================================================================
\section{Vertex Cover}
% ==================================================================

\begin{defn}{Vertex Cover (VC)}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein \emph{Vertex Cover} ist
eine Knotenmenge, die von \emph{jeder} Kante mindestens einen Endpunkt enthält.
Gefragt ist: Besitzt $G$ ein Vertex Cover mit höchstens $k$ Knoten?
\end{defn}

\begin{analogie}
Stell dir die Kanten als Flure eines Museums vor und die Knoten als Ecken, an
denen Wächter stehen können. Ein Vertex Cover ist eine Wächteraufstellung, bei
der jeder Flur von mindestens einem Ende aus eingesehen wird -- und gefragt ist,
ob $k$ Wächter reichen.
\end{analogie}

\begin{bsp}{Wächter platzieren}
Wieder der Pfad $p - q - r - s$. Die Aufstellung $\{q, r\}$ deckt alle drei
Flure: $\{p,q\}$ über $q$, $\{q,r\}$ über beide, $\{r,s\}$ über $r$. Mit nur
einem Wächter geht es nicht -- egal wo er steht, bleibt ein Flur an beiden Enden
unbewacht.
\end{bsp}

\subsection*{Warum Vertex Cover in NP liegt}

\emph{Was das Zertifikat ist.} Die Wächtermenge $C$.

\emph{Wie geprüft wird.} Der Verifizierer geht die Kantenliste durch. Bei jeder
Kante $\{u,v\}$ fragt er: Liegt $u$ in $C$ oder $v$ in $C$? Sobald eine Kante
beide Male Nein liefert, lehnt er ab. Am Ende zählt er $|C|$; bei $|C| \le k$
akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Ein echtes Vertex Cover der Größe
$\le k$ besteht jeden Kantentest und die Zählung -- es wird akzeptiert. Gibt es
keines, dann lässt jede Menge mit $\le k$ Knoten mindestens eine Kante
unbedeckt, und der Test schlägt fehl. Beide Richtungen halten.

\emph{Wie lange es dauert.} Ein Durchlauf über alle Kanten mit konstanten
Nachschlägen: $O(|E|)$, dazu $O(|V|)$ fürs Zählen. Also $\problem{VC} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{Clique} \redp \problem{VC}$: Komplement und Gegenmenge}
Aus $(G, k)$ mit $n$ Knoten wird $(\bar G,\, n-k)$: derselbe Komplementgraph wie
bei der IS-Reduktion, aber als Schranke die \emph{Restgröße} $n - k$.
\end{idee}

Der Weg führt über zwei Beobachtungen. Erstens: $C$ ist Clique in $G$ genau
dann, wenn $C$ Independent Set in $\bar G$ ist (Kanten umgeklappt). Zweitens:
$I$ ist Independent Set genau dann, wenn $V \setminus I$ Vertex Cover ist --
denn \glqq keine Kante verläuft innerhalb von $I$\grqq{} heißt \glqq jede Kante
hat ein Ende außerhalb von $I$\grqq. Setzt man beides zusammen: $G$ hat eine
$k$-Clique genau dann, wenn $\bar G$ ein Vertex Cover der Größe $n - k$ hat.
Beide Richtungen der Antwortgleichheit stecken in diesen beiden Äquivalenzen.
Der Aufbau ist mit $O(|V|^2)$ polynomiell, also ist \problem{VC} NP-vollständig.

\begin{aha}
Damit schließt sich ein Dreieck aus drei Sichtweisen auf dieselbe Struktur:
\[
C \text{ Clique in } G
\iff C \text{ Independent Set in } \bar G
\iff V \setminus C \text{ Vertex Cover in } \bar G.
\]
Die drei Probleme bleiben eigenständig -- aber wer eine der drei Übersetzungen
verstanden hat, kann die anderen beiden selbst herleiten.
\end{aha}

\begin{bsp}{Das Dreieck in einem Bild}
Links $G$ mit der Clique $\{1,2,3\}$; rechts das Komplement $\bar G$, in dem
$\{1,2,3\}$ unabhängig ist und der übrig gebliebene Knoten 4 alle Kanten
abdeckt.
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(12,3.2)(0,-0.5)
\put(1.3,2.6){\small $G$: $\{1,2,3\}$ 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\}$ IS, $\{4\}$ 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*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{VC} \redp \problem{FVS}$: Kanten zu Mini-Kreisen}
Jede ungerichtete Kante wird durch ein Paar entgegengesetzter Pfeile ersetzt --
ein gerichteter 2-Kreis, den nur seine beiden Endknoten zerstören können.
Details beim Feedback Vertex Set.
\end{idee}

\begin{idee}{$\problem{VC} \redp \Delta$-\problem{Cover}: Kanten zu Dreiecken}
Jede Kante bekommt einen neuen Spitzknoten und wird so zu einem Dreieck
aufgepumpt; Kanten decken heißt dann Dreiecke treffen. Details beim
$\Delta$-Cover.
\end{idee}

% ==================================================================
\section{Feedback Vertex Set}
% ==================================================================

Zum ersten Mal wechseln wir zu \emph{gerichteten} Graphen -- die Kanten sind
jetzt Pfeile.

\begin{defn}{Feedback Vertex Set (FVS)}
Gegeben ein gerichteter Graph $G = (V,E)$ und eine Zahl $k$. Gesucht ist eine
Menge $X$ von höchstens $k$ Knoten, deren Entfernung \emph{alle gerichteten
Kreise} zerstört -- sodass der Restgraph kreisfrei ist. Gefragt: Existiert ein
solches $X$?
\end{defn}

\begin{bsp}{Kreise brechen}
Ein Graph enthalte die Pfeile $a \to b$, $b \to a$, $b \to c$ und $c \to b$. Es
gibt zwei Kreise: $a \to b \to a$ und $b \to c \to b$. Beide laufen durch $b$ --
entfernt man $b$, ist der Rest kreisfrei. $X = \{b\}$ ist ein FVS der Größe 1.
\end{bsp}

\subsection*{Warum Feedback Vertex Set in NP liegt}

\emph{Was das Zertifikat ist.} Die zu entfernende Knotenmenge $X$.

\emph{Wie geprüft wird.} Zwei Kontrollen. Erstens zählt der Verifizierer
$|X|$ und vergleicht mit $k$. Zweitens muss er entscheiden, ob der Graph ohne
$X$ kreisfrei ist -- dafür steht ihm ein klassischer Polynomialzeit-Algorithmus
zur Verfügung: die \emph{topologische Sortierung}. Sie ordnet die Knoten so an,
dass alle Pfeile vorwärts zeigen, und gelingt \emph{genau dann}, wenn kein Kreis
existiert. Gelingt die Sortierung von $G \setminus X$ und stimmt die Größe,
akzeptiert der Verifizierer.

\emph{Warum das in beide Richtungen stimmt.} Ist $X$ ein echtes FVS der Größe
$\le k$, dann ist der Restgraph kreisfrei, die Sortierung klappt, und der
Vorschlag wird angenommen. Gibt es kein solches FVS, dann hinterlässt jede Menge
dieser Größe einen Kreis, die Sortierung scheitert, der Vorschlag wird
abgelehnt.

\emph{Wie lange es dauert.} Topologische Sortierung läuft in $O(|V| + |E|)$,
die Zählung in $O(|V|)$. Also $\problem{FVS} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{VC} \redp \problem{FVS}$: antiparallele Bögen}
Aus einer ungerichteten VC-Instanz $(G, k)$ wird eine gerichtete FVS-Instanz
$(G', k)$: Jede Kante $\{u,v\}$ von $G$ wird durch die \emph{beiden} Pfeile
$u \to v$ und $v \to u$ ersetzt. Sonst ändert sich nichts, auch $k$ bleibt.
\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(0.9,-0.05){\small 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(4.9,-0.05){\small 2-Kreis in $G'$}
\end{picture}
\end{center}

Der Kern des Arguments: Jedes Pfeilpaar bildet einen Kreis der Länge zwei, und
\emph{andere} Kreise gibt es in $G'$ nicht in neuer Qualität -- jeder Kreis
durchläuft solche Pfeilpaare. Einen 2-Kreis $u \to v \to u$ zerstört man nur,
indem man $u$ oder $v$ entfernt. \glqq Alle Kreise zerstören\grqq{} übersetzt
sich damit in \glqq von jeder Original-Kante einen Endpunkt entfernen\grqq{} --
das ist wörtlich die Vertex-Cover-Bedingung. Konkret: Ist $C$ ein Vertex Cover
von $G$, dann bleibt nach Entfernen von $C$ kein Pfeilpaar vollständig übrig,
also kein Kreis -- $C$ ist ein FVS. Ist umgekehrt $X$ ein FVS von $G'$, dann
muss $X$ jeden 2-Kreis anfassen, deckt also jede Kante von $G$ ab -- $X$ ist ein
Vertex Cover. Der Umbau kostet $O(|E|)$. \problem{FVS} ist damit NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

\problem{Feedback Vertex Set} ist im Kurs ein Endpunkt -- es dient nicht als
Quelle einer weiteren Reduktion.

% ==================================================================
\section{$\Delta$-Cover}
% ==================================================================

Noch einmal Vertex Cover als Quelle, diesmal mit einem anderen Gadget: Statt um
Kanten geht es um Dreiecke.

\begin{defn}{$\Delta$-Cover}
Gegeben ein ungerichteter Graph $G = (V,E)$ und eine Zahl $k$. Ein
\emph{$\Delta$-Cover} ist eine Knotenmenge, die jedes \emph{Dreieck} des Graphen
(jede 3-Clique) in mindestens einem Knoten trifft. Gefragt: Gibt es eines mit
höchstens $k$ Knoten?
\end{defn}

\begin{bsp}{Dreiecke treffen}
Zwei Dreiecke $\{a,b,c\}$ und $\{c,d,e\}$, die sich den Knoten $c$ teilen. Die
Menge $\{c\}$ trifft beide -- ein $\Delta$-Cover der Größe 1. Die Menge
$\{a,d\}$ trifft ebenfalls beide, braucht aber zwei Knoten.
\end{bsp}

\subsection*{Warum $\Delta$-Cover in NP liegt}

\emph{Was das Zertifikat ist.} Die Knotenmenge $C_\Delta$.

\emph{Wie geprüft wird.} Der Verifizierer zählt zunächst $|C_\Delta|$ und
vergleicht mit $k$. Dann sucht er systematisch alle Dreiecke: Er läuft über
sämtliche Knotentripel, prüft für jedes, ob alle drei Verbindungskanten
existieren, und wenn ja, ob wenigstens einer der drei Knoten in $C_\Delta$
liegt. Ein ungetroffenes Dreieck führt zur Ablehnung; sonst wird akzeptiert.

\emph{Warum das in beide Richtungen stimmt.} Ein echtes $\Delta$-Cover der
verlangten Größe übersteht die Suche -- kein Dreieck bleibt ungetroffen -- und
wird angenommen. Existiert keines, findet die Suche bei jedem Vorschlag dieser
Größe ein verfehltes Dreieck und lehnt ab.

\emph{Wie lange es dauert.} Es gibt $O(|V|^3)$ Tripel; Kanten- und
Mitgliedschaftstests pro Tripel sind konstant bis linear. Insgesamt höchstens
$O(|V|^4)$ -- polynomiell, also $\Delta\text{-}\problem{Cover} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{VC} \redp \Delta$-\problem{Cover}: Kanten aufpumpen}
Zur VC-Instanz $(G, k)$ baut man $G'$: Für jede Kante $e = \{u,v\}$ kommt ein
frischer Knoten $t_e$ hinzu, verbunden mit $u$ und mit $v$. Jede Kante wird so
zur Spitze eines eigenen Dreiecks $\{t_e, u, v\}$. Die Schranke $k$ bleibt.
\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.1,-0.1){\small Kante $e$}
\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 $t_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.8,-0.35){\small Dreieck $\{t_e,u,v\}$}
\end{picture}
\end{center}

Die Hinrichtung ist unkompliziert: Deckt $C$ jede Kante von $G$, dann enthält
$C$ von jedem Gadget-Dreieck $\{t_e, u, v\}$ den Knoten $u$ oder $v$ -- das
Dreieck ist getroffen.

\begin{stolper}
\textbf{Hier liegt eine Falle, die echte Punkte gekostet hat.} $G'$ enthält
neben den Gadget-Dreiecken auch alle Dreiecke, die \emph{schon in $G$ standen} --
denn die Originalkanten bleiben ja erhalten. Ein Beweis, der behauptet,
\emph{jedes} Dreieck von $G'$ habe die Form $\{t_e, u, v\}$, ist falsch. Die
geerbten Dreiecke muss man eigens behandeln: Ihre drei Seiten sind
Originalkanten, jede davon wird vom Vertex Cover gedeckt, also liegt einer ihrer
Eckknoten in $C$ -- auch sie sind getroffen. Erst mit diesem Fall ist die
Hinrichtung vollständig.
\end{stolper}

Für die Rückrichtung nimmt man ein $\Delta$-Cover $C_\Delta$ der Größe $\le k$
und säubert es: Enthält es einen Gadget-Knoten $t_e$, ersetzt man ihn durch
einen der beiden Endpunkte von $e$ -- das einzige Dreieck durch $t_e$ ist sein
eigenes, und das bleibt getroffen; die Menge wächst dabei nicht. Danach liegt
$C_\Delta$ ganz in $V$, und weil es jedes Gadget-Dreieck $\{t_e, u, v\}$ treffen
muss, enthält es $u$ oder $v$ -- von \emph{jeder} Kante $e$ einen Endpunkt. Das
ist ein Vertex Cover. Der Aufbau kostet $O(|E|)$; $\Delta$-\problem{Cover} ist
NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

Auch das $\Delta$-Cover ist im Kurs ein Endpunkt ohne ausgehende Reduktion.

% ==================================================================
\section{$k$-Color}
% ==================================================================

Zurück zur 3-SAT-Linie der Landkarte. Das Färbungsproblem ist ein Klassiker mit
anschaulicher Deutung.

\begin{defn}{$k$-Color}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine gültige \emph{$k$-Färbung}
weist jedem Knoten eine von $k$ Farben zu, wobei benachbarte Knoten nie dieselbe
Farbe tragen dürfen. Gefragt: Lässt sich $G$ so färben?
\end{defn}

Die klassische Deutung: Länder einer Landkarte färben, sodass Nachbarländer
verschieden aussehen. Schon mit drei Farben ist die Frage NP-vollständig.

\begin{bsp}{Drei Farben im Einsatz}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(4.5,2.6)(-0.3,-0.3)
\put(0,0){\circle*{0.18}}\put(-0.4,-0.05){\small $1$}
\put(2,0){\circle*{0.18}}\put(2.1,-0.3){\small $2$}
\put(1,1.7){\circle*{0.18}}\put(1.1,1.85){\small $3$}
\put(3.4,0.85){\circle*{0.18}}\put(3.55,0.8){\small $1$}
\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}
Die Zahlen sind Farben. Das Dreieck links verbraucht zwingend drei verschiedene
Farben. Der rechte Knoten hat nur einen Nachbarn (Farbe 2) und darf deshalb
Farbe 1 wiederverwenden.
\end{bsp}

\subsection*{Warum $k$-Color in NP liegt}

\emph{Was das Zertifikat ist.} Die Farbzuweisung -- pro Knoten eine Zahl
zwischen 1 und $k$.

\emph{Wie geprüft wird.} Der Verifizierer wandert über die Kantenliste. Für
jede Kante vergleicht er die Farben ihrer beiden Endpunkte; sind sie irgendwo
gleich, lehnt er ab. Übersteht die Färbung alle Kanten, akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Eine gültige Färbung passiert
jeden Vergleich und wird angenommen. Ist der Graph nicht $k$-färbbar, enthält
jede eingereichte Zuweisung mindestens eine gleichfarbige Kante -- der Vergleich
schlägt dort fehl, Ablehnung.

\emph{Wie lange es dauert.} Ein Lauf über $|E|$ Kanten mit konstantem Vergleich:
$O(|E|)$. Also $\problem{$k$-Color} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{3-SAT} \redp \problem{$k$-Color}$: Färben heißt Belegen}
Zur Formel mit $n$ Variablen und $m$ Klauseln baut man einen Graphen mit drei
Sorten von Knoten: für jede Variable ein Paar $x_i$, $\bar x_i$ und ein
Hilfsknoten $v_i$; für jede Klausel ein Knoten $F_j$; dazu ein zentraler Knoten
$z$. Die Hilfsknoten $v_1, \dots, v_n$ und $z$ sind untereinander komplett
verbunden -- sie bilden eine Clique und schlucken dadurch $n+1$ paarweise
verschiedene Farben. Jedes Paar $x_i$, $\bar x_i$ ist verbunden und zusätzlich
so mit den Hilfsknoten verdrahtet, dass für die beiden nur noch zwei Farben in
Frage kommen -- eine spielt \glqq wahr\grqq, die andere \glqq falsch\grqq. Die
Färbung der Literalknoten \emph{ist} damit eine Belegung. Jeder Klauselknoten
$F_j$ schließlich ist genau mit den Literalknoten verbunden, die \emph{nicht} in
seiner Klausel vorkommen; dadurch findet er genau dann noch eine erlaubte Farbe,
wenn eines seiner eigenen Literale die \glqq wahr\grqq-Farbe trägt. Insgesamt:
Der Graph ist mit $n+1$ Farben färbbar genau dann, wenn die Formel erfüllbar
ist.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

Das Färbungsproblem gibt seine Härte im Kurs nicht weiter; es kehrt aber bei den
unteren Schranken in Teil C zurück, wo seine besonders knappe
$O(n+m)$-Konstruktion den Ausschlag gibt.

% ==================================================================
\section{Hamiltonkreis}
% ==================================================================

\begin{defn}{Hamiltonkreis (HK)}
Gegeben ein Graph $G$. Gefragt ist, ob es eine geschlossene Tour gibt, die
\emph{jeden Knoten genau einmal} besucht. (Das Problem ist für gerichtete wie
ungerichtete Graphen NP-vollständig.)
\end{defn}

Nicht verwechseln mit dem Eulerkreis, der jede \emph{Kante} genau einmal nutzt
-- der ist leicht zu finden. Beim Hamiltonkreis geht es um die \emph{Knoten},
und das ändert alles.

\begin{bsp}{Eine Rundtour durch alle Knoten}
\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}
Die fette Route berührt jeden der fünf Knoten exakt einmal und kehrt zum Start
zurück -- ein Hamiltonkreis.
\end{bsp}

\subsection*{Warum Hamiltonkreis in NP liegt}

\emph{Was das Zertifikat ist.} Die Besuchsreihenfolge -- eine Auflistung aller
Knoten in Tourfolge.

\emph{Wie geprüft wird.} Zwei Kontrollen. Der Verifizierer hakt erstens ab, dass
in der Liste jeder Knoten genau einmal auftaucht (etwa mit einer
Markierungstabelle). Zweitens läuft er die Liste entlang und schlägt für jedes
Nachbarpaar -- einschließlich des Schlusses von letzter zu erster Position --
nach, ob die Kante existiert. Beide Kontrollen bestanden: Annahme; sonst
Ablehnung.

\emph{Warum das in beide Richtungen stimmt.} Ein echter Hamiltonkreis liefert
als Liste genau ein Zertifikat, das beide Kontrollen besteht. Und jede Liste,
die beide Kontrollen besteht, beschreibt ihrerseits eine geschlossene Tour über
lauter echte Kanten durch alle Knoten -- einen Hamiltonkreis. Es gibt keine
Lücke zwischen \glqq wird akzeptiert\grqq{} und \glqq ist wirklich einer\grqq.

\emph{Wie lange es dauert.} Markieren in $O(|V|)$, Kantenchecks in $O(|V|)$
Nachschlägen: zusammen linear bis $O(|V|+|E|)$. Also $\problem{HK} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{3-SAT}' \redp \problem{HK}$: Bausteine mit zwei Durchgängen}
Für die Variante mit \emph{genau} drei Literalen pro Klausel baut man den
Graphen aus zwei Bausteintypen. Die \emph{A-Bausteine} -- leiterförmige
Komponenten, eine je Literalvorkommen -- lassen sich von einer Tour nur auf
genau zwei Weisen durchqueren; die Wahl der Weise kodiert, ob die zugehörige
Variable wahr oder falsch ist. Die \emph{B-Bausteine} -- einer je Klausel --
sind so verdrahtet, dass eine Tour sie für jede \emph{nichtleere} Teilmenge
ihrer drei Anschlusskanten passieren kann, für die leere aber nicht. Die leere
Teilmenge entspricht dem Fall \glqq alle drei Literale falsch\grqq. Eine
Hamiltontour durch das Gesamtgebilde existiert deshalb genau dann, wenn man die
Variablen so setzen kann, dass keine Klausel leer ausgeht -- wenn die Formel
erfüllbar ist.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{HK} \redp \problem{TSP}$: Distanzen als Filter}
Man macht aus dem Graphen eine Distanztabelle: echte Kanten kosten 1, fehlende
Verbindungen kosten $|V| + 1$, und als Budget setzt man $L = |V|$. Eine
Rundreise im Budget kann sich keine einzige teure Nicht-Kante leisten -- sie
existiert also genau dann, wenn der Graph eine reine Kanten-Tour durch alle
Knoten besitzt: einen Hamiltonkreis. Details beim TSP.
\end{idee}

\begin{idee}{Kreis und Pfad ineinander überführen}
Vom \emph{Pfad} zum \emph{Kreis}: Ein zusätzlicher Knoten, der mit allen
verbunden ist, schließt jeden Hamiltonpfad zu einem Kreis. Vom Kreis zum Pfad:
Man verdoppelt einen Knoten $v$ zu einem Zwilling $v^*$ mit denselben Nachbarn
und klemmt an $v$ und $v^*$ je einen neuen Endknoten vom Grad 1 -- ein
Hamiltonpfad zwischen den beiden Endknoten entspricht dann genau einem
Hamiltonkreis durch $v$.
\end{idee}

% ==================================================================
\section{TSP}
% ==================================================================

\begin{defn}{TSP (Entscheidungsvariante)}
Gegeben $n$ Städte, eine Distanz $d(i,j)$ für jedes Städtepaar und ein Budget
$L$. Gefragt: Gibt es eine Rundreise, die jede Stadt genau einmal besucht und
insgesamt höchstens $L$ kostet?
\end{defn}

Gegenüber dem Hamiltonkreis kommen Zahlen ins Spiel: Nicht \emph{ob} eine
Rundtour existiert, sondern ob eine \emph{billige} existiert. In der
Optimierungsfassung -- kürzeste Rundreise -- ist das TSP das Paradebeispiel des
Approximationsteils.

\begin{bsp}{Ein Budget einhalten}
Vier Städte an den Ecken eines Quadrats, Seitenlänge 1, Diagonalen 2. Die Tour
einmal außen herum kostet 4. Bei Budget $L = 4$ lautet die Antwort Ja; bei
$L = 3$ Nein, denn jede Rundreise über vier Städte braucht vier Teilstrecken
der Länge $\ge 1$.
\end{bsp}

\subsection*{Warum TSP in NP liegt}

\emph{Was das Zertifikat ist.} Die Stadtreihenfolge der behaupteten Rundreise.

\emph{Wie geprüft wird.} Der Verifizierer bestätigt zuerst, dass jede Stadt
genau einmal in der Reihenfolge steht. Dann summiert er die Distanzen von
Station zu Station, die Rückfahrt zum Start eingeschlossen, und vergleicht die
Gesamtsumme mit $L$. Summe im Budget und Reihenfolge vollständig: Annahme.

\emph{Warum das in beide Richtungen stimmt.} Existiert eine Rundreise im
Budget, dann wird ihre Reihenfolge eingereicht und angenommen. Existiert keine,
dann sprengt jede vollständige Reihenfolge das Budget -- der Summenvergleich
lehnt sie ab. Beide Richtungen greifen.

\emph{Wie lange es dauert.} $n$ Additionen und ein Vergleich: $O(n)$. Also
$\problem{TSP} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{HK} \redp \problem{TSP}$: teuer machen, was verboten ist}
Aus dem HK-Graphen $G$ mit Knotenmenge $V$ wird die TSP-Instanz: Städte sind die
Knoten; $d(u,v) = 1$ für jede Kante von $G$, $d(u,v) = |V| + 1$ für jedes
Nicht-Kanten-Paar; Budget $L = |V|$. Eine Rundreise besteht aus genau $|V|$
Teilstrecken. Bleibt sie im Budget $|V|$, muss jede Teilstrecke den Preis 1
haben -- schon eine einzige Nicht-Kante spränge mit $|V|+1$ allein über das
Budget. Die Rundreise benutzt also nur echte Kanten und ist ein Hamiltonkreis.
Hat $G$ umgekehrt einen Hamiltonkreis, kostet dieser als Rundreise exakt $|V|$
und hält das Budget ein. Bemerkenswert: Das TSP bleibt sogar dann
NP-vollständig, wenn die Distanzen symmetrisch sind und die Dreiecksungleichung
erfüllen.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

Das TSP reicht seine Härte im Kurs nicht weiter. Es wird stattdessen zur
Hauptbühne des Approximationsteils: Dort zeigen wir, dass es ohne
Zusatzannahmen nicht einmal näherungsweise lösbar ist -- und mit
Dreiecksungleichung erstaunlich gut.

% ==================================================================
\section{3-dimensionales Matching}
% ==================================================================

Der dritte Ast der Landkarte führt weg von den Graphen, hinein in Mengen und
schließlich Zahlen. Sein erstes Glied handelt von Dreier-Zuordnungen.

\begin{defn}{3-dimensionales Matching (3-DM)}
Gegeben drei gleich große, disjunkte Mengen $U$, $V$, $W$ sowie eine Liste $T$
von Tripeln der Form $(u, v, w)$ mit $u \in U$, $v \in V$, $w \in W$. Gefragt:
Kann man Tripel aus $T$ so auswählen, dass jedes Element aller drei Mengen in
\emph{genau einem} gewählten Tripel vorkommt?
\end{defn}

\begin{analogie}
Drei gleich große Gruppen -- etwa Piloten, Flugzeuge und Zeitfenster -- sollen
zu kompletten Einsätzen kombiniert werden. Die Liste $T$ enthält die
\emph{zulässigen} Kombinationen. Gesucht ist ein Einsatzplan, in dem jeder
Pilot, jedes Flugzeug und jedes Zeitfenster genau einmal verplant ist.
\end{analogie}

\begin{bsp}{Ein gültiger Plan}
$U = \{u_1, u_2\}$, $V = \{v_1, v_2\}$, $W = \{w_1, w_2\}$;
$T$ enthalte $(u_1, v_1, w_2)$, $(u_2, v_2, w_1)$ und $(u_1, v_2, w_1)$. Die
Auswahl der ersten beiden Tripel verplant jedes der sechs Elemente genau einmal
-- ein 3-dimensionales Matching. Nimmt man stattdessen das dritte Tripel, lässt
sich kein zweites mehr ergänzen, ohne $u_1$, $v_2$ oder $w_1$ doppelt zu
verwenden.
\end{bsp}

\subsection*{Warum 3-DM in NP liegt}

\emph{Was das Zertifikat ist.} Die getroffene Tripelauswahl $M \subseteq T$.

\emph{Wie geprüft wird.} Der Verifizierer legt für jedes Element aller drei
Mengen einen Zähler an und geht die gewählten Tripel durch, wobei er für jede
der drei Komponenten den Zähler erhöht. Am Ende kontrolliert er: Steht jeder
Zähler auf genau 1? Zusätzlich prüft er $|M| = |U|$. Beides erfüllt: Annahme;
irgendein Zähler auf 0 oder $\ge 2$: Ablehnung.

\emph{Warum das in beide Richtungen stimmt.} Ein echtes Matching bringt
konstruktionsgemäß jeden Zähler auf exakt 1 und wird angenommen. Gibt es keines,
dann verfehlt jede Auswahl das Zählerbild -- irgendwo entsteht eine Doppelung
oder eine Lücke -- und sie wird abgelehnt.

\emph{Wie lange es dauert.} Einmal über die Auswahl laufen und Zähler pflegen:
$O(|T|)$ plus $O(|U|+|V|+|W|)$ fürs Kontrollieren. Also $\problem{3-DM} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SAT} \redp \problem{3-DM}$: Zahnräder, Andockstellen, Aufräumer}
Drei Baustein-Sorten übersetzen eine Formel in Tripel. \emph{Zahnräder:} Für
jede Variable ordnet man Tripel ringförmig an; ein Matching kann den Ring nur
in einer von zwei Verzahnungen abdecken -- die eine heißt \glqq wahr\grqq, die
andere \glqq falsch\grqq. Je nach Verzahnung bleiben genau die Literal-Elemente
der einen oder der anderen Sorte unbedeckt zurück. \emph{Andockstellen:} Für
jede Klausel gibt es ein Elementpaar, dessen Tripel nur an ein
\emph{freigebliebenes} Literal der Klausel andocken können -- das erzwingt, dass
jede Klausel ein wahres Literal hat. \emph{Aufräumer:} Zusätzliche Tripel
(\glqq Garbage Collection\grqq) sammeln alle danach noch unbedeckten
Literal-Elemente ein, damit die Bilanz \glqq jedes Element genau einmal\grqq{}
exakt aufgeht. Ein Matching existiert genau dann, wenn die Formel erfüllbar ist.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: nur die Brille wechseln}
Ein Tripel $(u,v,w)$ ist nichts anderes als eine dreielementige Menge
$\{u,v,w\}$ über dem Gesamtuniversum $U \cup V \cup W$. Mehr braucht die
Reduktion nicht -- ausgeführt wird sie beim 3-Exact Cover.
\end{idee}

% ==================================================================
\section{3-Exact Cover}
% ==================================================================

\begin{defn}{3-Exact Cover (3-EC)}
Gegeben ein Universum $U$ mit $3m$ Elementen und eine Familie dreielementiger
Teilmengen $S_1, \dots, S_n \subseteq U$. Gefragt: Lassen sich Mengen so
auswählen, dass jedes Element von $U$ in \emph{genau einer} gewählten Menge
liegt -- eine lückenlose Überdeckung ohne Überlappung?
\end{defn}

\begin{bsp}{Exakt oder nicht}
$U = \{1, \dots, 6\}$ mit $S_1 = \{1,3,5\}$, $S_2 = \{2,4,6\}$,
$S_3 = \{1,2,3\}$. Die Wahl $\{S_1, S_2\}$ deckt jedes Element genau einmal --
exakt. Die Wahl $\{S_2, S_3\}$ deckt die 2 doppelt und lässt die 5 aus -- keine
exakte Überdeckung.
\end{bsp}

\subsection*{Warum 3-EC in NP liegt}

\emph{Was das Zertifikat ist.} Die Auswahl der Mengen. Eine exakte Überdeckung
von $3m$ Elementen durch Dreiermengen umfasst genau $m$ Mengen.

\emph{Wie geprüft wird.} Der Verifizierer führt eine Strichliste über die
Elemente von $U$: Für jede gewählte Menge macht er bei ihren drei Elementen
einen Strich. Danach kontrolliert er, dass jedes Element genau einen Strich
trägt -- keiner fehlt, keiner ist doppelt. Bestanden: Annahme; sonst Ablehnung.

\emph{Warum das in beide Richtungen stimmt.} Eine exakte Überdeckung erzeugt
per Definition genau das Strichbild \glqq überall eins\grqq{} und wird
angenommen. Existiert keine, produziert jede Auswahl entweder eine Lücke oder
eine Doppelung und fällt durch.

\emph{Wie lange es dauert.} Strichliste führen und ablesen: linear in der
Eingabe. Also $\problem{3-EC} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{3-DM} \redp \problem{3-EC}$: dieselben Daten, neue Lesart}
Man nimmt die 3-DM-Instanz und liest sie um: Das Universum ist
$U \cup V \cup W$ (Größe $3 \cdot |U|$), und jedes Tripel $(u,v,w)$ wird zur
Menge $\{u,v,w\}$. Es wird nichts hinzugefügt und nichts verändert.
\end{idee}

Dass die Antwort erhalten bleibt, liegt daran, dass beide Bedingungen dasselbe
sagen: \glqq Jedes Element kommt in genau einem gewählten Tripel vor\grqq{}
(3-DM) und \glqq jedes Element liegt in genau einer gewählten Menge\grqq{}
(3-EC) sind identische Forderungen, nur einmal über Tripel und einmal über
Mengen formuliert. Eine Auswahl erfüllt die eine genau dann, wenn sie die andere
erfüllt -- in beide Richtungen. Die Umformung ist reine Notation und damit
trivial polynomiell berechenbar in einem Durchlauf. Da \problem{3-DM}
NP-vollständig ist und $\problem{3-EC} \in \NP$, ist \problem{3-EC}
NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Überdecken wird Addieren}
Jede Menge wird als Zahl in einem Stellensystem mit riesiger Basis kodiert;
exakt überdecken heißt dann, die Zahl \glqq lauter Einsen\grqq{} als Summe zu
treffen. Vollständig ausgeführt beim SubSet Sum.
\end{idee}

% ==================================================================
\section{SubSet Sum}
% ==================================================================

\begin{defn}{SubSet Sum}
Gegeben ganze Zahlen $c_1, \dots, c_n$ und ein Ziel $K$. Gefragt: Existiert eine
Auswahl dieser Zahlen, deren Summe \emph{exakt} $K$ ergibt?
\end{defn}

\begin{bsp}{Ein Ziel treffen}
Zahlen $5, 9, 11, 2$ und Ziel $K = 16$. Die Auswahl $\{5, 9, 2\}$ summiert auf
16 -- getroffen. $\{5, 11\}$ ergibt dagegen 16 ebenfalls! Beide sind gültige
Zertifikate; eines genügt. Für $K = 8$ hingegen trifft keine Auswahl.
\end{bsp}

\subsection*{Warum SubSet Sum in NP liegt}

\emph{Was das Zertifikat ist.} Die Auswahl -- pro Zahl ein Bit
(\glqq dabei / nicht dabei\grqq).

\emph{Wie geprüft wird.} Der Verifizierer addiert die ausgewählten Zahlen und
vergleicht das Ergebnis mit $K$. Bei Gleichheit akzeptiert er, sonst nicht.

\emph{Warum das in beide Richtungen stimmt.} Gibt es eine treffende Auswahl,
liefert genau sie die Summe $K$ und wird angenommen. Gibt es keine, weicht jede
eingereichte Auswahl von $K$ ab und wird abgewiesen -- der Vergleich lässt
keinen Spielraum.

\emph{Wie lange es dauert.} Höchstens $n$ Additionen und ein Vergleich (auf
langen Zahlen, deren Länge Teil der Eingabe ist): polynomiell. Also
$\problem{SubSet Sum} \in \NP$. Die Schwere steckt nicht im Nachrechnen, sondern
darin, unter $2^n$ Auswahlmöglichkeiten die richtige zu \emph{finden}.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$: Stellenwertsystem ohne Übertrag}
Nummeriere die Universums-Elemente $1$ bis $3m$ und gib jedem eine
\emph{Ziffernposition} in einem Stellensystem zur Basis $n+1$ ($n$ = Anzahl der
Mengen). Jede Menge $S_j$ wird zur Zahl mit Ziffer 1 an den Positionen ihrer
drei Elemente:
\[
c_j = \sum_{u_i \in S_j} (n+1)^{\,i-1}.
\]
Das Ziel $K$ ist die Zahl mit Ziffer 1 an \emph{allen} $3m$ Positionen.
\end{idee}

Der entscheidende Kunstgriff ist die Basiswahl. Addiert man beliebig viele der
$c_j$, dann sammeln sich an jeder Ziffernposition höchstens $n$ Einsen -- weniger
als die Basis $n+1$. Es entsteht also \emph{nie ein Übertrag}, und die Addition
wirkt an jeder Position unabhängig. \glqq Summe $= K$\grqq{} zerfällt dadurch in
$3m$ separate Bedingungen: \emph{jede} Position wird von \emph{genau einer}
gewählten Menge bedient. Das ist Wort für Wort die exakte Überdeckung. Bei Basis
2 wäre das falsch -- Überträge könnten Lücken und Doppelungen gegeneinander
verrechnen.

\begin{bsp}{Die Kodierung nachgerechnet}
$U = \{1,\dots,6\}$, also $m = 2$; Mengen $S_1 = \{1,2,3\}$, $S_2 = \{4,5,6\}$,
$S_3 = \{1,2,4\}$, $S_4 = \{3,5,6\}$; damit $n = 4$ und Basis 5.
\begin{center}\small
\begin{tabular}{lll}
\toprule
Menge & Positionen & Wert zur Basis 5\\
\midrule
$S_1$ & $1,2,3$ & $5^0 + 5^1 + 5^2 = 31$\\
$S_2$ & $4,5,6$ & $5^3 + 5^4 + 5^5 = 3875$\\
$S_3$ & $1,2,4$ & $5^0 + 5^1 + 5^3 = 131$\\
$S_4$ & $3,5,6$ & $5^2 + 5^4 + 5^5 = 3775$\\
\midrule
Ziel $K$ & $1,\dots,6$ & $5^0 + \dots + 5^5 = 3906$\\
\bottomrule
\end{tabular}
\end{center}
Probe: $31 + 3875 = 3906$ -- und $\{S_1, S_2\}$ überdeckt $U$ exakt. Genauso
$131 + 3775 = 3906$ mit der exakten Überdeckung $\{S_3, S_4\}$. Auswahlen, die
nicht exakt überdecken, verfehlen die Zielzahl.
\end{bsp}

Neben dieser Kette gibt es eine zweite, gezielt sparsame Härte-Quelle, die
direkt bei \problem{3-SAT} ansetzt. Sie wird in Teil C gebraucht.

\begin{idee}{$\problem{3-SAT} \redp \problem{SubSet Sum}$ (streng): Dezimalziffern}
Man spendiert jeder Variablen und jeder Klausel eine eigene Dezimalstelle --
die Zahlen haben $n + m$ Ziffern zur Basis 10. Für jede Variable $x_i$ gibt es
\emph{zwei} Zahlen: eine für \glqq wahr\grqq, eine für \glqq falsch\grqq. Beide
tragen an der Variablenstelle $i$ eine 1 -- das Ziel verlangt dort genau 1,
erzwingt also die Wahl \emph{einer} der beiden. An den Klauselstellen trägt die
\glqq wahr\grqq-Zahl Einsen bei den Klauseln, in denen $x_i$ positiv vorkommt,
die \glqq falsch\grqq-Zahl bei denen mit $\neg x_i$. Das Ziel verlangt an jeder
Klauselstelle eine 3; da eine erfüllte Klausel ein bis drei wahre Literale
liefert, gleichen \emph{zwei Ausgleichszahlen} pro Klausel (Wert 1 an genau
dieser Stelle) die Differenz aus. Erfüllbarkeit und Zielsumme entsprechen sich
exakt. Die Konstruktion erzeugt nur $2n + 2m$ Zahlen -- diese Sparsamkeit macht
sie für die unteren Schranken wertvoll.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: das Gleichgewicht erzwingen}
Zwei zusätzliche, geschickt dimensionierte Zahlen verwandeln \glqq triff
$K$\grqq{} in \glqq teile alles in zwei gleiche Hälften\grqq. Ausgeführt bei
Partition.
\end{idee}

\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: ein Spezialfall}
Setzt man im Rucksack Gewicht $=$ Profit und Kapazität $=$ Zielprofit $= K$,
kollabieren beide Rucksack-Bedingungen zu \glqq Summe exakt $K$\grqq. Ausgeführt
beim Knapsack.
\end{idee}

\begin{idee}{$\problem{SubSet Sum} \redp$ Kardinalitäts-Variante: Verschieben und Auffüllen}
Verlangt die Variante zusätzlich \glqq nimm genau $n$ Zahlen\grqq, erhöht man
jede Originalzahl um 1 und legt $n$ Füll-Einsen dazu; das Ziel wächst auf
$K + n$. Die Füllzahlen gleichen die Anzahl aus, ohne die Substanz der Summe zu
verändern.
\end{idee}

% ==================================================================
\section{Partition}
% ==================================================================

\begin{defn}{Partition}
Gegeben ganze Zahlen $c_1, \dots, c_n$. Gefragt: Kann man sie in zwei Gruppen
mit \emph{gleicher Summe} aufteilen -- gibt es also eine Auswahl, deren Summe
exakt die Hälfte der Gesamtsumme beträgt?
\end{defn}

\begin{bsp}{Ja-Instanz und Nein-Instanz}
Die Zahlen $1, 5, 6, 2$ haben Gesamtsumme 14, Hälfte 7. Die Auswahl $\{1, 6\}$
trifft die 7, der Rest $\{5, 2\}$ ebenso -- eine gültige Halbierung, Antwort
Ja. Anders die Zahlen $4, 7, 3, 2$: Gesamtsumme 16, Hälfte 8. Probiert man alle
Teilsummen durch, erreicht man 6, 7 und 9, aber nie genau 8 -- keine Halbierung
möglich, Antwort Nein.
\end{bsp}

\subsection*{Warum Partition in NP liegt}

\emph{Was das Zertifikat ist.} Die Auswahl einer Seite der Aufteilung -- pro
Zahl ein Bit.

\emph{Wie geprüft wird.} Der Verifizierer berechnet zweierlei: die Gesamtsumme
$N$ aller Zahlen und die Summe der ausgewählten. Er akzeptiert genau dann, wenn
die Auswahl-Summe exakt $N/2$ beträgt.

\emph{Warum das in beide Richtungen stimmt.} Lässt sich die Menge halbieren,
dann erreicht die passende Auswahl exakt $N/2$ und wird angenommen. Lässt sie
sich nicht halbieren, dann liegt jede Auswahl über oder unter $N/2$, und der
Vergleich weist sie ab.

\emph{Wie lange es dauert.} Zwei Summationen über $n$ Zahlen: $O(n)$
Arithmetikschritte. Also $\problem{Partition} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$: zwei Ausgleichsgewichte}
Gegeben Zahlen $c_1, \dots, c_n$ mit Ziel $K$. Setze $N = \bigl(\sum_j c_j\bigr)
+ 1$ und lege \emph{zwei neue Zahlen} dazu: $a = N - K$ und $b = K + 1$.
\end{idee}

Die Rechnung dahinter: Die erweiterte Menge hat die Gesamtsumme
$\sum_j c_j + (N-K) + (K+1) = (N-1) + N + 1 = 2N$; eine gültige Halbierung muss
also je Seite exakt $N$ erreichen. Nun das zentrale Detail: $a + b = N + 1 > N$
-- die beiden neuen Zahlen \emph{zusammen} sprengen jede Hälfte. In jeder
Halbierung liegen sie deshalb zwangsläufig auf \emph{verschiedenen} Seiten.
Betrachte die Seite mit $a = N - K$: Ihre übrigen Mitglieder sind Originalzahlen
und müssen zusammen $N - (N-K) = K$ ergeben -- eine Ziel-treffende Auswahl im
Sinne von SubSet Sum. Umgekehrt: Trifft eine Original-Auswahl $S$ das Ziel $K$,
dann bildet $S \cup \{a\}$ eine Seite mit Summe $K + (N-K) = N$ -- eine gültige
Halbierung. Ja- und Nein-Antworten stimmen also überein. Zwei Zahlen anhängen
kostet nichts; die Reduktion ist polynomiell, \problem{Partition}
NP-vollständig.

\begin{bsp}{Die Ausgleichsgewichte in Aktion}
Zahlen $3, 5, 8, 4$ (Summe 20), Ziel $K = 12$. Dann $N = 21$, und die neuen
Zahlen sind $a = 9$ und $b = 13$. Erweiterte Menge: $\{3,5,8,4,9,13\}$ mit
Gesamtsumme 42, Halbierungswert 21. Die Original-Auswahl $\{8,4\}$ trifft
$K = 12$; zusammen mit $a = 9$ entsteht die Seite $\{8,4,9\}$ mit Summe 21 --
die andere Seite $\{3,5,13\}$ hat ebenfalls 21. Es geht auf.
\end{bsp}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: Halbieren heißt Balancieren}
Deutet man die Zahlen als Job-Laufzeiten auf zwei Maschinen, dann heißt
\glqq beide Maschinen gleichzeitig fertig\grqq{} genau \glqq Zahlen
halbiert\grqq. Ausgeführt beim Scheduling.
\end{idee}

% ==================================================================
\section{Knapsack}
% ==================================================================

\begin{defn}{Knapsack (Rucksackproblem)}
Gegeben $n$ Gegenstände -- der $i$-te mit Gewicht $w_i$ und Profit $p_i$ --
sowie eine Tragkraft $B$ und ein Profitziel $P$. Gefragt: Gibt es eine Auswahl,
deren Gesamtgewicht höchstens $B$ und deren Gesamtprofit mindestens $P$ ist?
\end{defn}

\begin{bsp}{Packen mit zwei Bedingungen}
Gegenstände $(w, p)$: $(2, 3)$, $(3, 4)$, $(4, 6)$; Tragkraft $B = 6$, Ziel
$P = 9$. Die Auswahl $\{(2,3), (4,6)\}$ wiegt 6 und bringt Profit 9 -- beide
Bedingungen erfüllt, Antwort Ja. Die Auswahl aller drei wöge 9 und ist verboten.
\end{bsp}

\subsection*{Warum Knapsack in NP liegt}

\emph{Was das Zertifikat ist.} Die Packliste -- pro Gegenstand ein Bit.

\emph{Wie geprüft wird.} Der Verifizierer bildet zwei Summen über die
ausgewählten Gegenstände: das Gesamtgewicht und den Gesamtprofit. Er akzeptiert
genau dann, wenn das Gewicht $\le B$ \emph{und} der Profit $\ge P$ ist.

\emph{Warum das in beide Richtungen stimmt.} Eine zulässige, profitable Auswahl
besteht beide Vergleiche und wird angenommen. Existiert keine, dann reißt jede
Auswahl mindestens eine der beiden Schranken, und einer der Vergleiche schlägt
fehl.

\emph{Wie lange es dauert.} Zwei Summen, zwei Vergleiche: $O(n)$. Also
$\problem{Knapsack} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SubSet Sum} \redp \problem{Knapsack}$: beide Schranken zusammenziehen}
Aus der SubSet-Sum-Instanz $(c_1, \dots, c_n; K)$ macht man Gegenstände mit
$w_i = p_i = c_i$ und setzt $B = P = K$. Die Rucksackfrage verlangt nun eine
Auswahl mit Summe $\le K$ (Gewicht) \emph{und} Summe $\ge K$ (Profit) -- da
beide Summen identisch sind, geht das nur mit Summe \emph{exakt} $K$. Damit sind
die Ja-Instanzen beider Probleme dieselben, in beiden Richtungen. Die Umformung
ist ein einfacher Durchlauf. \problem{Knapsack} ist NP-vollständig.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

Keine weitere Reduktion geht vom Rucksack aus. Dafür ist er im
Approximationsteil das Vorzeigebeispiel für die ganze Palette: vom scheiternden
Greedy bis zum FPTAS.

% ==================================================================
\section{$P\|\Cmax$ (Scheduling)}
% ==================================================================

\begin{defn}{$P\|\Cmax$}
Gegeben $n$ Jobs mit Laufzeiten $p_1, \dots, p_n$ und $m$ baugleiche Maschinen.
Jeder Job läuft komplett auf einer Maschine. Der \emph{Makespan} eines Plans ist
die Fertigstellungszeit der am längsten laufenden Maschine. Optimierungsziel:
den Makespan minimieren; Entscheidungsfrage: Geht Makespan $\le T$?
\end{defn}

\begin{bsp}{Lasten verteilen}
Jobs $5, 4, 3, 2$ auf zwei Maschinen. Verteilt man $\{5, 2\}$ und $\{4, 3\}$,
sind beide Maschinen nach 7 Zeiteinheiten fertig -- Makespan 7. Schlechter wäre
$\{5, 4\}$ gegen $\{3, 2\}$: Makespan 9. Unter 7 geht es nicht, denn die
Gesamtarbeit 14 verteilt auf 2 Maschinen erzwingt mindestens 7.
\end{bsp}

\subsection*{Warum $P\|\Cmax$ in NP liegt}

\emph{Was das Zertifikat ist.} Der Plan -- für jeden Job die Nummer seiner
Maschine.

\emph{Wie geprüft wird.} Der Verifizierer summiert je Maschine die Laufzeiten
der dort eingeplanten Jobs, bestimmt das Maximum dieser Summen und vergleicht
es mit $T$. Liegt es darunter oder darauf, akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Ein Plan mit Makespan $\le T$
besteht den Vergleich. Existiert keiner, dann hat jeder eingereichte Plan eine
Maschine über $T$, und das Maximum verrät sie.

\emph{Wie lange es dauert.} Jeden Job einmal anfassen: $O(n)$. Also liegt die
Entscheidungsvariante von $P\|\Cmax$ in $\NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$: perfekte Balance}
Die Partition-Zahlen werden Jobs, die Maschinenzahl ist 2, und als
Makespan-Schranke wählt man $T = \frac12 \sum_j c_j$. Die Gesamtarbeit beider
Maschinen ist fix $\sum_j c_j$; ein Makespan von höchstens $T$ heißt also, dass
\emph{keine} Maschine über die Hälfte kommt -- und weil beide zusammen das Ganze
stemmen, tragen dann \emph{beide exakt} die Hälfte. Ein solcher Plan ist
wörtlich eine Halbierung der Zahlen, und jede Halbierung ist umgekehrt so ein
Plan. Damit ist das Scheduling bereits mit \emph{zwei} Maschinen NP-vollständig
-- mehr Maschinen machen es nicht leichter.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

Keine ausgehende Reduktion; im Approximationsteil liefert das Scheduling die
Bühne für List Scheduling und LPT.

% ==================================================================
\section{Hitting Set}
% ==================================================================

\begin{defn}{Hitting Set}
Gegeben ein Universum $U$, Mengen $F_1, \dots, F_r \subseteq U$ und eine Zahl
$k$. Eine Menge $H \subseteq U$ \glqq trifft\grqq{} $F_i$, wenn
$H \cap F_i \ne \emptyset$. Gefragt: Gibt es ein $H$ mit höchstens $k$
Elementen, das \emph{alle} $F_i$ trifft?
\end{defn}

\begin{analogie}
Die Mengen $F_i$ sind Kundenwünsche -- jeder Kunde nennt einige akzeptable
Produkte. Gesucht ist ein Sortiment aus höchstens $k$ Produkten, das
\emph{jeden} Kunden zufriedenstellt: Von jedem Wunschzettel muss mindestens ein
Produkt im Sortiment sein.
\end{analogie}

\begin{bsp}{Ein kleines Sortiment}
$U = \{1,2,3,4,5\}$; Wünsche $F_1 = \{1,2\}$, $F_2 = \{2,3\}$, $F_3 = \{4,5\}$.
Das Sortiment $\{2, 4\}$ trifft alle drei Wünsche -- Größe 2. Mit einem einzigen
Produkt geht es nicht, denn $F_1 \cup F_2$ und $F_3$ sind disjunkt.
\end{bsp}

\subsection*{Warum Hitting Set in NP liegt}

\emph{Was das Zertifikat ist.} Die Treffermenge $H$.

\emph{Wie geprüft wird.} Der Verifizierer zählt $|H|$ gegen $k$. Danach nimmt er
sich jede Menge $F_i$ vor und sucht ein gemeinsames Element mit $H$. Wird er bei
jeder fündig und stimmt die Größe, akzeptiert er; eine verfehlte Menge genügt
zur Ablehnung.

\emph{Warum das in beide Richtungen stimmt.} Ein echtes Hitting Set der Größe
$\le k$ übersteht alle Suchen. Existiert keines, lässt jede Menge $H$ dieser
Größe mindestens ein $F_i$ unberührt, und die Suche dort scheitert.

\emph{Wie lange es dauert.} Für jede der $r$ Mengen ein Abgleich mit $H$:
$O(r \cdot |U|)$. Also $\problem{Hitting Set} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{3-SAT} \redp \problem{Hitting Set}$: Belegung als Auswahl}
Das Universum besteht aus allen $2n$ Literalen. Es gibt zwei Sorten von Mengen:
Für jede Variable die \emph{Paarmenge} $\{x_i, \bar x_i\}$ und für jede Klausel
die Menge ihrer (höchstens drei) Literale. Die Schranke ist $k = n$. Die $n$
disjunkten Paarmengen zwingen jede Lösung, aus \emph{jedem} Paar mindestens ein
Literal zu nehmen -- bei Budget $n$ also \emph{genau} eines: Das ist eine
Belegung. Die Klauselmengen verlangen zusätzlich, dass diese Belegung in jeder
Klausel ein Literal trifft -- die Klausel also erfüllt. Ein Hitting Set der
Größe $n$ existiert demnach genau dann, wenn die Formel erfüllbar ist; beide
Richtungen stecken in dieser Entsprechung. Der Aufbau ist ein Durchlauf über die
Formel. \problem{Hitting Set} ist NP-vollständig.
\end{idee}

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: Seiten wechseln}
Elemente und Mengen tauschen die Plätze -- was vorher traf, überdeckt nachher.
Ausgeführt beim Set Cover.
\end{idee}

% ==================================================================
\section{Set Cover}
% ==================================================================

\begin{defn}{Set Cover}
Gegeben ein Universum $U$, Mengen $S_1, \dots, S_r \subseteq U$ und eine Zahl
$k$. Gefragt: Gibt es höchstens $k$ dieser Mengen, deren Vereinigung ganz $U$
ergibt?
\end{defn}

\begin{bsp}{Alles abdecken}
$U = \{1,2,3,4,5\}$; $S_1 = \{1,2,3\}$, $S_2 = \{3,4\}$, $S_3 = \{4,5\}$. Die
Wahl $\{S_1, S_3\}$ vereinigt sich zu $\{1,2,3,4,5\} = U$ -- ein Set Cover der
Größe 2.
\end{bsp}

\subsection*{Warum Set Cover in NP liegt}

\emph{Was das Zertifikat ist.} Die Liste der gewählten Mengen-Indizes.

\emph{Wie geprüft wird.} Der Verifizierer zählt die gewählten Mengen gegen $k$.
Dann markiert er alle Elemente, die in irgendeiner gewählten Menge vorkommen,
und kontrolliert, ob ganz $U$ markiert ist. Vollständig markiert und Anzahl im
Rahmen: Annahme.

\emph{Warum das in beide Richtungen stimmt.} Ein echtes Set Cover markiert
alles und wird angenommen. Gibt es keines mit $\le k$ Mengen, bleibt bei jeder
solchen Wahl ein Element unmarkiert -- Ablehnung.

\emph{Wie lange es dauert.} Markieren über alle gewählten Mengen:
$O(r \cdot |U|)$. Also $\problem{Set Cover} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{Hitting Set} \redp \problem{Set Cover}$: der Seitenwechsel}
Aus der Hitting-Set-Instanz (Universum $U$, Mengen $F_1, \dots, F_r$, Schranke
$k$) wird eine Set-Cover-Instanz mit \emph{vertauschten Rollen}: Das neue
Universum sind die Mengen-Nummern $\{1, \dots, r\}$; für jedes alte Element
$u \in U$ entsteht die neue Menge $D_u = \{\, i \mid u \in F_i \,\}$ -- die
Nummern aller alten Mengen, die $u$ enthalten. Die Schranke bleibt $k$.
\end{idee}

Die Entsprechung: Wählt man im Original die Treffermenge $H = \{u_1, \dots\}$,
dann überdecken die neuen Mengen $D_{u_1}, \dots$ genau die Nummern aller
$F_i$, die von $H$ getroffen werden. \glqq$H$ trifft alle $F_i$\grqq{} übersetzt
sich also in \glqq die gewählten $D_u$ überdecken alle Nummern\grqq{} -- ein Set
Cover derselben Größe. Und rückwärts genauso: Ein Set Cover aus $D$-Mengen
benennt eine gleich große Trefferauswahl. Beide Richtungen sind ein reiner
Blickwechsel. Bemerkenswert: Wendet man den Seitenwechsel zweimal an, steht die
ursprüngliche Instanz wieder da -- die Übersetzung ist ihre eigene Umkehrung.
Deshalb sind Hitting Set und Set Cover exakt gleich schwer.
\problem{Set Cover} ist NP-vollständig.

\subsection*{Wohin die Härte weiterfließt}

\begin{idee}{$\problem{Set Cover} \redp \problem{Hitting Set}$: derselbe Wechsel zurück}
Weil der Seitenwechsel seine eigene Umkehrung ist, funktioniert er wörtlich auch
von Set Cover nach Hitting Set: Neue Elemente sind die Set-Cover-Mengennummern,
neue Mengen entstehen pro Element $u$ als Nummernliste seiner Überdecker, $k$
bleibt. Die Antwort bleibt erhalten -- mit derselben Begründung wie eben, nur
mit vertauschten Namen. Im Kurs wird dieses Paar vor allem bei den unteren
Schranken in Teil C gebraucht.
\end{idee}

% ==================================================================
\section{Dominating Set}
% ==================================================================

\begin{defn}{Dominating Set}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Eine Menge $D \subseteq V$
\emph{dominiert} den Graphen, wenn jeder Knoten entweder selbst zu $D$ gehört
oder mit einem Knoten aus $D$ benachbart ist. Gefragt: Gibt es ein solches $D$
mit höchstens $k$ Knoten?
\end{defn}

\begin{analogie}
Denk an Funkmasten in Dörfern: Ein Mast versorgt sein eigenes Dorf und alle
direkt verbundenen Nachbardörfer. Ein Dominating Set ist ein Mastenplan, bei dem
jedes Dorf Empfang hat.
\end{analogie}

\begin{bsp}{Ein Mast genügt}
Ein sternförmiges Netz: Zentrum $z$, außen $a, b, c, d$, jede Außenstelle nur
mit $z$ verbunden. Der Plan $D = \{z\}$ dominiert alles -- $z$ versorgt sich
selbst und alle vier Nachbarn. Größe 1.
\end{bsp}

\subsection*{Warum Dominating Set in NP liegt}

\emph{Was das Zertifikat ist.} Die Auswahl $D$ -- ein Bit pro Knoten.

\emph{Wie geprüft wird.} Zwei Schritte. Erstens zählt der Verifizierer $|D|$
gegen $k$. Zweitens prüft er die Versorgung: Für jeden Knoten $v$ des Graphen
fragt er, ob $v \in D$ gilt -- und falls nicht, geht er die Nachbarn von $v$
durch (eine Zeile der Adjazenzmatrix) und sucht dort ein Mitglied von $D$.
Bleibt ein Knoten unversorgt, lehnt er ab; sonst akzeptiert er.

\emph{Warum das in beide Richtungen stimmt.} Ein dominierendes $D$ der Größe
$\le k$ lässt keinen Knoten unversorgt und besteht beide Schritte. Existiert
keines, hat jede Auswahl dieser Größe irgendwo einen unversorgten Knoten, und
die Versorgungsprüfung findet ihn.

\emph{Wie lange es dauert.} Pro Knoten eine Matrixzeile durchsehen: $O(|V|^2)$
insgesamt, dazu $O(|V|)$ fürs Zählen. Also $\problem{Dominating Set} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{zushang}
Für \problem{Dominating Set} enthält das Kursmaterial \emph{nur} den
NP-Zugehörigkeits-Nachweis -- er war eine Klausuraufgabe. Eine Härte-Reduktion
wird im Kurs nicht geführt. Das Problem ist in der Literatur als NP-vollständig
bekannt, aber der zugehörige Beweis gehört nicht zum gesicherten Stoff dieses
Kurses, und deshalb steht er auch nicht in diesem Heft.
\end{zushang}

% ==================================================================
\section{Longest Path}
% ==================================================================

\begin{defn}{Longest Path}
Gegeben ein Graph $G = (V,E)$ und eine Zahl $k$. Ein Pfad heißt \emph{einfach},
wenn er keinen Knoten wiederholt; seine Länge ist die Zahl seiner Kanten.
Gefragt: Enthält $G$ einen einfachen Pfad der Länge mindestens $k$?
\end{defn}

\begin{bsp}{Pfadlängen}
Im Kreis aus fünf Knoten $1 - 2 - 3 - 4 - 5 - 1$ ist $1,2,3,4,5$ ein einfacher
Pfad der Länge 4. Länger geht es nicht -- ein sechster Schritt müsste einen
besuchten Knoten wiederholen.
\end{bsp}

\subsection*{Warum Longest Path in NP liegt}

\emph{Was das Zertifikat ist.} Die Knotenfolge $(v_0, v_1, \dots, v_k)$ des
behaupteten Pfades.

\emph{Wie geprüft wird.} Der Verifizierer kontrolliert zweierlei: dass in der
Folge kein Knoten doppelt vorkommt (paarweise Vergleiche oder eine
Markierungstabelle), und dass jedes aufeinanderfolgende Paar $(v_i, v_{i+1})$
durch eine Kante verbunden ist (ein Nachschlag pro Schritt). Beides bestanden:
Annahme.

\emph{Warum das in beide Richtungen stimmt.} Hat der Graph einen einfachen Pfad
der Länge $\ge k$, dann bilden dessen erste $k+1$ Knoten ein Zertifikat, das
beide Kontrollen besteht. Und jede Folge, die beide Kontrollen besteht, ist
selbst ein einfacher Pfad der Länge $k$ -- der Graph hat dann einen. Kein
Vorschlag kann den Verifizierer täuschen.

\emph{Wie lange es dauert.} Verschiedenheit in $O(k^2)$, Kanten in $O(k)$:
zusammen $O(k^2) \subseteq O(|V|^2)$. Also $\problem{Longest Path} \in \NP$.

\subsection*{Woher die Härte kommt}

\begin{zushang}
Auch beim \problem{Longest Path} behandelt der Kurs ausschließlich die
NP-Zugehörigkeit -- ebenfalls als Klausuraufgabe. Eine Härte-Reduktion (etwa
über den Hamiltonpfad, den Longest Path verallgemeinert) kommt im Kursmaterial
nicht vor und wird hier deshalb nicht als Kursstoff ausgegeben.
\end{zushang}

% ==================================================================
\section{Das Halteproblem}
% ==================================================================

Der Katalog schließt mit einem Ausreißer -- einem Problem, das NP-schwer ist,
ohne in $\NP$ zu liegen. Es markiert die Außengrenze der bisherigen Begriffe.

\begin{defn}{Halteproblem}
Gegeben der Quelltext eines Programms $M$ und eine Eingabe $w$. Gefragt: Stoppt
$M$, wenn man es auf $w$ laufen lässt -- oder läuft es endlos?
\end{defn}

Turing hat bewiesen, dass \emph{kein} Algorithmus diese Frage für alle
Programme beantwortet -- das Halteproblem ist \emph{unentscheidbar}. Daraus
folgt sofort: Es liegt nicht in $\NP$. Denn jedes NP-Problem ist entscheidbar --
zur Not probiert man alle Zertifikate durch, die der Verifizierer innerhalb
seiner Laufzeitschranke überhaupt lesen kann; das dauert exponentiell lange,
terminiert aber.

\subsection*{Woher die Härte kommt}

\begin{idee}{$\problem{SAT} \redp \problem{Halteproblem}$: die Suchschleife}
Zu einer Formel $\varphi$ konstruiert man ein Programm $M_\varphi$ nach festem
Muster: Es zählt alle Belegungen der Variablen von $\varphi$ der Reihe nach auf,
testet jede, und \emph{stoppt}, sobald eine die Formel erfüllt -- findet es
keine, läuft die Schleife für immer weiter. Als Reduktionsausgabe dient das
Paar $\langle M_\varphi, \text{leere Eingabe} \rangle$.
\end{idee}

Die Antwort-Erhaltung: Ist $\varphi$ erfüllbar, erreicht die Schleife irgendwann
die erste erfüllende Belegung und $M_\varphi$ hält -- Ja bleibt Ja. Ist
$\varphi$ unerfüllbar, findet die Schleife nie einen Grund zu stoppen und läuft
ewig -- Nein bleibt Nein. Entscheidend ist die Trennung zweier Zeitbegriffe:
$M_\varphi$ selbst darf beliebig lange laufen, denn \emph{ausgeführt} wird es in
der Reduktion nie. Polynomiell sein muss nur das \emph{Aufschreiben} seines
Quelltexts aus $\varphi$ -- und der ist kaum mehr als die Formel plus eine
Schleifenschablone. Damit reduziert \problem{SAT} auf das Halteproblem, und das
Halteproblem ist NP-schwer.

\begin{aha}
Hier trennen sich die Begriffe sichtbar: Das Halteproblem ist NP-\emph{schwer},
aber mangels Entscheidbarkeit nicht in $\NP$ -- also nicht NP-\emph{vollständig}.
Die beiden Hälften der Vollständigkeit sind wirklich unabhängige Bedingungen,
und dieses Problem erfüllt nur eine davon.
\end{aha}

\subsection*{Wohin die Härte weiterfließt}

Nirgendwohin -- als unentscheidbares Problem ist das Halteproblem im Kurs die
Endstation.

% ##################################################################
\part*{Teil C -- Untere Schranken mit der ETH}
\addcontentsline{toc}{section}{\textbf{Teil C -- Untere Schranken mit der ETH}}
% ##################################################################

\noindent \glqq NP-vollständig\grqq{} bedeutet nur: vermutlich kein
Polynomialzeit-Algorithmus. Offen bleibt, \emph{wie langsam} es wirklich sein
muss -- $2^n$? $2^{\sqrt n}$? $n^{\log n}$? Die Exponentialzeit-Hypothese
verschärft die Annahme so weit, dass sich konkrete Untergrenzen ausrechnen
lassen.

% ==================================================================
\section{Das Handwerkszeug}
% ==================================================================

\subsection*{Echt langsamer wachsen: klein-o}

\begin{defn}{Klein-o-Notation}
$f(n) = o(g(n))$ bedeutet, dass der Quotient $f(n)/g(n)$ gegen null geht -- $f$
wird von $g$ auf lange Sicht beliebig weit abgehängt. Wichtig: Ein konstanter
Faktor rettet nichts, $\delta n$ ist \emph{nicht} $o(n)$.
\end{defn}

Ein Algorithmus mit Laufzeit $2^{o(n)}$ hat einen Exponenten, der langsamer als
jede Gerade wächst -- man nennt das \emph{subexponentiell}. $2^{\sqrt n}$ ist so
ein Fall: enorm schneller als $2^{n}$, aber immer noch weit von polynomiell
entfernt.

\subsection*{Die Hypothese selbst}

\begin{defn}{Exponentialzeit-Hypothese (ETH)}
Es existiert eine Konstante $\delta > 0$, sodass kein Algorithmus \problem{3-SAT}
mit $n$ Variablen in Zeit $2^{\delta n} \cdot \poly$ löst. Gleichwertig
formuliert: \problem{3-SAT} hat keinen $2^{o(n)}$-Algorithmus.
\end{defn}

Bewiesen ist die ETH nicht -- sie ist eine Arbeitshypothese, stärker als
$\Pclass \ne \NP$. Sie passt aber zum Forschungsstand: Trotz Jahrzehnten der
Suche liegen die besten 3-SAT-Löser bei $c^n$ mit $c$ knapp über $1{,}3$.

\subsection*{Von Variablen zu Klauseln: das Sparsification-Lemma}

\begin{satz}{Sparsification-Lemma}
Unter der ETH hat \problem{3-SAT} auch keinen Algorithmus mit Laufzeit
$2^{o(m)} \cdot \poly$, wobei $m$ die \emph{Klauselzahl} bezeichnet.
\end{satz}

\begin{intuition}
Wozu ein eigenes Lemma? Die ETH spricht von der \emph{Variablenzahl} $n$.
Reduktionen bemessen ihre Ausgabegröße aber meist an der \emph{Klauselzahl} $m$
-- und $m$ kann kubisch größer sein als $n$. Aus \glqq kein $2^{o(n)}$\grqq{}
folgt darum noch lange nicht \glqq kein $2^{o(m)}$\grqq. Das Lemma schließt
diese Lücke und macht die Klauselzahl zur gleichwertigen Härte-Währung. Als
Rückweg merkt man sich $n \le 3m$: Mehr Variablen als Literale kann es nicht
geben.
\end{intuition}

\subsection*{Das Argumentationsmuster}

\begin{idee}{Kontraposition mit Größenrechnung}
Jede ETH-Schranke folgt demselben Dreischritt.
\emph{Schritt 1:} Drücke die Zielgröße der Reduktion (Knotenzahl, Mengenzahl,
Parameter $k$, \dots) durch $n$ und $m$ aus.
\emph{Schritt 2:} Unterstelle einen zu schnellen Algorithmus für das
Zielproblem und rechne nach, welche 3-SAT-Laufzeit die Kette
\glqq Reduktion + Algorithmus\grqq{} ergäbe.
\emph{Schritt 3:} Stelle den Widerspruch fest -- zur ETH direkt, wenn die
Größe nur an $n$ hängt; zum Sparsification-Lemma, wenn sie an $m$ hängt.
\end{idee}

\begin{stolper}
Ob man das Sparsification-Lemma zitieren muss, entscheidet sich allein daran,
\emph{welche} Größe in Schritt 1 auftaucht. Nur $n$: die ETH genügt. Auch $m$
(oder $n + m$, was $O(m)$ ist): ohne das Lemma bricht der Schluss zusammen. Wer
es pauschal immer oder nie erwähnt, verliert Punkte.
\end{stolper}

Eine nützliche Ergänzung ist die \emph{Wurzel-Regel}: Wächst die Zielgröße
polynomiell, etwa $p = O(m^2)$, dann verbietet die Härte nur noch
$2^{o(\sqrt p)}$ -- allgemein $2^{o(\sqrt[c]{p})}$ bei $p = O(m^c)$. Denn erst
$\sqrt[c]{p}$ ist wieder von der Ordnung $m$.

% ==================================================================
\section{Die Schranken im Einzelnen}
% ==================================================================

Jetzt das Muster in Anwendung -- für jedes Problem gesondert.

\subsection*{Untere Schranke für Clique}

Die Reduktion von \problem{3-SAT} auf \problem{$k$-Clique} baut pro
Literalvorkommen einen Knoten: Bei höchstens drei Literalen je Klausel sind das
$|V| = O(m)$ Knoten, dazu $|E| = O(m^2)$ Kanten und die Zielgröße $k = m$.
Angenommen, \problem{Clique} hätte einen $2^{o(|V|)}$-Algorithmus. Wegen
$|V| = O(m)$ wäre die Kette aus Reduktion und Algorithmus ein
3-SAT-Verfahren mit Laufzeit $2^{o(m)} \cdot \poly$ -- das verbietet das
Sparsification-Lemma. Für die Kantenzahl greift die Wurzel-Regel: Aus
$|E| = O(m^2)$ folgt, dass kein $2^{o(\sqrt{|E|})}$-Algorithmus existiert. Und
da $k = m$ direkt die Klauselzahl ist, scheidet auch ein
$2^{o(k)}$-Algorithmus aus.

\subsection*{Untere Schranke für Independent Set}

Die Reduktion von \problem{Clique} auf \problem{Independent Set} ersetzt den
Graphen durch sein Komplement und behält $k$. Dabei bleibt die Knotenzahl
identisch, die Kantenzahl bleibt durch $O(|V|^2)$ beschränkt, und $k$ ändert
sich nicht. Ein $2^{o(|V|)}$-Algorithmus für \problem{Independent Set} wäre
darum -- nach Vorschalten der Komplementbildung -- ein
$2^{o(|V|)}$-Algorithmus für \problem{Clique}, den es nach dem vorigen
Abschnitt nicht gibt. Mit derselben Übertragung scheiden
$2^{o(\sqrt{|E|})}$- und $2^{o(k)}$-Algorithmen aus.

\subsection*{Untere Schranke für Vertex Cover}

Die Reduktion von \problem{Clique} auf \problem{Vertex Cover} nutzt ebenfalls
den Komplementgraphen, diesmal mit Schranke $k' = n - k$. Auch hier wächst
nichts: Knotenzahl gleich, Kantenzahl $O(|V|^2)$, und $k' \le |V|$. Ein zu
schneller VC-Algorithmus -- sei es in $|V|$, in $\sqrt{|E|}$ oder in $k'$ --
ließe sich also in einen gleich schnellen Clique-Algorithmus verwandeln, im
Widerspruch zur Clique-Schranke. \problem{Vertex Cover} hat somit dieselben
drei Untergrenzen.

\subsection*{Untere Schranken für Hitting Set}

Die Reduktion von \problem{3-SAT} liefert $|U| = 2n$ Elemente, $r = n + m$
Mengen und die Schranke $k = n$. Die drei Parameter verhalten sich
unterschiedlich -- genau deshalb ist dieses Problem das Lehrstück des Themas.

\emph{Erstens, die Universumsgröße.} Ein Algorithmus in $2^{o(|U|)}$ wäre wegen
$|U| = 2n$ einer in $2^{o(n)}$. Vorgeschaltet an die Reduktion entstünde ein
3-SAT-Löser in $2^{o(n)} \cdot \poly$ -- das widerspricht unmittelbar der ETH.
Das Sparsification-Lemma wird hier nicht angerührt, weil $m$ in der Rechnung
nirgends vorkommt.

\emph{Zweitens, die Mengenzahl.} Ein Algorithmus in $2^{o(r)}$ trifft auf
$r = n + m \le 3m + m = 4m$, ist also einer in $2^{o(m)}$. Die Kette ergäbe
einen 3-SAT-Löser in $2^{o(m)} \cdot \poly$ -- \emph{das} verbietet erst das
Sparsification-Lemma, denn die ETH allein sagt über $m$ nichts. Hier ist das
Zitat des Lemmas Pflicht.

\emph{Drittens, die Schranke $k$.} Ein Algorithmus in $2^{o(k)}$ ist wegen
$k = n$ einer in $2^{o(n)}$ -- derselbe unmittelbare ETH-Widerspruch wie beim
ersten Parameter, wieder ohne Lemma.

\subsection*{Untere Schranke für SubSet Sum und Partition}

Hier zahlt sich die strenge Dezimal-Reduktion aus dem Katalog aus: Sie erzeugt
aus einer 3-SAT-Formel nur $2n + 2m$ Zahlen, und mit $n \le 3m$ sind das
höchstens $8m = O(m)$ Stück. Hätte \problem{SubSet Sum} einen Algorithmus in
$2^{o(\#\text{Zahlen})}$, dann liefe die Kette in $2^{o(m)} \cdot \poly$ für
\problem{3-SAT} -- vom Sparsification-Lemma ausgeschlossen. \problem{SubSet Sum}
hat also keinen subexponentiellen Algorithmus in der Anzahl seiner Zahlen. Die
Reduktion auf \problem{Partition} fügt lediglich zwei weitere Zahlen hinzu und
verschiebt die Größenordnung nicht -- dieselbe Schranke gilt daher auch für
\problem{Partition}.

\subsection*{Untere Schranke für 3-Color}

Für das Färbungsproblem existiert eine eigens sparsame Konstruktion, die aus
einer 3-SAT-Formel einen Graphen mit nur $O(n + m)$ Knoten macht. Wegen
$n \le 3m$ ist das $O(m)$. Ein $2^{o(|V|)}$-Algorithmus für \problem{3-Color}
ergäbe darum einen $2^{o(m)}$-3-SAT-Löser -- Widerspruch zum
Sparsification-Lemma. Für die Kantenzahl ($O(m^2)$) schließt die Wurzel-Regel
zusätzlich jeden $2^{o(\sqrt{|E|})}$-Algorithmus aus.

\subsection*{Untere Schranke für Set Cover}

Der Seitenwechsel zwischen \problem{Hitting Set} und \problem{Set Cover}
vertauscht die Rollen der beiden Größen: Aus dem Universum wird die
Mengenliste und umgekehrt. Die Hitting-Set-Schranken wandern dadurch mit
vertauschten Parametern hinüber: \problem{Set Cover} hat weder in der
Universumsgröße noch in der Mengenzahl einen subexponentiellen Algorithmus --
bei der $m$-abhängigen Größe wieder mit dem Sparsification-Lemma als
Schlussstein.

% ##################################################################
\part*{Teil D -- Approximation}
\addcontentsline{toc}{section}{\textbf{Teil D -- Approximation}}
% ##################################################################

\noindent Wo exakte Lösungen (vermutlich) exponentiell teuer sind, verschiebt
man den Anspruch: schnell rechnen, dafür nur \emph{nahe} ans Optimum -- aber mit
beweisbarer Garantie, wie nahe. Für jeden Algorithmus dieses Teils steht hier
seine Garantie samt der Idee, warum sie hält.

% ==================================================================
\section{Was eine Güte-Garantie ist}
% ==================================================================

\begin{defn}{Multiplikative Güte}
Bezeichne $\OPT(I)$ den optimalen Wert der Instanz $I$. Ein Algorithmus $A$
\emph{garantiert die Güte} $\alpha$, wenn für jede Instanz gilt: beim
Minimieren $A(I) \le \alpha \cdot \OPT(I)$, beim Maximieren $\OPT(I) \le
\alpha \cdot A(I)$. \emph{Scharf} heißt die Garantie, wenn es Instanzen gibt,
die den Faktor beliebig genau ausreizen.
\end{defn}

\begin{intuition}
Eine Güte ist ein Versprechen über den \emph{schlechtesten} Fall. Güte 2 beim
Minimieren: Was auch immer kommt, meine Lösung kostet höchstens das Doppelte
des Bestmöglichen. Je näher an 1, desto besser das Versprechen.
\end{intuition}

Bei manchen Problemen kann man die Genauigkeit sogar frei wählen -- gegen
entsprechende Rechenzeit. Solche Familien von Algorithmen tragen je nach
Preis-Leistungs-Verhältnis einen von drei Namen; wir definieren sie
nacheinander.

\begin{defn}{PTAS}
Ein \emph{polynomielles Approximationsschema} ist eine Familie
$(A_\varepsilon)_{\varepsilon > 0}$ mit Güte $1 + \varepsilon$, deren Laufzeit
für jedes \emph{festgehaltene} $\varepsilon$ polynomiell in $n$ ist.
\end{defn}

Die Schwäche steckt im Kleingedruckten: $\varepsilon$ darf im Exponenten von
$n$ auftauchen. Eine Laufzeit wie $n^{1/\varepsilon}$ ist für jedes feste
$\varepsilon$ polynomiell -- aber schon bei $\varepsilon = 0{,}1$ steht dort
$n^{10}$.

\begin{defn}{EPTAS}
Ein \emph{effizientes} PTAS hat Laufzeiten der Form
$f(1/\varepsilon) \cdot \poly(n)$: Die Abhängigkeit von $\varepsilon$ ist aus
dem $n$-Exponenten herausgezogen und in einen eigenen Faktor verbannt.
\end{defn}

Der Faktor $f(1/\varepsilon)$ darf groß sein -- aber die Skalierung in der
Eingabegröße bleibt ein festes Polynom, egal wie genau man es haben will.

\begin{defn}{FPTAS}
Ein \emph{voll polynomielles} PTAS läuft polynomiell in $n$ \emph{und} in
$1/\varepsilon$ zugleich -- etwa in $O(n^3/\varepsilon)$. Mehr kann man von
einem Approximationsschema nicht verlangen.
\end{defn}

Dazu ein Nachbarbegriff, den man hier braucht: \emph{pseudopolynomiell} nennt
man Laufzeiten, die polynomiell in den \emph{Werten} der Eingabezahlen sind.
Wegen der Binärkodierung (Teil A) sind solche Werte exponentiell in der
Eingabe\emph{länge} -- pseudopolynomiell ist also gerade \emph{nicht}
polynomiell im strengen Sinn.

% ==================================================================
\section{TSP ohne Zusatzannahme: hoffnungslos}
% ==================================================================

\begin{satz}{Keine Güte fürs allgemeine TSP}
Gäbe es für das TSP mit beliebigen Distanzen einen Polynomialzeit-Algorithmus
mit irgendeiner festen Güte $\alpha$, dann wäre $\Pclass = \NP$.\\[0.3em]
\emph{Die Idee:} Man präpariert die HK-Reduktion mit einem Abgrund. Echte
Kanten kosten 1, fehlende aber nicht bloß $|V|+1$, sondern einen gigantischen
Betrag -- so groß, dass selbst das $\alpha$-Fache einer reinen Kanten-Tour
billiger bleibt als eine einzige Nicht-Kante. Ein $\alpha$-approximativer
Algorithmus müsste dann bei Graphen \emph{mit} Hamiltonkreis eine Tour
unterhalb des Abgrunds abliefern und bei Graphen \emph{ohne} zwangsläufig
darüber liegen -- an seiner Ausgabe ließe sich \problem{HK} exakt ablesen. Ein
NP-vollständiges Problem wäre in Polynomialzeit gelöst.
\end{satz}

Rettung bringt die \emph{Dreiecksungleichung} $d(i,j) \le d(i,k) + d(k,j)$ --
Umwege lohnen nie. Reale Distanzen erfüllen sie ohnehin. Unter dieser Annahme
(\glqq metrisches TSP\grqq) existieren gleich zwei gute Näherungsverfahren.

% ==================================================================
\section{$\Delta$TSP$_1$: Gerüst, Rundweg, Abkürzung}
% ==================================================================

\begin{idee}{Der Bauplan}
Drei Zutaten: Ein \emph{minimaler Spannbaum} verbindet alle Städte zum
kleinstmöglichen Preis. Das \emph{Verdoppeln} seiner Kanten macht jeden Grad
gerade, sodass ein \emph{Eulerkreis} existiert -- ein Rundweg über alle Kanten.
\emph{Abkürzen} verwandelt ihn in eine echte Tour, die jede Stadt nur einmal
anläuft.
\end{idee}

\noindent Wir verfolgen den Ablauf an einem festen Beispiel mit den Städten
$A, B, C, D, E$ und den Distanzen $d(A,E) = 1$, $d(B,C) = 1$, $d(A,C) = 2$,
$d(C,D) = 2$ (alle übrigen 2 oder 3).

\medskip
\noindent\textbf{Vorab -- die optimale Tour.} Zum späteren Vergleich: Die beste
Rundreise ist $[C,B,D,E,A,C]$ mit Länge 8. Der Algorithmus kennt sie nicht.
\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 $[C,B,D,E,A,C]$ -- Länge $8 = \OPT$}
\end{picture}
\end{center}

\noindent\textbf{Erster Schritt -- der Spannbaum.} Der billigste Baum durch
alle fünf Städte besteht aus $A$--$E$ (1), $B$--$C$ (1), $A$--$C$ (2) und
$C$--$D$ (2); er wiegt 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, Gewicht $6$}
\end{picture}
\end{center}

\begin{intuition}
Der Spannbaum ist der Anker der ganzen Analyse: Er kostet \emph{höchstens}
$\OPT$. Denn streicht man aus der optimalen Tour irgendeine Kante, entsteht ein
Gerüst, das alle Städte verbindet -- und der \emph{minimale} Spannbaum
unterbietet jedes solche Gerüst.
\end{intuition}

\noindent\textbf{Zweiter und dritter Schritt -- verdoppeln, Eulerkreis.} Jede
Baumkante wird zweifach gelegt; nun hat jede Stadt geraden Grad, und ein
Rundweg über sämtliche Kantenkopien existiert. Er wiegt $2 \cdot 6 = 12$, zum
Beispiel $[C,A,E,A,C,B,C,D,C]$ -- mit Wiederholungsbesuchen bei $A$ und $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.3pt}
\qbezier(0.5,2.2)(1.55,2.6)(2.6,3.0)\put(1.2,2.75){\small $\times2$}
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)\put(1.2,0.5){\small $\times2$}
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3)\put(1.3,1.9){\small $\times2$}
\put(2.6,1.3){\line(1,0){2.0}}\put(3.4,1.4){\small $\times2$}
\put(-0.3,-0.2){\small verdoppelt: Gewicht $12$, alle Grade gerade}
\end{picture}
\end{center}

\noindent\textbf{Vierter Schritt -- abkürzen.} Beim Ablaufen des Eulerkreises
überspringt man jede schon besuchte Stadt und fliegt direkt zur nächsten neuen.
Aus $[C,A,E,A,C,B,C,D,C]$ wird so die Tour $[C,A,E,B,D,C]$ der Länge 10.
\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.3,-0.2){\small Tour $[C,A,E,B,D,C]$ -- Länge $10 \le 2 \cdot 8$}
\end{picture}
\end{center}

\begin{satz}{$\Delta$TSP$_1$ garantiert Güte 2}
Drei Ungleichungen tragen den Beweis. \emph{Erstens} wiegt der Spannbaum
höchstens $\OPT$ (Tour minus Kante ist ein Gerüst). \emph{Zweitens} wiegt der
Eulerkreis exakt das Doppelte des Baums, also höchstens $2\,\OPT$.
\emph{Drittens} macht Abkürzen nichts teurer -- die Dreiecksungleichung
garantiert, dass der Direktflug zur nächsten neuen Stadt nie länger ist als der
Umweg über besuchte. Zusammen: Tourlänge $\le 2\,\OPT$. Im Beispiel: 10 bei
Optimum 8, Garantie wäre 16.
\end{satz}

\begin{intuition}
Die Garantie ist im Wesentlichen scharf: Es gibt sternförmige Instanzen mit
Optimum $n$, auf denen das Verfahren $2n - 2$ produziert -- für großes $n$
beliebig nah am Faktor 2.
\end{intuition}

% ==================================================================
\section{Christofides: das Matching statt der Verdopplung}
% ==================================================================

Das Verdoppeln \emph{aller} Kanten ist Verschwendung -- schuld an ungeraden
Graden sind nur \emph{manche} Knoten. Christofides repariert gezielt.

\begin{idee}{Gezielt reparieren}
Nur die Knoten mit ungeradem Grad im Spannbaum stören den Eulerkreis. Ihre
Anzahl ist immer gerade -- man kann sie also paaren. Christofides verbindet sie
durch das \emph{billigste perfekte Matching} und erhält so gerade Grade zum
halben Preis.
\end{idee}

\noindent\textbf{Erster Schritt -- Spannbaum wie gehabt.} Kanten $A$--$E$,
$B$--$C$, $A$--$C$, $C$--$D$; Gewicht 6.

\noindent\textbf{Zweiter Schritt -- die Störer finden.} Grade im Baum: $A$ hat
2, alle übrigen 1 oder 3 -- ungerade sind $B, C, D, E$ (im Bild 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 markiert: ungerade Grade $\{B,C,D,E\}$}
\end{picture}
\end{center}

\noindent\textbf{Dritter Schritt -- die Störer paaren.} Unter den möglichen
Paarungen von $\{B,C,D,E\}$ ist $\{B$--$C,\ D$--$E\}$ mit Kosten $1 + 2 = 3$
die billigste. Diese zwei Matchingkanten (dünn) kommen zum Baum -- jetzt sind
alle Grade gerade.
\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.4,-0.2){\small Matching $\{B$--$C, D$--$E\}$, Kosten $3$}
\end{picture}
\end{center}

\noindent\textbf{Vierter Schritt -- Eulerkreis und Abkürzung.} Aus Baum plus
Matching entsteht ein Eulerkreis; abgekürzt ergibt er die Tour
$[C,B,A,E,D,C]$ der Länge 9 -- einen Schritt näher am Optimum 8 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.0,-0.2){\small Tour $[C,B,A,E,D,C]$ -- Länge $9$}
\end{picture}
\end{center}

\begin{satz}{Christofides garantiert Güte $1{,}5$}
Die Tour kostet Baum plus Matching, also höchstens $\OPT + d(M)$. Der Kern ist
die Schranke $d(M) \le \OPT/2$: Läuft man die \emph{optimale} Tour ab und
notiert nur die ungerad-gradigen Knoten in Besuchsreihenfolge, so zerfallen
deren Verbindungsstücke in \emph{zwei} perfekte Paarungen -- die
\glqq geraden\grqq{} und die \glqq ungeraden\grqq{} Abschnitte im Wechsel. Dank
Dreiecksungleichung kosten beide zusammen höchstens $\OPT$; die billigere also
höchstens $\OPT/2$. Das \emph{minimale} Matching unterbietet auch diese. Ergebnis:
Tour $\le \OPT + \OPT/2 = 1{,}5\,\OPT$. Auch diese Schranke wird von
Beispielfamilien asymptotisch erreicht.
\end{satz}

\begin{stolper}
Zwei beliebte Fehler: Das Matching wird über den \emph{ungerad-gradigen
Baumknoten} gebildet -- nicht über allen Knoten. Und ohne Dreiecksungleichung
platzt der Abkürzungsschritt, genau wie bei $\Delta$TSP$_1$.
\end{stolper}

% ==================================================================
\section{Knapsack, Stufe 1: der pure Greedy}
% ==================================================================

Beim Optimier-Rucksack will man mit Tragkraft $B$ möglichst viel Profit
einpacken. Der erste Versuch liegt nahe.

\begin{idee}{Greedy nach Profitdichte}
Bewerte jeden Gegenstand mit seiner \emph{Dichte} $p_i / w_i$ -- Profit pro
Kilo. Sortiere absteigend danach und packe der Reihe nach ein, was noch in den
Rucksack passt.
\end{idee}

\begin{satz}{Greedy allein hat keine Güte-Garantie}
Für jede noch so große Zahl $\alpha$ gibt es Instanzen, auf denen Greedy um mehr
als den Faktor $\alpha$ am Optimum vorbeipackt.\\[0.3em]
\emph{Das Gegenbeispiel:} Zwei Gegenstände bei Tragkraft $B$ -- ein Krümel mit
Gewicht 1 und Profit 1 (Dichte 1) und ein Brocken mit Gewicht $B$ und Profit
$B - 1$ (Dichte knapp unter 1). Greedy greift zuerst zum dichteren Krümel;
danach passt der Brocken nicht mehr. Ergebnis: Profit 1 statt $B - 1$. Mit
wachsendem $B$ wird das Verhältnis beliebig schlecht -- der Fehler ist, dass
Dichte nichts über \emph{absolute} Profite sagt.
\end{satz}

% ==================================================================
\section{Knapsack, Stufe 2: Modified Greedy}
% ==================================================================

\begin{idee}{Zwei Kandidaten statt einem}
Berechne \emph{beides}: die Greedy-Packung \emph{und} den besten
Einzelgegenstand. Gib das profitablere von beiden aus.
\end{idee}

\begin{satz}{Modified Greedy garantiert Güte 2}
Der Schlüssel ist die \emph{gebrochene} Variante des Rucksacks, bei der man
Gegenstände auch anteilig einpacken darf. Ihr Optimum $\OPT_f$ ist mindestens so
groß wie das echte $\OPT$, und es hat eine einfache Gestalt: Greedy-Reihenfolge,
bis das erste Stück -- das \emph{Split-Item} -- nur noch teilweise hineinpasst.
Daraus liest man ab:
\[
\OPT \;\le\; \OPT_f \;\le\; \text{Greedy-Profit} + p_{\text{Split}}
\;\le\; \text{Greedy-Profit} + p_{\max}
\;\le\; 2 \cdot \max\{\text{Greedy}, p_{\max}\}.
\]
Der rechte Ausdruck ist genau das Doppelte der Modified-Greedy-Ausgabe. Der
Algorithmus verliert also höchstens den Profit \emph{eines} Gegenstands -- und
den sichert der zweite Kandidat ab.
\end{satz}

% ==================================================================
\section{Knapsack, Stufe 3: Sahni-Schema}
% ==================================================================

\begin{idee}{Kleine Vorauswahl raten, Rest gierig}
Für einen Parameter $k$: Probiere \emph{jede} Teilmenge von höchstens $k$
Gegenständen als festen Grundstock durch, fülle den Rest der Tragkraft mit
Greedy und behalte die beste aller so entstandenen Packungen.
\end{idee}

\begin{satz}{Sahni ist ein PTAS}
Die Güte beträgt $1 + 1/k$ bei Laufzeit $O(n^{k+1})$. Mit $k = 2$ erreicht man
Faktor $3/2$, mit $k = 3$ Faktor $4/3$ -- beliebig nah an 1, wenn man $k$
wachsen lässt. Der Preis: $k$ wandert in den Exponenten der Laufzeit. Genau das
Profil eines PTAS. (Modified Greedy steckt als Spezialfall $k = 1$ mit drin.)
\end{satz}

% ==================================================================
\section{Knapsack, Stufe 4: das FPTAS}
% ==================================================================

\begin{idee}{Profite vergröbern, dann exakt rechnen}
Es gibt ein exaktes Rucksack-Verfahren per dynamischer Programmierung, dessen
Laufzeit von der \emph{Größe der Profitwerte} abhängt -- pseudopolynomiell.
Skaliert man alle Profite um einen Faktor $K$ herunter (mit Abrunden), werden
die Werte klein und das exakte Verfahren schnell. Die Abrundung kostet
Genauigkeit -- aber kontrollierbar wenig.
\end{idee}

\begin{satz}{Das Skalierungsverfahren ist ein FPTAS}
Zwei Abschätzungen steuern den Fehler. Nach unten: Die auf den vergröberten
Profiten optimale Packung verliert gegenüber $\OPT$ höchstens $K$ pro
Gegenstand -- durch das Abrunden -- also insgesamt höchstens $K n$. Nach oben:
Ihre echte Profitsumme ist mindestens so groß wie ihr vergröberter Wert mal
$K$. Wählt man $K$ proportional zu $\varepsilon \, p_{\max} / n$, dann ist der
Verlust $Kn$ höchstens ein $\varepsilon$-Anteil von $p_{\max} \le \OPT$ -- Güte
$1 + \varepsilon$. Die Laufzeit des exakten Verfahrens auf den kleinen Werten
beträgt $O(n^3/\varepsilon)$: polynomiell in $n$ \emph{und} $1/\varepsilon$,
also ein FPTAS.
\end{satz}

% ==================================================================
\section{Scheduling, Regel 1: List Scheduling}
% ==================================================================

\begin{idee}{Immer zur leersten Maschine}
Nimm die Jobs in gegebener Reihenfolge und lege jeden auf die Maschine, die
gerade am wenigsten zu tun hat.
\end{idee}

Das Gantt-Bild zeigt die Schwäche: drei Jobs $1, 1, 2$ auf zwei Maschinen.
\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{besser}:}
\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}
Die beiden Einsen blockieren beide Maschinen, die späte Zwei stapelt sich
obendrauf. Wer die Zwei zuerst platziert, erreicht Makespan 2.

\begin{satz}{List Scheduling garantiert $2 - \frac1m$ -- scharf}
Betrachte die am Ende vollste Maschine und den \emph{letzten} Job $J_k$, der
dort landete. Im Moment seiner Zuteilung war diese Maschine die
\emph{leerste} -- alle $m$ Maschinen trugen damals also mindestens
\glqq Endlast minus $p_k$\grqq. Summiert ergibt das
$\sum_i p_i \ge m(\mathrm{LS} - p_k) + p_k$. Nun die beiden
\emph{Universalschranken} jedes Schedules: Das Optimum ist mindestens die
Durchschnittslast $\frac1m \sum_i p_i$, und mindestens so groß wie jeder
einzelne Job, insbesondere $p_k$. Beides eingesetzt liefert
$\mathrm{LS} \le (2 - \frac1m)\,\OPT$. Die Schranke wird erreicht: $m(m-1)$
Einser-Jobs, gefolgt von einem Job der Länge $m$, treiben List Scheduling auf
$2m - 1$ bei Optimum $m$.
\end{satz}

% ==================================================================
\section{Scheduling, Regel 2: LPT}
% ==================================================================

\begin{idee}{Die Großen zuerst}
Sortiere die Jobs absteigend nach Laufzeit und wende dann List Scheduling an.
Die dicken Brocken kommen so aufs leere Feld; die kleinen füllen am Ende nur
noch Lücken.
\end{idee}

\begin{satz}{LPT garantiert $\frac43 - \frac1{3m}$ -- scharf}
Der Beweis arbeitet mit einem \emph{kleinsten Gegenbeispiel}: einer Instanz mit
minimaler Jobzahl, die die Schranke verletzt. Dort muss der zuletzt platzierte
-- wegen der Sortierung kleinste -- Job den Makespan setzen; andernfalls ließe
er sich streichen und ein kleineres Gegenbeispiel bliebe übrig. Aus der
verletzten Schranke errechnet man, dass dieser kleinste Job länger als
$\OPT/3$ dauert. Dann aber passt in den \emph{optimalen} Plan höchstens ein
Job-Duo pro Maschine -- drei Jobs über $\OPT/3$ sprengten sie. Pläne mit
höchstens zwei Jobs pro Maschine lassen sich nun durch schrittweises
\emph{Tauschen} umsortieren: Je zwei Jobs wechseln so die Maschinen, dass die
Anordnung der LPT-Reihenfolge angeglichen wird, wobei bei nur zwei Jobs pro
Maschine kein Tausch die vollste Maschine voller macht. Am Ende steht der
LPT-Plan mit Optimal-Makespan -- das Gegenbeispiel widerspricht sich selbst,
also existiert keines.
\end{satz}

% ==================================================================
\section{Parallel-Task-Scheduling: Jobs, die mehrere Maschinen brauchen}
% ==================================================================

Eine Verallgemeinerung des Schedulings, die in neueren Klausuren auftaucht:
Jobs können mehrere Maschinen \emph{gleichzeitig} belegen.

\begin{defn}{Parallel-Task-Scheduling}
Gegeben $n$ Jobs und $m$ Maschinen. Jeder Job $j$ hat eine Ausführungszeit
$p_j$ und belegt während dieser Zeit \emph{gleichzeitig} $q_j \in [m]$
Maschinen. Gesucht ist ein Schedule ohne Überlappungen auf derselben Maschine
mit minimalem Makespan.
\end{defn}

Auch hier arbeitet ListScheduling: Es nimmt die Jobs der Reihe nach und
platziert jeden zum \emph{frühestmöglichen} Zeitpunkt auf den $q_j$ am
wenigsten belasteten Maschinen.

\begin{bsp}{ListScheduling mit Maschinenbedarf}
$m = 3$; Jobs als $(p_j, q_j)$: $(1,1)$, $(1,3)$, $(2,2)$, $(3,1)$. Die
Maschinenlasten $C$ entwickeln sich so: Job 1 startet bei 0 auf einer Maschine
-- $C = (1,0,0)$. Job 2 braucht alle drei Maschinen; die höchste Last ist 1,
also läuft er in $[1,2]$ -- $C = (2,2,2)$. Job 3 belegt zwei Maschinen ab
Zeit 2, läuft in $[2,4]$ -- $C = (4,4,2)$. Job 4 nimmt die leerste Maschine ab
Zeit 2, läuft in $[2,5]$ -- $C = (5,4,4)$. Makespan: 5.
\end{bsp}

Für den Sonderfall $q_j = 1$ ist das genau das klassische ListScheduling mit
seiner Güte $2 - \frac1m$. Interessant wird es, wenn alle Maschinenbedarfe in
einem festen Band liegen.

\begin{satz}{Güte im Band $\frac{m}{k+1} < q_j \le \frac{m}{k}$}
Liegen alle Bedarfe in diesem Band (für ein festes $k \ge 2$), so gilt
$\mathrm{LS}(I) \le \mathrm{OPT}(I) + \bigl(1 - \frac1k\bigr) p_{\max}
\le \bigl(2 - \frac1k\bigr)\mathrm{OPT}(I)$.\\[0.3em]
\emph{Die Idee:} Betrachte einen Job $j$, der den Makespan bestimmt, mit
Startzeit $s$. Zu jedem Zeitpunkt vor $s$ waren weniger als $q_j \le \frac mk$
Maschinen frei -- sonst hätte ListScheduling den Job früher platziert. Also
waren mehr als $\frac{(k-1)m}{k}$ Maschinen belegt. Da jeder Job höchstens
$\frac mk$ Maschinen belegt, liefen mindestens $k$ Jobs; da jeder \emph{mehr}
als $\frac{m}{k+1}$ belegt, passen keine $k+1$ nebeneinander -- es liefen also
stets \emph{genau} $k$ Jobs. Das ergibt $k \cdot s \le \sum_i p_i - p_j$. Im
Optimum laufen ebenfalls höchstens $k$ Jobs parallel, also
$\sum_i p_i \le k \cdot \mathrm{OPT}$. Zusammen folgt
$s \le \mathrm{OPT} - \frac1k p_j$ und damit
$\mathrm{LS} = s + p_j \le \mathrm{OPT} + (1 - \frac1k) p_j$.
\end{satz}

\begin{intuition}
Der wichtigste Spezialfall ist $k = 2$, also $\frac m3 < q_j \le \frac m2$:
Vor dem Start des entscheidenden Jobs laufen immer genau zwei Jobs, und es
folgt $\mathrm{LS} \le \mathrm{OPT} + \frac12 p_{\max}$. Das Argument ist eine
direkte Verallgemeinerung der beiden Universalschranken des klassischen
ListScheduling -- nur zählt man hier die \emph{parallel laufenden Jobs} statt
der Maschinen.
\end{intuition}

% ==================================================================
\section{Strip Packing: der NFDH-Algorithmus}
% ==================================================================

Ein Packungsproblem mit demselben Approximations-Geist: Rechtecke in einen
Streifen packen.

\begin{defn}{Strip Packing}
Gegeben eine Folge von Rechtecken $r_1, \dots, r_n$ mit Breiten
$w(r_i) \le 1$ und Höhen $h(r_i)$, absteigend nach Höhe sortiert
($h(r_i) \ge h(r_{i+1})$), sowie ein Streifen der Breite 1 mit unbeschränkter
Höhe. Gesucht ist eine überlappungsfreie Packung mit minimaler Gesamthöhe.
\end{defn}

\begin{idee}{NFDH (Next Fit Decreasing Height)}
NFDH packt \emph{stufenweise}: Die Rechtecke werden der Reihe nach
links-bündig auf die aktuelle Stufe gelegt. Passt eines nicht mehr in die
Breite, wird eine neue Stufe eröffnet -- auf Höhe des \emph{ersten} Rechtecks
der alten Stufe (das wegen der Sortierung das höchste ist).
\end{idee}

\begin{bsp}{NFDH gegen die optimale Packung}
Fünf Rechtecke der Höhe 1 mit Breiten $\frac12, \frac14, \frac12, \frac14,
\frac12$. NFDH links: Stufe 1 fasst $\frac12 + \frac14$; das nächste
$\frac12$ passt nicht mehr -- Stufe 2 mit $\frac12 + \frac14$; das letzte
$\frac12$ eröffnet Stufe 3. Höhe 3. Optimal rechts: $\frac12 + \frac12$ und
$\frac12 + \frac14 + \frac14$ -- Höhe 2.
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(11,3.6)(-0.4,-0.5)
% NFDH links (Streifenbreite 4cm = Breite 1)
\put(0.8,3.25){\small NFDH: Höhe 3}
\put(0,0){\framebox(2,1){\small $\frac12$}}\put(2,0){\framebox(1,1){\small $\frac14$}}
\put(0,1){\framebox(2,1){\small $\frac12$}}\put(2,1){\framebox(1,1){\small $\frac14$}}
\put(0,2){\framebox(2,1){\small $\frac12$}}
\put(0,-0.15){\line(1,0){4}}\put(4,-0.15){\line(0,1){3.3}}\put(0,-0.15){\line(0,1){3.3}}
% OPT rechts
\put(7.0,2.25){\small Optimal: Höhe 2}
\put(6.2,0){\framebox(2,1){\small $\frac12$}}\put(8.2,0){\framebox(2,1){\small $\frac12$}}
\put(6.2,1){\framebox(2,1){\small $\frac12$}}\put(8.2,1){\framebox(1,1){\small $\frac14$}}\put(9.2,1){\framebox(1,1){\small $\frac14$}}
\put(6.2,-0.15){\line(1,0){4}}\put(10.2,-0.15){\line(0,1){2.3}}\put(6.2,-0.15){\line(0,1){2.3}}
\end{picture}
\end{center}
Die Rate beträgt hier $\frac32$.
\end{bsp}

\begin{intuition}
\textbf{Der schlimmste Fall} treibt die Rate gegen 2: Nimm $2t$ Rechtecke der
Höhe 1 mit Breiten abwechselnd $1$ und $\varepsilon$. Bei NFDH füllt jedes
Breite-1-Rechteck seine Stufe komplett; jedes $\varepsilon$-Rechteck eröffnet
eine neue Stufe, auf die das nächste Breite-1-Rechteck nicht mehr passt --
$2t$ Stufen. Optimal packt man alle $\varepsilon$-Rechtecke zusammen auf eine
einzige Stufe: Höhe $t + 1$. Die Rate $\frac{2t}{t+1}$ geht gegen 2.
\end{intuition}

\begin{satz}{NFDH garantiert $2 \cdot \mathrm{OPT} + 1$ (für Höhen 1)}
Seien $W_1, \dots, W_S$ die belegten Breiten der NFDH-Stufen; die Packungshöhe
ist $S$.\\[0.3em]
\emph{Die Idee:} Für benachbarte Stufen gilt $W_i + W_{i+1} > 1$ -- denn das
erste Rechteck der Stufe $i+1$ passte nicht mehr auf Stufe $i$, und seine
Breite steckt in $W_{i+1}$. Summiert man diese Ungleichungen über
$i = 1, \dots, S-1$, steht links höchstens $2 \sum_i W_i$ und rechts $S - 1$:
\[
2 \sum_i W_i \;>\; S - 1 .
\]
Die Gesamtfläche der Rechtecke ist $\sum_i W_i$ (alle Höhen 1), und sie muss
in jede Packung der Breite 1 hineinpassen: $\mathrm{OPT} \ge \sum_i W_i$.
Also $2\,\mathrm{OPT} > S - 1$, das heißt
$\mathrm{NFDH} = S \le 2\,\mathrm{OPT} + 1$.
\end{satz}

\begin{intuition}
Für gemischte Höhen $h(r_i) \le 1$ bleibt die Schranke bestehen. Die Idee:
Die Stufenhöhen $H_1 \ge H_2 \ge \dots$ sind die Höhen der jeweils ersten
Rechtecke, und jedes Rechteck der Stufe $i$ ist mindestens $H_{i+1}$ hoch --
die Fläche der Stufe $i$ ist also mindestens $W_i \cdot H_{i+1}$. Zusammen mit
$W_i + W_{i+1} > 1$ ergibt sich $\sum_{i \ge 2} H_i \le 2 \cdot \text{Fläche}
\le 2\,\mathrm{OPT}$, und die erste Stufe steuert höchstens $H_1 \le 1$ bei:
wieder $\mathrm{NFDH} \le 2\,\mathrm{OPT} + 1$.
\end{intuition}

% ==================================================================
\section{MAX-3-SAT: zwei Versuche reichen für Güte 2}
% ==================================================================

\begin{idee}{Alles an, alles aus}
Gesucht ist eine Belegung, die möglichst viele Klauseln erfüllt. Der
Algorithmus testet nur zwei Kandidaten: die Belegung, die alle Variablen auf
wahr setzt, und die, die alle auf falsch setzt. Die bessere gewinnt.
\end{idee}

\begin{satz}{Der Zwei-Versuche-Algorithmus hat Güte 2}
Jede Klausel enthält mindestens ein Literal. Ein positives Literal wird von der
Alles-wahr-Belegung erfüllt, ein negatives von der Alles-falsch-Belegung --
folglich erfüllt \emph{jede} Klausel mindestens einen der beiden Kandidaten.
Zählt man zusammen, erfüllen beide Kandidaten gemeinsam mindestens $m$
Klauseln; der bessere allein also mindestens $m/2$. Mehr als $m$ kann auch das
Optimum nicht erfüllen, also liefert der Algorithmus mindestens die Hälfte des
Optimums. Scharf ist das auch: Ein Klauselpaar, von dem eines nur positive und
eines nur negative Literale enthält, ist gemeinsam erfüllbar ($\OPT = 2$),
aber jeder der beiden Kandidaten schafft nur eine der Klauseln.
\end{satz}

% ==================================================================
\section{Vertex Cover: die Beide-Endpunkte-Regel}
% ==================================================================

\begin{idee}{Kante schnappen, beide Enden nehmen}
Solange noch eine unbedeckte Kante existiert: Nimm \emph{beide} Endpunkte in
die Lösung und streiche alle dadurch bedeckten Kanten. Wiederhole.
\end{idee}

\begin{satz}{Die Regel garantiert Güte 2}
Nenne $A$ die Menge der geschnappten Kanten; die Ausgabe hat $2|A|$ Knoten.
Zwei geschnappte Kanten können keinen Endpunkt teilen -- sonst wäre die später
geschnappte beim Schnappen der früheren schon bedeckt gewesen. $A$ ist also ein
\emph{Matching}: lauter knotenfremde Kanten. Jedes Vertex Cover -- auch das
optimale -- muss jede dieser $|A|$ Kanten mit einem \emph{jeweils eigenen}
Knoten bedecken, braucht also mindestens $|A|$ Knoten. Die Ausgabe mit $2|A|$
Knoten ist demnach höchstens doppelt so groß wie das Optimum.
\end{satz}

\begin{intuition}
Damit sind alle drei Grundmuster der Güte-Beweise versammelt: das Optimum von
unten durch eine \emph{Struktur} abschätzen (hier: das Matching), ein
\emph{Zählargument} über komplementäre Kandidaten (MAX-3-SAT), und die
\emph{Universalschranken} Durchschnittslast und Maximaljob (Scheduling). Fast
jeder Güte-Beweis des Kurses ist eine Variation eines dieser drei.
\end{intuition}

% ==================================================================
\section{Schlusswort}
% ==================================================================

Damit liegt das ganze Fundament vor dir. Du kennst für jedes Problem des Kurses
die Definition, den NP-Nachweis, die Herkunft seiner Härte und ihre
Weitergabe. Du kannst untere Schranken aus der ETH herleiten und weißt bei
jedem Parameter, ob das Sparsification-Lemma gebraucht wird. Und du kennst die
Approximationsalgorithmen samt der Ideen hinter ihren Garantien.

\begin{aha}
Wenn du ein einziges Bild mitnimmst, dann dieses: Alles hängt an der
\emph{Reduktion}. Sie trägt die Härte von \problem{SAT} durch die gesamte
Landkarte, sie macht aus der ETH konkrete Zahlen, und ihr Scheitern beim
allgemeinen TSP zeigt, wo nicht einmal Näherung hilft. Wer Reduktionen lesen
und bauen kann, hat den Kurs verstanden.
\end{aha}

\noindent\textbf{Und jetzt?} Verständnis wird durch Anwendung zu Können. Nimm
dir die Präsenz-, Haus- und Klausuraufgaben vor und führe selbst aus, was hier
als Idee steht -- Reduktionen mit beiden Richtungen, Schranken-Herleitungen,
Worst-Case-Konstruktionen. Viel Erfolg dabei.

\end{document}
