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

\title{\textbf{\Huge Komplexität verstehen}\\[0.5em]
\large Das grafische Fundament zu \textit{Analyse von Algorithmen und Komplexität}\\[0.3em]
\normalsize CAU Kiel -- Sommersemester 2026 \quad$\cdot$\quad Ausgabe 3}
\author{}
\date{}

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

\begin{center}\itshape\large
Alles, was du brauchst, um den Kurs zu \emph{verstehen} --\\
mit Bildern, Beispielen und Fragen zum Selbstprüfen.
\end{center}

\vfill

\noindent\textbf{Wozu dieses Heft.}
Es baut dein \emph{Fundament}: Begriffe, Regeln, Probleme und ihre Zusammenhänge.
Danach kannst du den ganzen Stoff nachvollziehen -- und bist bereit, in
Präsenz-, Haus- und Klausuraufgaben selbst zu rechnen.

\medskip
\noindent\textbf{So arbeitest du damit (wichtig!).}
Am Ende jedes Kapitels stehen \textbf{Abruf-Fragen}. Beantworte sie
\emph{schriftlich aus dem Kopf}, \emph{bevor} du im Lösungsanhang
(Anhang~\ref{sec:loesungen}) nachsiehst. Dieses aktive Erinnern ist der
eigentliche Lerneffekt -- nur Lesen reicht nicht.

\medskip
\noindent\textbf{Die Kästen und ihre Rollen.}
\begin{center}\small
\begin{tabular}{ll}
\ding{72}~Intuition & die Idee in einfachen Worten\\
\ding{43}~Analogie & ein Bild aus dem Alltag\\
\ding{110}~Definition & die präzise Fassung\\
\ding{115}~Satz & ein Ergebnis mit Beweis\emph{idee}\\
\ding{108}~Beispiel & durchgerechnet, mit echten Zahlen\\
\ding{52}~Warum in NP? & Zertifikat und Prüfung des Problems\\
\ding{43}~Idee & die Konstruktion hinter einer Reduktion/einem Beweis\\
\ding{73}~Aha & die Pointe\\
\ding{55}~Stolperstein & der häufige Fehler\\
\ding{228}~Zusammenhang & wie es ins Ganze passt\\
\textbf{?}~Abruf & prüfe dich -- Lösung nur im Anhang\\
\end{tabular}
\end{center}

\vfill
\newpage
\tableofcontents
\newpage

% ##################################################################
\section{Ein Problem, das sich wehrt}
% ##################################################################

\begin{ziel}
Wir treffen ein Problem, das harmlos aussieht und trotzdem jeden Computer
überfordert. Daran verstehst du, warum es eine Theorie der \glqq schweren\grqq{}
Probleme gibt.
\end{ziel}

\subsection{Cliquen in einem Graphen}

Ein \emph{Graph} besteht aus \emph{Knoten} (Punkte) und \emph{Kanten}
(Verbindungen). Eine \emph{Clique} ist eine Gruppe von Knoten, in der
\emph{jeder mit jedem} verbunden ist. Das \emph{Cliquenproblem} fragt: Gibt es
eine Clique aus mindestens $k$ Knoten?

\begin{bsp}{Clique mit dem Auge}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(4,2.7)(-0.5,-0.4)
\put(0,1){\circle*{0.13}}\put(-0.45,1){\small $1$}
\put(1,2){\circle*{0.13}}\put(0.95,2.2){\small $2$}
\put(2,1){\circle*{0.13}}\put(2.2,1.05){\small $3$}
\put(1.4,0){\circle*{0.13}}\put(1.3,-0.42){\small $4$}
\put(3,0.5){\circle*{0.13}}\put(3.2,0.4){\small $5$}
\put(0,1){\line(1,1){1}}
\put(0,1){\line(1,0){2}}
\put(1,2){\line(1,-1){1}}
\put(2,1){\line(-3,-5){0.6}}
\put(2,1){\line(2,-1){1}}
\end{picture}
\end{center}
$\{1,2,3\}$ bildet ein Dreieck -- eine Clique der Größe 3. $\{2,3,4\}$ ist keine:
zwischen 2 und 4 fehlt die Kante. Eine 4er-Clique gibt es hier nicht.
\end{bsp}

\subsection{Warum der naive Weg explodiert}

Wie sucht ein Computer eine $k$-Clique? Naiv: \emph{alle} Knotengruppen der
Größe $k$ durchprobieren. Bei $n$ Knoten und $k = n/2$ sind das mindestens
$2^{n/2}$ Gruppen.

\begin{bsp}{Der Graben zwischen $n^3$ und $2^{n/2}$}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(8,4.4)(-0.6,-0.5)
\put(0,0){\vector(1,0){7.5}} \put(7.2,-0.45){\small Eingabegröße $n$}
\put(0,0){\vector(0,1){4}}   \put(-0.55,3.8){\small Zeit}
% polynomiell n^3 (flach ansteigend)
\qbezier(0,0)(4,0.4)(7,1.7)
\put(7.1,1.6){\small $n^3$ (polynomiell)}
% exponentiell 2^(n/2) (schnell steil)
\qbezier(0,0)(2.9,0.15)(3.7,4)
\put(3.4,4.05){\small $2^{n/2}$ (exponentiell)}
% "machbar"-Linie
\multiput(0,3)(0.3,0){12}{\line(1,0){0.15}}
\put(4.2,3.05){\small \itshape Grenze des Machbaren}
\end{picture}
\end{center}
Die polynomielle Kurve bleibt lange flach. Die exponentielle schießt fast
senkrecht nach oben und durchbricht früh jede Zeitgrenze.
\end{bsp}

\begin{bsp}{Dieselbe Kluft in Zahlen}
\begin{center}
\begin{tabular}{rrr}
\toprule
$n$ & $n^3$ & $2^{n/2}$\\
\midrule
$20$  & $8\,000$        & rund $1\,000$\\
$40$  & $64\,000$       & rund $1$ Million\\
$100$ & $10^6$          & rund $10^{15}$ (über ein Monat bei $10^9$/s)\\
$200$ & $8\cdot10^6$    & rund $10^{30}$ (länger als das Universum alt ist)\\
\bottomrule
\end{tabular}
\end{center}
\end{bsp}

\begin{intuition}
\emph{Exponentielles} Wachstum verdoppelt den Aufwand bei jedem zusätzlichen
Element. Ein doppelt so schneller Computer bringt dir dann genau \emph{einen}
Knoten mehr. Hardware kann exponentielles Wachstum niemals einholen. Genau das
macht ein Problem \glqq praktisch unlösbar\grqq.
\end{intuition}

\begin{satz}{Der naive Clique-Algorithmus ist exponentiell}
Für $k = |V|/2$ braucht er mindestens $2^{|V|/2}$ Schritte.\\
\emph{Beweisidee:} Es sind $\binom{n}{n/2} \ge 2^{n/2}$ Gruppen zu prüfen.
\end{satz}

\subsection{Die eigentliche Frage}

Vielleicht ist der naive Weg nur dumm und es gibt einen cleveren Trick? Für die
Clique kennt bis heute niemand einen -- aber niemand hat auch bewiesen, dass es
keinen gibt.

\begin{aha}
Die Komplexitätstheorie fragt nicht \glqq Wie löse ich das schnell?\grqq, sondern
\glqq Ist das \emph{überhaupt} schnell lösbar -- oder gehört es zu einer ganzen
Familie von Problemen, die gemeinsam scheitern?\grqq{} Diese zweite Frage können
wir beantworten, obwohl die erste offen ist.
\end{aha}

\begin{abruf}
\textbf{A1.} Warum hilft ein 1000-mal schnellerer Computer beim naiven
Clique-Algorithmus kaum?\\
\textbf{A2.} Was ist der Unterschied zwischen \glqq wir kennen keinen schnellen
Algorithmus\grqq{} und \glqq es gibt keinen\grqq -- und welchen der beiden Fälle
hat die Wissenschaft für die Clique bewiesen?
\end{abruf}

% ##################################################################
\section{Was heißt \glqq schnell\grqq?}
% ##################################################################

\begin{ziel}
Wir machen \glqq effizient\grqq{} präzise und lernen die Klasse $\Pclass$ kennen
-- die Probleme, die wir schnell lösen können.
\end{ziel}

\subsection{Laufzeit misst man in der Eingabegröße}

Ein Algorithmus ist schnell oder langsam stets \emph{relativ zur Eingabegröße}
$n$. Wir betrachten den \emph{schlechtesten Fall}: die maximale Schrittzahl über
alle Eingaben der Länge $n$.

\begin{defn}{Klasse P}
$\Pclass$ ist die Menge der Entscheidungsprobleme, die ein Algorithmus in
\emph{polynomieller} Zeit $O(n^d)$ (mit fester Zahl $d$) löst. Kurz: die
\emph{effizient lösbaren} Probleme.
\end{defn}

\begin{intuition}
\glqq Polynomiell = effizient\grqq{} ist eine Konvention, aber eine robuste:
Praktische polynomielle Algorithmen haben kleine Exponenten ($n$, $n^2$, $n^3$),
und die Grenze bleibt stabil, egal welchen realistischen Rechner man annimmt.
Der wahre Bruch verläuft zwischen polynomiell und exponentiell -- den hast du in
Kapitel 1 grafisch gesehen.
\end{intuition}

Beispiele in $\Pclass$: Sortieren, kürzeste Wege, minimale Spannbäume, Matching.

\subsection{Probleme als Ja/Nein-Fragen}

Die Theorie betrachtet \emph{Entscheidungsprobleme} -- Fragen mit Antwort Ja
oder Nein. Statt \glqq Wie groß ist die größte Clique?\grqq{} fragt man
\glqq Gibt es eine Clique mit $\ge k$ Knoten?\grqq

\begin{analogie}
Wie \glqq Ist das Paket schwerer als 5\,kg?\grqq{} statt \glqq Wie schwer genau?\grqq.
Beantwortest du die Ja/Nein-Frage für jede Schranke, kennst du am Ende auch den
genauen Wert -- du tastest ihn ein. Deshalb ist die Entscheidungsvariante
\glqq gleich schwer\grqq{} wie das Optimierungsproblem, aber leichter zu
vergleichen.
\end{analogie}

Formal kodiert man jede Eingabe als \emph{Wort} über einem Alphabet; ein Problem
wird zur Menge seiner Ja-Wörter (einer \emph{Sprache}). Merke dir schlicht:
\emph{ein Problem = die Menge seiner Ja-Eingaben}.

\begin{stolper}
\textbf{Zahlen sind binär kodiert.} Eine Zahl $K$ hat Eingabelänge nur
$O(\log K)$, ihr \emph{Wert} ist exponentiell größer. Ein Algorithmus, der bis
$K$ zählt, ist deshalb \emph{nicht} polynomiell. Daran hängt später die Schwere
von \problem{SubSet Sum} und der Begriff \glqq pseudopolynomiell\grqq.
\end{stolper}

\begin{abruf}
\textbf{A3.} Ist ein Algorithmus mit Laufzeit $n^4$ \glqq effizient\grqq{} im
Sinne der Theorie? Begründe.\\
\textbf{A4.} Warum ist \glqq zähle von 1 bis zur Eingabezahl $K$\grqq{} \emph{kein}
polynomieller Algorithmus, obwohl er so einfach aussieht?
\end{abruf}

% ##################################################################
\section{Prüfen ist leichter als Lösen}
% ##################################################################

\begin{ziel}
Wir entdecken die zentrale Beobachtung der Theorie -- Prüfen ist oft viel
leichter als Lösen -- und lernen daraus die Klasse $\NP$ sowie ein Rezept, mit
dem du für \emph{jedes} Problem zeigst, dass es in $\NP$ liegt.
\end{ziel}

\subsection{Die Sudoku-Beobachtung}

\begin{analogie}
Ein schweres Sudoku zu \emph{lösen} dauert. Eine \emph{fertige} Lösung zu
\emph{prüfen} geht in einer Minute: Zeilen, Spalten, Blöcke abhaken. Lösen ist
schwer, Prüfen ist leicht. Diese Asymmetrie \emph{ist} $\NP$.
\end{analogie}

Die vorgelegte Lösung heißt \emph{Zertifikat}, der Prüf-Algorithmus
\emph{Verifizierer}.

\begin{defn}{Verifizierer, Zertifikat, NP}
Ein \emph{Verifizierer} für ein Problem $L$ bekommt die Instanz $x$ und einen
Vorschlag $c$ und erfüllt
\[
x \in L \iff \text{es gibt ein } c \text{ mit } A(x,c) = 1.
\]
$c$ heißt \emph{Zertifikat}. $L \in \NP$, wenn es einen Verifizierer gibt, der
für jede Ja-Instanz ein \emph{polynomiell langes} Zertifikat in
\emph{polynomieller} Zeit prüft.
\end{defn}

\begin{intuition}
$\NP$ = effizient \emph{überprüfbar}, nicht effizient \emph{lösbar}. Das
Zertifikat ist die abgekürzte Antwort auf \glqq und woher weiß ich, dass das
stimmt?\grqq. Für Nein-Instanzen überzeugt \emph{kein} Vorschlag den
Verifizierer.
\end{intuition}

\subsection{Der NP-Dreischritt -- so zeigt man \glqq $\in \NP$\grqq}

Für \emph{jedes} Problem läuft der NP-Nachweis nach demselben Muster. Diesen
Dreischritt brauchst du im ganzen Kurs.

\begin{idee}{Nachweis \glqq $L \in \NP$\grqq}
\textbf{(1) Zertifikat:} Was ist die \glqq Lösung\grqq? (Teilmenge, Belegung,
Permutation.) Angeben, dass sie polynomiell lang ist.\\
\textbf{(2) Verifizierer:} Ein Algorithmus, der \emph{alle} geforderten
Eigenschaften prüft. Zwei Richtungen der Korrektheit: Ja-Instanz $\Rightarrow$
es gibt ein akzeptiertes Zertifikat; Nein-Instanz $\Rightarrow$ keines wird
akzeptiert. Laufzeit polynomiell.\\
\textbf{(3) Alternativ als Raten (NDTM):} \glqq Rate die Lösung, prüfe sie.\grqq{}
Die Rateschritte \emph{sind} das Zertifikat.
\end{idee}

\begin{bsp}{Der Dreischritt für Clique}
\textbf{Zertifikat:} eine Knotenmenge $C$ (ein Bit pro Knoten, also
polynomiell). \textbf{Verifizierer:} prüfe, ob alle Paare in $C$ verbunden sind
($O(|C|^2)$) und ob $|C| \ge k$ ($O(|V|)$). \textbf{Korrektheit:} Gibt es eine
$k$-Clique, wird sie akzeptiert; gibt es keine, scheitert jeder Vorschlag.
Laufzeit polynomiell -- also $\problem{Clique} \in \NP$.
\end{bsp}

\begin{intuition}
Die zweite Sicht (\glqq Raten\grqq) ist eine \emph{nichtdeterministische}
Maschine, die an jeder Verzweigung alle Wege gleichzeitig verfolgt. Sie
akzeptiert, wenn \emph{ein} Weg zum Ziel führt. Für eine Nein-Instanz führt
\emph{kein} Weg zum Ziel. \glqq Zertifikat bekommen\grqq{} und \glqq richtig
raten\grqq{} sind zwei Namen für dieselbe Sache.
\end{intuition}

\subsection{P steckt in NP -- und die Millionenfrage}

\begin{satz}{$\Pclass \subseteq \NP$}
Jedes effizient lösbare Problem ist auch effizient überprüfbar.\\
\emph{Beweisidee:} Wer selbst lösen kann, ignoriert das Zertifikat und rechnet
die Antwort direkt aus.
\end{satz}

Die offene Umkehrung lautet: Gilt $\Pclass = \NP$? Ist alles, was man schnell
\emph{prüfen} kann, auch schnell \emph{lösbar}?

\begin{aha}
Ob $\Pclass = \NP$, weiß niemand -- eines der sieben Millennium-Probleme
(1\,Mio.\ Dollar). Die meisten glauben $\Pclass \ne \NP$. \emph{Alles Folgende --
NP-Vollständigkeit, ETH, Approximation -- ist der Umgang mit dieser
Unwissenheit.}
\end{aha}

\begin{abruf}
\textbf{A5.} Nenne die drei Schritte des NP-Nachweises und wende sie auf
\problem{Vertex Cover} an (Zertifikat? Prüfung? Laufzeit?).\\
\textbf{A6.} Warum ist \glqq $L$ hat einen polynomiellen Verifizierer\grqq{} nicht
dasselbe wie \glqq $L$ ist in Polynomialzeit lösbar\grqq?
\end{abruf}

% ##################################################################
\section{\glqq Mindestens so schwer wie\grqq{} -- Reduktionen}
% ##################################################################

\begin{ziel}
Wir bauen das wichtigste Werkzeug der Theorie: die Reduktion. Mit ihr
vergleichst du Probleme nach Schwierigkeit, ohne für eines einen Algorithmus zu
kennen.
\end{ziel}

\subsection{Ein Problem mit einem anderen lösen}

\begin{analogie}
Du willst wissen, ob eine Strecke länger als 1 Meile ist, hast aber nur ein
km-Lineal. Du rechnest \glqq $>1$ Meile\grqq{} um in \glqq $>1{,}609$\,km\grqq{}
und misst. Die \emph{Umrechnung} ist billig, das \emph{Messen} erledigt das
fremde Werkzeug. Genau das ist eine Reduktion.
\end{analogie}

\begin{defn}{Polynomielle Reduktion $A \redp B$}
Eine Funktion $f$, die jede $A$-Eingabe $w$ in eine $B$-Eingabe $f(w)$
übersetzt, sodass
\[
w \in A \iff f(w) \in B,
\]
und die in polynomieller Zeit berechenbar ist. Schreibweise $A \redp B$.
\end{defn}

Der Datenfluss einer Reduktion, wenn man $A$ über einen $B$-Löser lösen will:

\begin{center}
\setlength{\unitlength}{1cm}
\begin{picture}(13,2)(0,-0.3)
\put(0,0.2){\framebox(2.4,1){\shortstack{$A$-Instanz\\ $w$}}}
\put(2.4,0.7){\vector(1,0){1.4}}
\put(2.5,0.9){\small $f$ (billig)}
\put(3.8,0.2){\framebox(2.6,1){\shortstack{$B$-Instanz\\ $f(w)$}}}
\put(6.4,0.7){\vector(1,0){1.4}}
\put(6.5,0.9){\small $B$-Löser}
\put(7.8,0.2){\framebox(2.2,1){\shortstack{Ja /\\ Nein}}}
\put(10.0,0.7){\vector(1,0){1.4}}
\put(10.05,0.9){\small ist Antwort}
\put(11.4,0.2){\framebox(1.4,1){für $w$}}
\end{picture}
\end{center}

\begin{intuition}
$A \redp B$ heißt: \glqq $B$ ist \emph{mindestens so schwer} wie $A$.\grqq{} Denn
ein schneller $B$-Löser ergibt (über $f$) auch einen schnellen $A$-Löser. Die
Schwierigkeit fließt \emph{entlang des Pfeils}: Ist $A$ schwer, muss $B$ es auch
sein.
\end{intuition}

\subsection{Die Richtung -- der teuerste Fehler}

\begin{stolper}
Um zu zeigen, dass ein \emph{neues} Problem $Y$ schwer ist, reduzierst du ein
\emph{bekannt schweres} $X$ \emph{auf} $Y$: also $X \redp Y$
(\glqq bekannt $\redp$ neu\grqq). Die Reduktion nimmt eine $X$-Instanz und baut
eine $Y$-Instanz. \textbf{Nie umgekehrt.} $Y \redp X$ würde nur zeigen, dass $Y$
\emph{höchstens} so schwer wie $X$ ist -- das sagt über $Y$ nichts.
\end{stolper}

\begin{analogie}
Willst du beweisen, dass ein neuer Boxer stark ist, schickst du den
\emph{amtierenden Champion} gegen ihn -- nicht einen Anfänger. \glqq Bekannt
stark $\redp$ neu.\grqq
\end{analogie}

\begin{satz}{Transitivität}
$A \redp B$ und $B \redp C$ $\Rightarrow$ $A \redp C$.\\
\emph{Beweisidee:} Umformungen hintereinander schalten; die Zwischenausgabe ist
polynomiell groß, also bleibt alles polynomiell.
\end{satz}

Deshalb kann eine ganze \emph{Kette} von Reduktionen die Schwere Glied für Glied
weitertragen -- das nutzen wir gleich.

\begin{abruf}
\textbf{A7.} Du weißt: \problem{Clique} ist schwer. Du willst zeigen, dass
\problem{Vertex Cover} schwer ist. In welche Richtung reduzierst du, und warum
genau so?\\
\textbf{A8.} Was bedeutet $A \redp B$ für die relative Schwierigkeit von $A$ und
$B$ -- in einem Satz?
\end{abruf}

% ##################################################################
\section{Die härtesten Probleme: NP-vollständig}
% ##################################################################

\begin{ziel}
Wir fassen die schwersten Probleme in $\NP$ mit einem Namen und sehen, warum
\emph{ein} schneller Algorithmus für eines von ihnen die ganze Landschaft zum
Einsturz brächte.
\end{ziel}

\begin{defn}{NP-schwer, NP-vollständig}
\begin{itemize}
\item $L_0$ ist \emph{NP-schwer}: \emph{jedes} $L \in \NP$ lässt sich auf $L_0$
reduzieren ($L \redp L_0$).
\item $L_0$ ist \emph{NP-vollständig}: NP-schwer \textbf{und} selbst in $\NP$.
\end{itemize}
\end{defn}

\begin{intuition}
Zwei Schranken:
\begin{itemize}
\item \emph{NP-schwer} = \textbf{untere} Schranke (\glqq mindestens so schwer wie
alles in $\NP$\grqq).
\item \emph{$\in \NP$} = \textbf{obere} Schranke (\glqq nicht schwerer als
$\NP$\grqq).
\end{itemize}
NP-vollständig = die schwersten Probleme \emph{innerhalb} von $\NP$.
\end{intuition}

\begin{stolper}
NP-schwer heißt \emph{nicht} \glqq in $\NP$\grqq. Es gibt NP-schwere Probleme
außerhalb von $\NP$ -- das Halteproblem (Kapitel~\ref{sec:halt}) ist nicht
einmal lösbar und trotzdem NP-schwer.
\end{stolper}

\begin{satz}{Ein schneller Algorithmus für eins löst alle}
Ist $L_0$ NP-vollständig, dann: $\Pclass = \NP \iff L_0 \in \Pclass$.\\
\emph{Beweisidee:} Läge $L_0$ in $\Pclass$, könnte man jedes $L \in \NP$ lösen:
erst $L \redp L_0$ rechnen, dann den schnellen $L_0$-Löser.
\end{satz}

\begin{aha}
Fände jemand für \emph{ein einziges} NP-vollständiges Problem einen
polynomiellen Algorithmus, wären \emph{schlagartig alle} NP-Probleme effizient
lösbar. Solange das niemandem gelingt, ist ein NP-Vollständigkeitsbeweis das
stärkste Indiz für \glqq vermutlich kein effizienter Algorithmus\grqq.
\end{aha}

\subsection{Der Anker: Cook--Levin}

\begin{satz}{Cook (1971), Levin (1973)}
\problem{SAT} ist NP-vollständig -- das \emph{erste} solche Problem.\\
\emph{Beweisidee:} Man nimmt ein \emph{beliebiges} $L \in \NP$ mit seiner
ratenden Maschine und gießt deren Rechnung in eine logische Formel. Variablen
beschreiben \glqq Zustand zur Zeit $t$\grqq, \glqq Bandinhalt\grqq{} usw. Die
Formel ist so gebaut, dass \emph{erfüllende Belegungen genau akzeptierenden
Rechenwegen entsprechen}. Also: $L$-Ja-Instanz $\iff$ Formel erfüllbar.
\end{satz}

\begin{idee}{Vererbungskorollar -- das Arbeitspferd}
Um ein neues Problem $Y$ als NP-vollständig zu zeigen, brauchst du nur zwei
Dinge:\\
\textbf{(1)} eine Reduktion $X \redp Y$ von \emph{einem} bekannten
NP-vollständigen $X$, und\\
\textbf{(2)} den Nachweis $Y \in \NP$ (NP-Dreischritt).\\
Dann ist $Y$ NP-vollständig -- denn $L \redp X \redp Y$ für alle $L \in \NP$.
\end{idee}

\subsection{Die Landkarte der Schwere}

Alle Probleme des Kurses hängen an \emph{einer} Kette ab \problem{SAT}. Der
Pfeil heißt \glqq wird reduziert auf\grqq{} (Schwere fließt nach unten).

\begin{center}
\setlength{\unitlength}{1cm}
\begin{picture}(13,8.7)(0,-0.3)
% Wurzel
\put(5.1,7.7){\framebox(2.4,0.7){\textbf{\problem{SAT}}}}
% Ebene 1
\put(6.3,7.7){\vector(-2,-1){2.6}} % zu 3-SAT
\put(6.3,7.7){\vector(0,-1){1.3}}  % zu Clique
\put(6.3,7.7){\vector(2,-1){2.6}}  % zu 3-DM
\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}}}
% Ebene 2
\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.6,3.7){\framebox(2.0,0.7){\problem{$k$-Color}}}
\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}}}
% Ebene 3
\put(3.6,3.7){\vector(0,-1){1.3}}
\put(6.3,3.7){\vector(0,-1){1.3}}
\put(9.0,3.7){\vector(0,-1){1.3}}
\put(2.2,1.7){\framebox(2.8,0.7){$\problem{HK}\to\problem{TSP}$}}
\put(5.1,1.7){\framebox(2.4,0.7){\problem{FVS}, $\Delta$-Cover}}
\put(8.0,1.7){\framebox(2.0,0.7){\problem{SubSetSum}}}
% Ebene 4
\put(9.0,1.7){\vector(0,-1){1.3}}
\put(6.8,0.0){\framebox(3.6,0.7){\problem{Partition}, \problem{Knapsack}, $P\|\Cmax$}}
\end{picture}
\end{center}

\begin{intuition}
Beim Lesen des nächsten Kapitels immer fragen: \glqq Von welchem Nachbarn erbt
dieses Problem seine Schwere?\grqq{} Die Probleme sind nicht einzeln schwer,
sondern \emph{gemeinsam} -- verbunden durch diese Pfeile.
\end{intuition}

\begin{abruf}
\textbf{A9.} Welche zwei Dinge musst du zeigen, um ein neues Problem als
NP-vollständig zu beweisen? Welchen davon vergisst man leicht?\\
\textbf{A10.} Warum wäre $\Pclass = \NP$, wenn jemand \problem{SubSet Sum} in
Polynomialzeit löste?
\end{abruf}

% ##################################################################
\section{Der Problem-Zoo}\label{sec:zoo}
% ##################################################################

\begin{ziel}
Wir gehen alle Probleme des Kurses durch. Zu jedem: was es fragt, \emph{warum es
in $\NP$ liegt} (Zertifikat), \emph{woher} seine Schwere kommt und die
\emph{Idee} der Reduktion -- oft als Bild.
\end{ziel}

\noindent So liest du jeden Eintrag: \textbf{Definition} (was gefragt ist)
$\to$ \textbf{Warum in NP?} (Zertifikat) $\to$ \textbf{Idee} (woher die Schwere,
wie die Reduktion baut). Alle diese Probleme sind NP-vollständig.

\subsection{Logik: SAT und 3-SAT}

\begin{defn}{SAT und 3-SAT}
\problem{SAT}: Formel in konjunktiver Normalform (UND von Klauseln, jede Klausel
ein ODER von Literalen $x_j$/$\neg x_j$) -- gibt es eine erfüllende Belegung?\\
\problem{3-SAT}: dasselbe mit höchstens 3 Literalen pro Klausel.
\end{defn}

\begin{zert}
\textbf{Zertifikat:} die Belegung $\psi$ (ein Bit pro Variable).
\textbf{Prüfung:} Formel unter $\psi$ auswerten -- linear in der Formellänge.
\end{zert}

\begin{idee}{$\problem{SAT} \redp \problem{3-SAT}$ -- lange Klauseln aufspalten}
Ersetze eine lange Klausel per Hilfsvariablen durch eine \emph{Kette} von
3er-Klauseln, z.\,B.
$(y_1 \vee \dots \vee y_n) \leadsto
(y_1 \vee y_2 \vee x_1)\wedge(\neg x_1 \vee y_3 \vee x_2)\wedge\dots$
Ist ein $y_i$ wahr, lässt sich die $x$-Kette passend setzen; ist \emph{keines}
wahr, erzwingt die Kette einen Widerspruch. Erfüllbarkeit bleibt gleich.
\end{idee}

\subsection{Graphen: das Dualitätsdreieck}

Drei Probleme, die im Grunde eines sind -- aus drei Blickwinkeln.

\begin{defn}{Clique, Independent Set (IS), Vertex Cover (VC)}
Gegeben $G$ und $k$.
\problem{Clique}: Gruppe, in der \emph{alle} paarweise verbunden sind, Größe
$\ge k$?
\problem{IS}: Gruppe, in der \emph{keine} zwei verbunden sind, Größe $\ge k$?
\problem{VC}: Knotenmenge, die \emph{jede} Kante berührt, Größe $\le k$?
\end{defn}

\begin{zert}
\textbf{Clique/IS:} Zertifikat ist die Gruppe; prüfe alle Paare ($O(|V|^2)$) und
die Größe. \textbf{VC:} Zertifikat ist die Knotenmenge; prüfe für jede Kante,
ob ein Endpunkt drin liegt ($O(|E|)$), und die Größe.
\end{zert}

\begin{aha}
\textbf{Ein Bild, drei Rollen.} In $G$ mit $n$ Knoten:
\[
C \text{ Clique in } G \iff C \text{ IS in } \bar G \iff
V\setminus C \text{ VC in } \bar G.
\]
Links dieselbe Knotenmenge $\{1,2,3\}$ in $G$ (Clique) und rechts im
Komplement $\bar G$ (Independent Set); der Rest $\{4\}$ ist dort ein Vertex
Cover.
\end{aha}

\begin{bsp}{Das Dreieck sichtbar}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(11,2.8)(0,-0.4)
% ---- G links ----
\put(0.6,2.2){\small $G$: $\{1,2,3\}$ ist Clique}
\put(1,0){\circle*{0.13}}\put(0.7,-0.05){\small $1$}
\put(1,1.6){\circle*{0.13}}\put(0.6,1.55){\small $2$}
\put(2.4,0.8){\circle*{0.13}}\put(2.55,0.75){\small $3$}
\put(3.6,0.8){\circle*{0.13}}\put(3.75,0.75){\small $4$}
\put(1,0){\line(0,1){1.6}}          % 1-2
\qbezier(1,0)(1.7,0.4)(2.4,0.8)     % 1-3
\qbezier(1,1.6)(1.7,1.2)(2.4,0.8)   % 2-3
% ---- Gbar rechts ----
\put(6.3,2.2){\small $\bar G$: $\{1,2,3\}$ IS, $\{4\}$ VC}
\put(6.6,0){\circle*{0.13}}\put(6.3,-0.05){\small $1$}
\put(6.6,1.6){\circle*{0.13}}\put(6.2,1.55){\small $2$}
\put(8.0,0.8){\circle*{0.13}}\put(7.7,0.95){\small $3$}
\put(9.4,0.8){\circle*{0.13}}\put(9.55,0.75){\small $4$}
\qbezier(6.6,0)(8.0,0.4)(9.4,0.8)     % 1-4
\qbezier(6.6,1.6)(8.0,1.2)(9.4,0.8)   % 2-4
\put(8.0,0.8){\line(1,0){1.4}}        % 3-4
\end{picture}
\end{center}
In $\bar G$ sind genau die früheren Nicht-Kanten vorhanden. $\{1,2,3\}$ hat dort
keine innere Kante (IS), und Knoten 4 allein berührt alle Kanten (VC).
\end{bsp}

\begin{idee}{$\problem{SAT} \redp \problem{Clique}$ -- ein Knoten pro Literal}
Baue für jedes Literalvorkommen einen Knoten $[i,j]$. Verbinde zwei Knoten
genau dann, wenn sie aus \emph{verschiedenen} Klauseln stammen und sich
\emph{nicht widersprechen}. Suche eine Clique der Größe $k = m$ (Anzahl
Klauseln). Eine solche Clique wählt aus jeder Klausel ein widerspruchsfreies
wahres Literal -- also eine erfüllende Belegung.
\end{idee}

\begin{bsp}{$\problem{SAT} \redp \problem{Clique}$ -- die Lösungs-Clique}
$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)$,
$m=3$. Acht Knoten in drei Klausel-Spalten; fett die Clique
$\{[1,1],[2,2],[3,1]\}$ ($x_1,\neg x_2,x_1$).
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(10,3.4)(-0.5,-0.3)
% Spalte 1 (x=0.5)
\put(0.5,2.6){\circle*{0.16}}\put(-0.55,2.55){\small $[1,1]\,x_1$}
\put(0.5,1.5){\circle{0.16}}\put(-0.05,1.4){\small $x_2$}
\put(0.5,0.5){\circle{0.16}}\put(-0.05,0.4){\small $x_3$}
\put(1.1,3.1){\small Klausel 1}
% Spalte 2 (x=4.5)
\put(4.5,2.6){\circle{0.16}}\put(4.7,2.55){\small $\neg x_1$}
\put(4.5,1.5){\circle*{0.16}}\put(4.7,1.45){\small $[2,2]\,\neg x_2$}
\put(4.0,3.1){\small Klausel 2}
% Spalte 3 (x=8.5)
\put(8.5,2.6){\circle*{0.16}}\put(7.2,2.55){\small $x_1\,[3,1]$}
\put(8.5,1.5){\circle{0.16}}\put(8.7,1.45){\small $\neg x_2$}
\put(8.5,0.5){\circle{0.16}}\put(8.7,0.4){\small $\neg x_3$}
\put(7.6,3.1){\small Klausel 3}
% Clique-Kanten (fett): [1,1]-[2,2], [2,2]-[3,1], [1,1]-[3,1]
\linethickness{1.2pt}
\put(0.5,2.6){\line(4,-1){4}}   % [1,1]-[2,2]
\put(4.5,1.5){\line(4,1){4}}    % [2,2]-[3,1]
\put(0.5,2.6){\line(1,0){8}}    % [1,1]-[3,1]
\end{picture}
\end{center}
Die drei fetten Kanten bilden das Dreieck (die 3-Clique). Sie liefert
$x_1=\true,\ x_2=\false$ -- und das erfüllt $F$.
\end{bsp}

\begin{idee}{$\problem{Clique} \redp \problem{VC}$ und $\redp \problem{IS}$}
Reine Umformung (das Dualitätsdreieck): für IS gib $(\bar G, k)$ aus, für VC
gib $(\bar G, n-k)$ aus. Kein Gadget nötig.
\end{idee}

\subsection{Färbung, Hamiltonkreis, TSP}

\begin{defn}{$k$-Color, Hamiltonkreis (HK), TSP}
\problem{$k$-Color}: Knoten mit $k$ Farben färben, sodass keine Kante gleiche
Enden hat?\\
\problem{HK}: Rundweg, der jeden Knoten genau einmal besucht?\\
\problem{TSP} (Entscheidung): Rundreise durch alle Städte mit Länge $\le L$?
\end{defn}

\begin{zert}
\textbf{Color:} die Färbung $f$; prüfe jede Kante ($O(|E|)$).
\textbf{HK:} die Knoten-Reihenfolge (Permutation); prüfe, ob jede Folgekante
existiert und jeder Knoten einmal vorkommt.
\textbf{TSP:} die Reihenfolge; addiere die Distanzen und vergleiche mit $L$.
\end{zert}

\begin{idee}{Woher ihre Schwere kommt}
\problem{$k$-Color} erbt von \problem{3-SAT} (Gadget mit $n{+}1$ Farben, das
jede Variable auf wahr/falsch zwingt). \problem{HK} erbt von der
3-Literal-Variante $\problem{3-SAT}'$ (A-Komponenten kodieren die
Variablensetzung, B-Komponenten prüfen die Klauseln). \problem{TSP} erbt von
\problem{HK}: echte Kanten Distanz 1, fehlende Kanten sehr groß, $L = |V|$ --
eine kurze Tour \emph{ist} ein Hamiltonkreis.
\end{idee}

\begin{idee}{$\problem{VC} \redp \problem{FVS}$ -- ungerichtet wird gerichtet}
\problem{Feedback Vertex Set}: entferne $\le k$ Knoten, sodass ein
\emph{gerichteter} Graph kreisfrei wird. Reduktion: mache aus jeder
ungerichteten Kante \emph{zwei antiparallele Bögen} (einen 2-Kreis). Ein
Knoten, der die Kante \glqq überdeckt\grqq{}, zerstört genau diesen Kreis.
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(8,1.4)(0,-0.3)
\put(0.6,0.4){\circle*{0.13}}\put(0.3,0.55){\small $u$}
\put(2.6,0.4){\circle*{0.13}}\put(2.8,0.55){\small $v$}
\put(0.6,0.4){\line(1,0){2}}
\put(1.4,-0.15){\small ungerichtet}
\put(4.0,0.7){\vector(1,0){2}}
\put(6.0,0.1){\vector(-1,0){2}}
\put(4.5,0.75){\circle*{0.13}}\put(4.2,0.9){\small $u$}
\put(6.0,0.1){\circle*{0.001}}
\put(6.05,0.55){\circle*{0.13}}\put(6.2,0.6){\small $v$}
\put(4.3,-0.2){\small zwei antiparallele Bögen}
\end{picture}
\end{center}
\end{idee}

\subsection{Mengen und Zahlen}

\begin{defn}{3-DM, 3-EC, SubSet Sum, Partition, Knapsack}
\problem{3-DM}: drei gleich große Mengen, Tripel; wähle Tripel, die jedes
Element genau einmal treffen.
\problem{3-EC}: 3-elementige Mengen; wähle einige, die das Universum exakt
(disjunkt) überdecken.
\problem{SubSet Sum}: Zahlen und Ziel $K$; Teilmenge mit Summe genau $K$?
\problem{Partition}: Teilmenge mit genau der halben Gesamtsumme?
\problem{Knapsack}: Auswahl mit Gewicht $\le B$ und Profit $\ge P$?
\end{defn}

\begin{zert}
Für alle: das Zertifikat ist die \emph{Auswahl} (Tripelmenge, Mengenauswahl,
Teilmenge). Prüfung: Summen bzw. Überdeckungsbedingungen nachrechnen und
Schranken vergleichen -- alles in $O(n)$ bis $O(n^2)$.
\end{zert}

\begin{idee}{$\problem{3-EC} \redp \problem{SubSet Sum}$ -- Mengen werden Ziffern}
Schreibe jede 3-elementige Menge als Bitvektor über dem Universum und lies ihn
als \emph{Zahl zur Basis $n+1$}. Beispiel $U=\{u_1,\dots,u_6\}$:
\begin{center}\small
\begin{tabular}{lcl}
\toprule
Menge & Bitvektor & Zahl (Basis $n{+}1$)\\
\midrule
$\{u_1,u_5,u_6\}$ & $100011$ & $(n{+}1)^0+(n{+}1)^4+(n{+}1)^5$\\
Ziel $K$ & $111111$ & $\sum_{i=0}^{5}(n{+}1)^i$\\
\bottomrule
\end{tabular}
\end{center}
Bei Basis $n+1$ und $\le n$ Summanden gibt es \emph{keinen Übertrag}. Die
Zielsumme wird genau dann getroffen, wenn jede Stelle exakt einmal überdeckt
ist -- eine exakte Überdeckung.
\end{idee}

\begin{idee}{$\problem{SubSet Sum} \redp \problem{Partition}$ -- zwei Zusatzzahlen}
Aus $(c_1,\dots,c_n,K)$ mit $N=\sum c_j+1$ ergänze $c_{n+1}=N-K$ und
$c_{n+2}=K+1$. Gesamtsumme $2N$, Hälfte $N$. Die beiden Zusatzzahlen summieren
zu $N+1$, können also nie zusammen in \emph{eine} Hälfte -- eine Halbierung
existiert genau dann, wenn eine Original-Teilmenge $K$ trifft.
\end{idee}

\begin{zushang}
\problem{Knapsack} enthält \problem{SubSet Sum} als Spezialfall
($w_j=p_j$, $P=B$) -- deshalb auch schwer. Und \problem{Partition} reduziert
weiter auf Scheduling (nächster Abschnitt).
\end{zushang}

\subsection{Scheduling: $P\|\Cmax$}

\begin{defn}{$P\|\Cmax$}
$n$ Jobs mit Laufzeiten $p_j$, $m$ identische Maschinen. Verteile sie so, dass
die höchste Maschinenlast (der \emph{Makespan}) minimal wird.
\end{defn}

\begin{zert}
\textbf{Zertifikat:} die Zuordnung Job $\to$ Maschine. \textbf{Prüfung:} pro
Maschine die Last summieren, Maximum bilden, mit der Schranke vergleichen --
$O(n)$.
\end{zert}

\begin{idee}{$\problem{Partition} \redp P2\|\Cmax$}
Nimm die Partition-Zahlen als Jobs, zwei Maschinen. Beide Maschinen exakt gleich
auszulasten heißt, die Zahlen zu \emph{halbieren}. Also ist $P\|\Cmax$ schon
für $m=2$ NP-vollständig.
\end{idee}

\begin{abruf}
\textbf{A11.} Gib für \problem{Hamiltonkreis} das Zertifikat und die Prüfung an
(NP-Dreischritt).\\
\textbf{A12.} Erkläre in eigenen Worten, warum bei $\problem{3-EC}\redp\problem{SubSet Sum}$
die Basis $n+1$ (und nicht z.\,B. Basis 2) gewählt wird.\\
\textbf{A13.} \problem{Vertex Cover} und \problem{Independent Set} hängen eng
zusammen. Wie -- und wie überführt man das eine ins andere?
\end{abruf}

% ##################################################################
\section{Wie schwer \emph{genau}? Die ETH}
% ##################################################################

\begin{ziel}
NP-Vollständigkeit sagt nur \glqq vermutlich nicht polynomiell\grqq. Die
Exponentialzeit-Hypothese (ETH) sagt schärfer: \emph{wie} exponentiell -- und
liefert konkrete untere Schranken.
\end{ziel}

\subsection{Die Lücke, die NP-Vollständigkeit lässt}

NP-Vollständigkeit unterscheidet nicht zwischen $2^n$ und $2^{\sqrt n}$ -- beide
sind \glqq nicht polynomiell\grqq. Oft will man aber wissen: geht es wenigstens
\emph{subexponentiell}?

\begin{defn}{Klein-o und subexponentiell}
$f(n)=o(g(n))$ heißt: $f$ wächst echt langsamer, $f(n)/g(n)\to 0$. Achtung:
$\delta n$ ist \emph{nicht} $o(n)$. Ein \glqq $2^{o(n)}$-Algorithmus\grqq{}
läuft subexponentiell (z.\,B. $2^{\sqrt n}$).
\end{defn}

\begin{bsp}{Drei Wachstumsklassen im Bild}
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(9,4.2)(-0.5,-0.5)
\put(0,0){\vector(1,0){8.5}} \put(8.2,-0.45){\small $n$}
\put(0,0){\vector(0,1){3.8}} \put(-0.5,3.6){\small Zeit}
% polynomiell
\qbezier(0,0)(4.5,0.5)(8,1.4) \put(8.1,1.35){\small poly}
% subexponentiell 2^sqrt(n)
\qbezier(0,0)(3.5,0.6)(6.5,3.6) \put(6.0,3.6){\small $2^{o(n)}$ (subexp.)}
% exponentiell 2^n
\qbezier(0,0)(2.3,0.5)(3.0,3.7) \put(2.6,3.75){\small $2^{n}$}
\end{picture}
\end{center}
Die ETH behauptet: Für \problem{3-SAT} gibt es \emph{keinen} Algorithmus der
mittleren Sorte -- es bleibt echt exponentiell.
\end{bsp}

\begin{defn}{Exponentialzeit-Hypothese (ETH)}
Es gibt ein $\delta > 0$, sodass \problem{3-SAT} mit $n$ Variablen \emph{nicht}
in Zeit $2^{\delta n}\cdot\poly$ lösbar ist. Kurz: kein
$2^{o(n)}$-Algorithmus für \problem{3-SAT}.
\end{defn}

Das ist eine \emph{Annahme}, stärker als $\Pclass\ne\NP$, aber breit geglaubt.

\subsection{Wie man ETH-Schranken beweist}

\begin{idee}{Kontraposition entlang einer Reduktion}
Man überträgt die Härte wie bei der NP-Vollständigkeit -- nur zählt man die
\emph{Größe} der konstruierten Instanz mit:
\begin{center}
\setlength{\unitlength}{1cm}
\begin{picture}(12.5,1.3)(0,-0.2)
\put(0,0.2){\framebox(4.4,0.8){\shortstack{\small angeblich: $2^{o(\cdot)}$-Alg.\\ \small für Zielproblem $Y$}}}
\put(4.4,0.6){\vector(1,0){1.6}} \put(4.5,0.75){\small Reduktion}
\put(6.0,0.2){\framebox(3.4,0.8){\shortstack{\small ergibt $2^{o(m)}$-Alg.\\ \small für \problem{3-SAT}}}}
\put(9.4,0.6){\vector(1,0){1.2}}
\put(10.6,0.2){\framebox(1.9,0.8){\shortstack{\small Widerspruch\\ \small zur ETH}}}
\end{picture}
\end{center}
\end{idee}

\begin{satz}{Sparsification-Lemma -- warum es nötig ist}
Unter der ETH gibt es auch keinen $2^{o(m)}$-Algorithmus für \problem{3-SAT}
($m$ = Klauselzahl).\\
\emph{Warum:} Die ETH spricht über $n$ (Variablen). Reduktionen erzeugen ihre
Größe oft aus $m$ (Klauseln). Da $m$ groß gegen $n$ sein kann, folgt eine
$m$-Schranke \emph{nicht} direkt aus der ETH -- das Lemma schließt die Lücke.
\end{satz}

\begin{stolper}
Hängt der Parameter deiner konstruierten Instanz an der Klauselzahl $m$, musst
du das Sparsification-Lemma zitieren. Das ist der am leichtesten vergessene
Schritt in ETH-Beweisen.
\end{stolper}

Unter der ETH bekommt man so $2^{o(n)}$-Schranken u.\,a. für \problem{3-Color},
\problem{Clique}, \problem{VC}, \problem{IS}, \problem{SubSet Sum} und
\problem{Partition}.

\begin{abruf}
\textbf{A14.} Wenn die ETH falsch ist -- folgt dann $\Pclass=\NP$? Begründe.\\
\textbf{A15.} Wozu braucht man das Sparsification-Lemma, wo die ETH doch schon
eine untere Schranke liefert?
\end{abruf}

% ##################################################################
\section{Damit leben: gute Näherungen}\label{sec:approx}
% ##################################################################

\begin{ziel}
Für schwere \emph{Optimierungsprobleme} berechnet man in Polynomialzeit
\emph{beweisbar gute} Näherungen. Wir sehen den Gütebegriff und die wichtigsten
Algorithmen -- viele davon grafisch.
\end{ziel}

\subsection{Was heißt \glqq gute Näherung\grqq?}

\begin{defn}{Multiplikative Güte}
Mit $\OPT(I)$ = optimaler Wert. Algorithmus $A$ hat \emph{Güte $\alpha$}, wenn
für alle $I$:
Minimierung: $A(I)\le\alpha\cdot\OPT(I)$;\quad
Maximierung: $\OPT(I)\le\alpha\cdot A(I)$.
\emph{Scharf}, wenn Instanzen den Faktor (fast) erreichen.
\end{defn}

\begin{defn}{PTAS, EPTAS, FPTAS}
Familie $(A_\varepsilon)$ mit Güte $1+\varepsilon$ für jedes $\varepsilon$:
\emph{PTAS} polynomiell in $n$ je festem $\varepsilon$ ($\varepsilon$ darf im
Exponenten stehen); \emph{EPTAS} Laufzeit $f(1/\varepsilon)\cdot\poly(n)$;
\emph{FPTAS} polynomiell in $n$ \emph{und} $1/\varepsilon$ (stärkste Form).
\emph{Pseudopolynomiell} = polynomiell in den Zahlen\emph{werten} (nicht in der
Länge!).
\end{defn}

\subsection{TSP: der Algorithmus Schritt für Schritt}

\begin{satz}{Allgemeines TSP ist gar nicht approximierbar}
Für beliebige Distanzen: keine beschränkte Güte möglich (außer $\Pclass=\NP$).\\
\emph{Beweisidee:} Reduziere \problem{HK} -- echte Kanten Distanz 1, fehlende
riesig. Ein Algorithmus mit Güte $\alpha$ müsste die billige Tour erkennen und
löste damit \problem{HK}.
\end{satz}

Ausweg: \emph{metrisches} TSP mit Dreiecksungleichung
$d(i,j)\le d(i,k)+d(k,j)$. Dort funktioniert folgender Dreisprung.

\begin{idee}{$\Delta$TSP$_1$ (Güte 2): Spannbaum $\to$ verdoppeln $\to$ Eulerkreis $\to$ abkürzen}
Der \emph{minimale Spannbaum} ist billiger als die optimale Tour. Verdoppeln
macht alle Grade gerade (Eulerkreis existiert). Abkürzen des Eulerkreises
verlängert dank Dreiecksungleichung nicht.
\end{idee}

\begin{bsp}{$\Delta$TSP$_1$ durchgerechnet (Skript-Zahlen)}
Städte $A,B,C,D,E$ mit $d(A,E)=1,\ d(B,C)=1,\ d(A,C)=2,\ d(C,D)=2$ (übrige
2/3). Links der \textbf{minimale Spannbaum} (fett, Gewicht $6$):
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(6,3.4)(-0.3,-0.3)
\put(0.5,2.2){\circle*{0.14}}\put(0.1,2.25){\small $A$}
\put(0.5,0.3){\circle*{0.14}}\put(0.1,0.2){\small $B$}
\put(2.6,1.3){\circle*{0.14}}\put(2.75,1.35){\small $C$}
\put(4.6,1.3){\circle*{0.14}}\put(4.75,1.35){\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)  % A-E =1
\put(1.3,2.75){\small $1$}
\qbezier(0.5,0.3)(1.55,0.8)(2.6,1.3)  % B-C =1
\put(1.3,0.55){\small $1$}
\qbezier(0.5,2.2)(1.55,1.75)(2.6,1.3) % A-C =2
\put(1.4,1.95){\small $2$}
\put(2.6,1.3){\line(1,0){2.0}}        % C-D =2
\put(3.5,1.4){\small $2$}
\end{picture}
\end{center}
Ablauf: MST-Gewicht $6$ $\to$ verdoppeln (Gewicht $12$) $\to$ Eulerkreis
$[C,A,E,A,C,B,C,D,C]$ $\to$ abkürzen zu Tour $[C,A,E,B,D,C]$ mit Länge
$\mathbf{10}\le 2\cdot\OPT$ (optimale Tour hat Länge $8$).
\end{bsp}

\begin{idee}{$\Delta$TSP$_2$ (Christofides, Güte $1{,}5$): nur die schiefen Knoten reparieren}
Statt \emph{alle} Kanten zu verdoppeln, verbindet Christofides nur die Knoten
mit \emph{ungeradem} Grad im MST durch ein \emph{minimales perfektes Matching}.
Das ist billiger (Matching $\le\OPT/2$) und liefert Güte $1{,}5$.
\end{idee}

\begin{bsp}{Christofides am selben Graphen}
Ungerade Grade im MST: $X=\{B,C,D,E\}$. Matching-Kosten: $d(B,C)=1,\ d(D,E)=2,\
d(B,E)=2,\ d(C,D)=2,\ d(B,D)=3,\ d(C,E)=3$. Minimales perfektes Matching:
$\{B\text{--}C,\ D\text{--}E\}$, Gewicht $3$. Ergebnis-Tour $[C,B,A,E,D,C]$ mit
Länge $\mathbf{9}$ -- besser als $\Delta$TSP$_1$.
\end{bsp}

\begin{stolper}
Das Matching läuft nur über die \emph{ungerad-gradigen} MST-Knoten, nicht über
alle. Und ohne Dreiecksungleichung bricht das Abkürzen zusammen.
\end{stolper}

\subsection{Knapsack: warum Gier scheitert -- und wie man sie rettet}

\begin{bsp}{Greedy kann beliebig schlecht sein}
Zwei Gegenstände $(w,p)=(1,1)$ und $(B,B-1)$, Kapazität $B$. Greedy nimmt (nach
Dichte) den kleinen -- Gewinn $1$. Optimal wäre der große -- Gewinn $B-1$. Das
Verhältnis $B-1$ wächst unbeschränkt.
\end{bsp}

\begin{idee}{Modified Greedy (MGA): Güte 2}
Rechne Greedy \emph{und} \glqq nur den profitabelsten Einzel-Gegenstand\grqq,
gib das Bessere aus. Greedy verliert nur am einen nicht mehr passenden
\glqq Split-Item\grqq{} -- dessen Profit fängt das Einzel-Item ab. Näher ans
Optimum kommen \emph{Sahni} ($1+1/k$, ein PTAS) und das \emph{FPTAS} (Profite
herunterskalieren, exakt per DP; $1+\varepsilon$ in $O(n^3/\varepsilon)$).
\end{idee}

\subsection{Scheduling: Regeln und Gantt-Bild}

\begin{defn}{List Scheduling und LPT}
\emph{List Scheduling:} jeden Job auf die momentan \emph{leerste} Maschine.
\emph{LPT:} zuerst \emph{absteigend} sortieren, dann List Scheduling.
\end{defn}

\begin{bsp}{Warum die Reihenfolge zählt (Gantt, $m=2$)}
Jobs der Größen $1,1,2$. Oben List Scheduling in dieser Reihenfolge (Makespan
$3$), unten optimal / LPT (Makespan $2$). Balkenlänge = Zeit.
\setlength{\unitlength}{1cm}
\begin{center}
\begin{picture}(9,4)(-1.3,-0.4)
% Achse
\put(0,-0.1){\vector(1,0){4}} \put(3.7,-0.5){\small Zeit}
\multiput(0,-0.15)(1,0){4}{\line(0,1){0.1}}
\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}
% List Scheduling
\put(-1.3,3.1){\small List Scheduling:}
\put(-1.1,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.1,1.5){\small $M_2$}
\put(0,1.3){\framebox(1,0.6){\small $1$}}
% Optimal
\put(-1.3,0.9){\small LPT / optimal:}
\put(-1.1,0.3){\small $M_1$}
\put(0,0.1){\framebox(2,0.6){\small $2$}}
\put(-1.1,-0.0){\small }
\end{picture}
\end{center}
List Scheduling stapelt die $2$ auf eine schon belegte Maschine (Makespan $3$).
LPT legt die große $2$ zuerst und erreicht Makespan $2$.
\end{bsp}

\begin{satz}{Güten}
List Scheduling: $2-\tfrac1m$; LPT: $\tfrac43-\tfrac1{3m}$ -- beide scharf.\\
\emph{Beweisidee:} zwei Universalschranken -- $\OPT\ge\frac1m\sum p_i$
(Durchschnittslast) und $\OPT\ge p_{\max}$ (größter Job). Der letzte Job auf der
vollsten Maschine lag dort, als sie die leerste war.
\end{satz}

\subsection{MAX-3-SAT: Güte 2 mit zwei Belegungen}

\begin{idee}{$\beta_0$ und $\beta_1$}
Maximiere die Zahl erfüllter Klauseln. Werte nur \glqq alles falsch\grqq{}
($\beta_0$) und \glqq alles wahr\grqq{} ($\beta_1$) aus, nimm das Bessere. Jede
Klausel hat ein positives \emph{oder} negatives Literal, wird also von einem der
beiden erfüllt. Damit erfüllen beide zusammen $\ge m$ Klauseln, die bessere
$\ge m/2\ge\OPT/2$. Güte 2.
\end{idee}

\begin{abruf}
\textbf{A16.} Nenne die vier Schritte von $\Delta$TSP$_1$ und sage bei jedem,
warum er die Güte-2-Schranke stützt.\\
\textbf{A17.} Warum ist Christofides besser als $\Delta$TSP$_1$, obwohl beide
mit demselben minimalen Spannbaum starten?\\
\textbf{A18.} Konstruiere (Idee) eine Instanz, bei der List Scheduling die
Schranke $2-\frac1m$ wirklich erreicht.
\end{abruf}

% ##################################################################
\section{Jenseits von NP: das Halteproblem}\label{sec:halt}
% ##################################################################

\begin{ziel}
Ein Blick über den Rand: ein Problem, das NP-schwer ist, aber \emph{nicht} in
$\NP$ liegt -- weil es überhaupt nicht lösbar ist. Das zeigt, dass
\glqq schwer\grqq{} und \glqq in NP\grqq{} wirklich zwei Achsen sind.
\end{ziel}

\begin{defn}{Halteproblem}
Gegeben die Beschreibung eines Programms $M$ und einer Eingabe $w$: hält $M$ auf
$w$ irgendwann, oder läuft es ewig?
\end{defn}

Das Halteproblem ist \emph{unentscheidbar} -- kein Algorithmus löst es, mit
keiner Laufzeit. Trotzdem ist es NP-schwer.

\begin{aha}
Man reduziert \problem{SAT} darauf: Baue zu einer Formel $\varphi$ ein Programm
$M_\varphi$, das \emph{alle} Belegungen durchprobiert und genau dann hält, wenn
eine erfüllende existiert. Dann gilt $\varphi$ erfüllbar $\iff$ $M_\varphi$
hält. Der Clou: $M_\varphi$ läuft womöglich ewig -- aber die \emph{Konstruktion}
aus $\varphi$ ist billig, und nur darauf kommt es bei einer Reduktion an. Also
ist das Halteproblem mindestens so schwer wie \problem{SAT}, liegt aber nicht in
$\NP$. \textbf{NP-schwer $\ne$ NP-vollständig.}
\end{aha}

% ##################################################################
\section{Das große Ganze}
% ##################################################################

\begin{ziel}
Wir ziehen die Fäden zusammen: eine Übersicht und ein Wahr/Falsch-Test zur
Selbstkontrolle.
\end{ziel}

\subsection{Die Reise auf einen Blick}

\begin{center}\small
\begin{tabular}{p{3.3cm}p{10.3cm}}
\toprule
Station & Kernidee \\
\midrule
$\Pclass$ & effizient \emph{lösbar} (polynomiell)\\
$\NP$ & effizient \emph{überprüfbar} (Zertifikat prüfen bzw.\ raten)\\
$\Pclass\subseteq\NP$ & Lösen ist mindestens so schwer wie Prüfen; Gleichheit offen\\
$A\redp B$ & \glqq $B$ mindestens so schwer wie $A$\grqq; Richtung: bekannt $\redp$ neu\\
NP-vollständig & die schwersten in $\NP$; \problem{SAT} ist der Anker (Cook--Levin)\\
Vererbungskorollar & neues Problem schwer: eine Reduktion $+$ Nachweis $\in\NP$\\
ETH & schärfer: konkrete $2^{o(\cdot)}$-Schranken (Kontraposition, Sparsification)\\
Approximation & schwere Optimierung: beweisbar gute Näherung mit Gütegarantie\\
\bottomrule
\end{tabular}
\end{center}

\subsection{Wahr oder falsch? (Begründung zählt)}

\begin{center}\small
\begin{tabular}{p{7.3cm}cp{4.8cm}}
\toprule
Aussage & W/F & Begründung \\
\midrule
Löst eine ratende Maschine ein Problem in Polyzeit, dann auch eine gewöhnliche. &
F$^{*}$ & Das wäre $\Pclass=\NP$ -- unbekannt. \\
\addlinespace
$A$ NP-schwer $\Rightarrow A\in\NP$. & F & Halteproblem: NP-schwer, nicht
einmal lösbar. \\
\addlinespace
$L\in\NP$ und $L\redp\problem{3-SAT}$ $\Rightarrow$ $L$ NP-vollständig. & F &
Falsche Richtung -- \emph{auf} 3-SAT reduzieren zeigt keine Schwere. \\
\addlinespace
$\problem{3-SAT}\redp L$ und $L\redp\problem{3-SAT}$ $\Rightarrow$ $L$
NP-vollständig. & W & Erstes gibt Schwere, zweites gibt $L\in\NP$. \\
\addlinespace
ETH falsch $\Rightarrow \Pclass=\NP$. & F & $2^{o(n)}$ kann superpolynomiell
bleiben. \\
\bottomrule
\end{tabular}
\end{center}
{\footnotesize $^{*}$ nicht als wahr beweisbar; äquivalent zu $\Pclass=\NP$.}

\begin{aha}
Du hast das \emph{Warum} beisammen: Was Probleme schwer macht, wie Schwere von
einem zum anderen fließt, wo die Grenzen liegen, was man bei schweren
Optimierungsproblemen tut. Das ist das Fundament.
\end{aha}

\noindent\textbf{Der nächste Schritt (Schritt 3 und 4 deines Lernmodells).} Nimm
die Präsenz-, Haus- und Klausuraufgaben. Führe dort selbst aus, was hier als
Idee stand: Reduktionen \emph{vollständig} beweisen (beide Richtungen!),
Güte-Schranken herleiten, Worst-Case-Instanzen bauen. Dieses Heft gab dir das
Verständnis -- die Aufgaben geben dir das Können.

% ##################################################################
\appendix
\renewcommand{\thesection}{\Alph{section}}
\section{Lösungen zu den Abruf-Fragen}\label{sec:loesungen}
% ##################################################################

Erst selbst beantwortet? Dann hier vergleichen.

\loes{A1.} Ein konstanter Faktor (1000$\approx 2^{10}$) verschiebt die
exponentielle Kurve nur um eine \emph{additive} Konstante: du schaffst rund 20
Knoten mehr -- einmalig. Das Problem wächst weiter exponentiell, die Hardware
nur einmal.

\loes{A2.} \glqq Kennen keinen\grqq{} = niemand hat einen Algorithmus gefunden
(Wissenslücke). \glqq Gibt keinen\grqq{} = bewiesene Nichtexistenz. Für die
Clique gilt nur Ersteres -- ein Nichtexistenzbeweis fehlt ($\Pclass$-vs-$\NP$
offen).

\loes{A3.} Ja. $n^4$ ist polynomiell (fester Exponent $d=4$), also in
$\Pclass$ und im Sinne der Theorie effizient.

\loes{A4.} Bis $K$ zu zählen kostet $K$ Schritte. $K$ ist aber exponentiell in
seiner Eingabelänge $O(\log K)$. Die Laufzeit ist also exponentiell in der
Eingabegröße.

\loes{A5.} \textbf{Zertifikat:} eine Knotenmenge $C$. \textbf{Verifizierer:}
prüfe, ob jede Kante einen Endpunkt in $C$ hat ($O(|E|)$) und ob $|C|\le k$;
akzeptiere genau dann. \textbf{Korrektheit:} gibt es ein VC der Größe $\le k$,
wird es akzeptiert, sonst keines. \textbf{Laufzeit} polynomiell. (NDTM: $C$
raten, dann prüfen.)

\loes{A6.} Der Verifizierer bekommt das Zertifikat \emph{geschenkt} und prüft
nur. Der Löser muss die Lösung selbst \emph{finden} -- und dafür können
exponentiell viele Kandidaten in Frage kommen. Prüfen startet einen Schritt
weiter als Lösen.

\loes{A7.} $\problem{Clique}\redp\problem{Vertex Cover}$ -- vom bekannt schweren
\problem{Clique} auf das neue \problem{VC}. So erbt \problem{VC} die Schwere. Die
Gegenrichtung würde über \problem{VC} nichts aussagen.

\loes{A8.} $A\redp B$ bedeutet: $B$ ist \emph{mindestens so schwer} wie $A$.

\loes{A9.} (1) eine Reduktion von einem bekannten NP-vollständigen Problem auf
$Y$; (2) der Nachweis $Y\in\NP$. Vergessen wird leicht (2) -- ohne ihn hat man
nur NP-\emph{Schwere}, nicht Vollständigkeit. (Beim Reduktionsteil vergisst man
gern die Rückrichtung der Korrektheit.)

\loes{A10.} \problem{SubSet Sum} ist NP-vollständig. Läge \emph{ein}
NP-vollständiges Problem in $\Pclass$, ließe sich jedes $L\in\NP$ via
$L\redp\problem{SubSet Sum}$ effizient lösen -- also $\Pclass=\NP$.

\loes{A11.} \textbf{Zertifikat:} eine Reihenfolge (Permutation) der Knoten.
\textbf{Verifizierer:} prüfe, ob jeder Knoten genau einmal vorkommt und jede
aufeinanderfolgende (und die schließende) Kante existiert -- $O(|V|+|E|)$.
\textbf{NDTM:} Reihenfolge raten, dann prüfen.

\loes{A12.} Bei Basis $n+1$ und höchstens $n$ Summanden gibt es \emph{keinen
Übertrag}; jede Ziffer zählt für sich. Bei Basis 2 könnten Überträge falsche
Teilsummen zufällig aufs Ziel bringen. Die große Basis macht \glqq Summe trifft
Ziel\grqq{} äquivalent zu \glqq jede Stelle genau einmal überdeckt\grqq.

\loes{A13.} $C$ ist Vertex Cover $\iff$ $V\setminus C$ ist Independent Set (im
selben Graphen). Überführung: aus der VC-Instanz $(G,k)$ mach die IS-Instanz
$(G,\,n-k)$.

\loes{A14.} Nein. \glqq ETH falsch\grqq{} heißt nur: \problem{3-SAT} geht in
$2^{o(n)}$ -- das kann noch superpolynomiell sein (z.\,B. $2^{\sqrt n}$).
Umgekehrt gilt: $\Pclass=\NP$ würde die ETH widerlegen.

\loes{A15.} Die ETH liefert eine Schranke in der Variablenzahl $n$. Viele
Reduktionen erzeugen ihre Instanzgröße aus der Klauselzahl $m$, und $m$ kann
$\gg n$ sein. Eine $2^{o(m)}$-Schranke folgt daher \emph{nicht} direkt aus der
ETH -- das Sparsification-Lemma liefert sie.

\loes{A16.} (1) Minimaler Spannbaum $T$: $w(T)\le\OPT$. (2) Kanten verdoppeln:
Gesamtlänge $2w(T)\le 2\OPT$. (3) Eulerkreis: nutzt die geraden Grade, ändert die
Länge nicht. (4) Abkürzen: verlängert wegen der Dreiecksungleichung nicht. Also
$d(R)\le 2\OPT$.

\loes{A17.} $\Delta$TSP$_1$ verdoppelt \emph{alle} MST-Kanten -- das kostet
zusätzlich rund $w(T)\approx\OPT$. Christofides fügt stattdessen nur ein
minimales perfektes Matching auf den ungerad-gradigen Knoten hinzu (Kosten
$\le\OPT/2$). Deshalb $1{,}5\,\OPT$ statt $2\,\OPT$.

\loes{A18.} $m(m-1)$ Jobs der Größe 1, danach \emph{ein} Job der Größe $m$ -- in
dieser Reihenfolge. List Scheduling verteilt die Einsen gleichmäßig (je $m-1$)
und legt den großen Job obendrauf: Makespan $2m-1$. Optimal ist $m$ (großer Job
allein). Verhältnis $\frac{2m-1}{m}=2-\frac1m$.

\end{document}
