1300 lines
56 KiB
TeX
1300 lines
56 KiB
TeX
\documentclass[11pt]{article}
|
|
\input{style_guide.tex}
|
|
|
|
\title{\textbf{\Huge Warum manche Probleme schwer sind}\\[0.6em]
|
|
\large Ein Anfänger-Guide zu Komplexitätstheorie und Approximation\\[0.3em]
|
|
\normalsize \textit{Analyse von Algorithmen und Komplexität} -- CAU Kiel, Sommersemester 2026}
|
|
\author{}
|
|
\date{}
|
|
|
|
\begin{document}
|
|
\maketitle
|
|
\thispagestyle{empty}
|
|
|
|
\begin{center}
|
|
\itshape
|
|
\large
|
|
\glqq Manche Probleme lösen wir in Sekunden.\\
|
|
Bei anderen läuft der Computer bis zum Hitzetod des Universums.\\
|
|
Dieser Guide erklärt dir, woran das liegt -- und was man dann tut.\grqq
|
|
\end{center}
|
|
|
|
\vfill
|
|
|
|
\noindent\textbf{An wen sich dieser Guide richtet.}
|
|
An dich, wenn du gerade erst anfängst. Du brauchst keine Vorkenntnisse in
|
|
Komplexitätstheorie. Was du brauchst: Neugier und die Bereitschaft, jedes
|
|
Kapitel wirklich durchzuarbeiten -- nicht zu überfliegen.
|
|
|
|
\medskip
|
|
\noindent\textbf{Wie du liest.}
|
|
Der Guide erzählt eine \emph{Geschichte}, keine Liste. Jedes Kapitel beginnt
|
|
mit einer Frage, die sich aus dem vorigen ergibt. Die farbigen Kästen haben
|
|
feste Rollen:
|
|
|
|
\begin{center}
|
|
\small
|
|
\begin{tabular}{ll}
|
|
\ding{72}~\textbf{Intuition} & die Idee in einfachen Worten\\
|
|
\ding{43}~\textbf{Analogie} & ein Bild aus dem Alltag\\
|
|
\ding{110}~\textbf{Definition} & die präzise Fassung\\
|
|
\ding{115}~\textbf{Satz} & ein Ergebnis mit kurzer Beweis\emph{idee}\\
|
|
\ding{108}~\textbf{Beispiel} & durchgerechnet, mit echten Zahlen\\
|
|
\ding{73}~\textbf{Aha} & die Pointe, die alles zusammenzieht\\
|
|
\ding{55}~\textbf{Stolperstein} & der Fehler, den fast alle machen\\
|
|
\ding{228}~\textbf{Zusammenhang} & wie es mit dem Rest verbunden ist\\
|
|
\ding{52}~\textbf{Selbst-Check} & prüfe dich, bevor du weiterliest\\
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\medskip
|
|
\noindent Am Ende verstehst du \emph{alle} Inhalte der Vorlesung und siehst, wie
|
|
sie zusammenhängen. Der Schritt danach: Präsenz-, Haus- und Klausuraufgaben
|
|
rechnen, um Routine zu bekommen. Dieser Guide gibt dir das \emph{Warum}, die
|
|
Aufgaben das \emph{Können}.
|
|
|
|
\vfill
|
|
\newpage
|
|
|
|
\tableofcontents
|
|
\newpage
|
|
|
|
% ##################################################################
|
|
\section{Ein Problem, das sich wehrt}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir treffen ein Problem, das einfach aussieht -- und trotzdem jeden bekannten
|
|
Computer in die Knie zwingt. Daran verstehst du, warum es eine ganze Theorie
|
|
über \glqq schwere\grqq{} Probleme gibt.
|
|
\end{ziel}
|
|
|
|
\subsection{Freunde auf einer Party}
|
|
|
|
Stell dir eine Party mit einigen Gästen vor. Manche kennen sich, manche nicht.
|
|
Du fragst dich: \emph{Gibt es eine Gruppe von $k$ Gästen, die sich alle
|
|
gegenseitig kennen?} Eine solche Gruppe, in der \emph{jeder jeden} kennt,
|
|
nennen wir eine \emph{Clique}.
|
|
|
|
Das lässt sich als \emph{Graph} zeichnen: Jeder Gast ist ein Punkt (ein
|
|
\emph{Knoten}), und eine Linie (eine \emph{Kante}) zwischen zwei Punkten heißt
|
|
\glqq die beiden kennen sich\grqq.
|
|
|
|
\begin{bsp}{Eine Clique mit dem Auge finden}
|
|
\setlength{\unitlength}{1cm}
|
|
\begin{center}
|
|
\begin{picture}(4,2.6)(-0.4,-0.3)
|
|
\put(0,1){\circle*{0.13}}\put(-0.4,1){\small $1$}
|
|
\put(1,2){\circle*{0.13}}\put(1,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.4){\small $4$}
|
|
\put(3,0.5){\circle*{0.13}}\put(3.2,0.4){\small $5$}
|
|
\put(0,1){\line(1,1){1}} % 1-2
|
|
\put(0,1){\line(1,0){2}} % 1-3
|
|
\put(1,2){\line(1,-1){1}} % 2-3
|
|
\put(2,1){\line(-3,-5){0.6}} % 3-4
|
|
\put(2,1){\line(2,-1){1}} % 3-5
|
|
\end{picture}
|
|
\end{center}
|
|
Fünf Gäste. Die Gruppe $\{1,2,3\}$ ist eine Clique: 1--2, 1--3 und 2--3 sind
|
|
alle da. Also kennen sich alle drei gegenseitig. Die Gruppe $\{2,3,4\}$ ist
|
|
\emph{keine} Clique -- zwischen 2 und 4 fehlt die Kante. Es gibt hier keine
|
|
Clique aus vier Gästen.
|
|
\end{bsp}
|
|
|
|
Bei fünf Gästen siehst du die Antwort sofort. Aber ein Computer \glqq sieht\grqq{}
|
|
nicht. Er muss rechnen. Und ab ein paar hundert Gästen wird selbst für den
|
|
schnellsten Rechner der Welt genau das zum Problem.
|
|
|
|
\subsection{Der naive Weg -- und warum er explodiert}
|
|
|
|
Wie würde ein Computer eine $k$-Clique suchen? Der naheliegende Weg:
|
|
\emph{probiere alle Gruppen aus $k$ Gästen durch} und prüfe für jede, ob sich
|
|
wirklich alle kennen.
|
|
|
|
Das klingt vernünftig. Rechnen wir nach, wie viele Gruppen das sind. Bei $n$
|
|
Gästen und Gruppengröße $k = n/2$ gibt es \glqq $n$ über $n/2$\grqq{} viele
|
|
Gruppen -- und das sind mindestens $2^{n/2}$.
|
|
|
|
\begin{bsp}{Wie schnell $2^{n/2}$ wächst}
|
|
\begin{center}
|
|
\begin{tabular}{rrl}
|
|
\toprule
|
|
Gäste $n$ & Gruppen $\ge 2^{n/2}$ & anschaulich\\
|
|
\midrule
|
|
$20$ & $\ge 1\,024$ & ein Wimpernschlag\\
|
|
$40$ & $\ge 1\,048\,576$ & eine Sekunde\\
|
|
$100$ & $\ge 2^{50} \approx 10^{15}$ & über einen Monat bei $10^9$/s\\
|
|
$200$ & $\ge 2^{100} \approx 10^{30}$ & länger als das Alter des Universums\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Jeder zusätzliche Gast \emph{verdoppelt} ungefähr den Aufwand. Das ist der
|
|
Unterschied zwischen \glqq machbar\grqq{} und \glqq unmöglich\grqq.
|
|
\end{bsp}
|
|
|
|
\begin{intuition}
|
|
Wenn der Aufwand sich bei jedem weiteren Element \emph{verdoppelt}, sprechen wir
|
|
von \emph{exponentiellem} Wachstum. Exponentielles Wachstum ist der natürliche
|
|
Feind jeder Berechnung: Es macht schon mittelgroße Eingaben unlösbar. Kein
|
|
schnellerer Rechner rettet dich -- du müsstest ihn selbst verdoppeln, nur um
|
|
\emph{einen} Gast mehr zu schaffen.
|
|
\end{intuition}
|
|
|
|
\begin{satz}{Der naive Clique-Algorithmus ist exponentiell}
|
|
Für $k = |V|/2$ braucht der naive Algorithmus mindestens $2^{|V|/2}$ Schritte.\\
|
|
\emph{Beweisidee:} Es gibt $\binom{n}{n/2} \ge 2^{n/2}$ Gruppen zu prüfen, und
|
|
schon das Durchprobieren so vieler Gruppen kostet exponentiell viel Zeit.
|
|
\end{satz}
|
|
|
|
\subsection{Die Frage, um die es geht}
|
|
|
|
Vielleicht ist der naive Weg einfach dumm. Vielleicht gibt es einen cleveren
|
|
Trick, der die Clique \emph{schnell} findet, ohne alle Gruppen durchzuprobieren.
|
|
|
|
Für das Cliquenproblem hat bis heute \emph{niemand} so einen Trick gefunden.
|
|
Aber -- und das ist der Kern -- niemand hat auch \emph{bewiesen}, dass es
|
|
keinen gibt. Diese Lücke zwischen \glqq wir kennen keinen schnellen Weg\grqq{}
|
|
und \glqq es gibt keinen schnellen Weg\grqq{} ist der Ausgangspunkt der ganzen
|
|
Vorlesung.
|
|
|
|
\begin{aha}
|
|
Die Komplexitätstheorie beantwortet nicht die Frage \glqq Wie löse ich dieses
|
|
Problem schnell?\grqq. Sie beantwortet die tiefere Frage: \glqq Ist dieses
|
|
Problem \emph{überhaupt} schnell lösbar -- oder gehört es zu einer Familie von
|
|
Problemen, bei denen alle gemeinsam scheitern?\grqq
|
|
\end{aha}
|
|
|
|
\begin{selbstcheck}
|
|
Bevor du weiterliest: Warum hilft ein doppelt so schneller Computer beim
|
|
naiven Clique-Algorithmus fast nichts?\\[0.3em]
|
|
\emph{Antwort:} Weil schon \emph{ein} Gast mehr den Aufwand verdoppelt. Der
|
|
schnellere Computer verschafft dir also gerade genug für einen einzigen
|
|
zusätzlichen Gast -- das Problem wächst schneller, als Hardware je aufholen kann.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Was heißt eigentlich \glqq schnell\grqq?}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir machen \glqq schnell\grqq{} und \glqq langsam\grqq{} präzise. Am Ende hast du
|
|
die erste wichtige Klasse verstanden: $\Pclass$, die Probleme, die wir effizient
|
|
lösen können.
|
|
\end{ziel}
|
|
|
|
\subsection{Laufzeit hängt von der Eingabegröße ab}
|
|
|
|
Ein Algorithmus ist nicht einfach \glqq schnell\grqq. Er ist schnell
|
|
\emph{relativ zur Größe seiner Eingabe}. Zehn Zahlen zu sortieren ist leicht;
|
|
zehn Milliarden zu sortieren dauert. Wir messen deshalb die \emph{Laufzeit als
|
|
Funktion der Eingabelänge} $n$.
|
|
|
|
\begin{defn}{Laufzeit}
|
|
$T_A(x)$ ist die Anzahl der Rechenschritte von Algorithmus $A$ auf Eingabe $x$.
|
|
Die \emph{Worst-Case-Laufzeit} bei Eingabelänge $n$ ist die schlimmste über
|
|
alle Eingaben dieser Länge:
|
|
\[
|
|
T_A(n) = \max\{\,T_A(x) \mid |x| = n\,\}.
|
|
\]
|
|
\end{defn}
|
|
|
|
Wir schauen bewusst auf den \emph{schlechtesten} Fall. Ein Algorithmus, der
|
|
\glqq meistens\grqq{} schnell ist, aber gelegentlich explodiert, ist keine
|
|
verlässliche Garantie.
|
|
|
|
\subsection{Polynomiell gegen exponentiell -- die entscheidende Grenze}
|
|
|
|
Es gibt viele Wachstumsarten, aber die eine Grenze, auf die alles hinausläuft,
|
|
ist: \emph{polynomiell} gegen \emph{exponentiell}.
|
|
|
|
\begin{itemize}
|
|
\item \emph{Polynomiell} heißt: die Laufzeit ist $O(n^d)$ für eine feste Zahl
|
|
$d$ -- also $n$, $n^2$, $n^3$, \dots
|
|
\item \emph{Exponentiell} heißt: etwas wie $2^n$, das sich bei jedem Schritt
|
|
verdoppelt.
|
|
\end{itemize}
|
|
|
|
\begin{bsp}{Der Graben zwischen $n^3$ und $2^n$}
|
|
\begin{center}
|
|
\begin{tabular}{rrr}
|
|
\toprule
|
|
$n$ & $n^3$ (polynomiell) & $2^n$ (exponentiell)\\
|
|
\midrule
|
|
$10$ & $1\,000$ & $1\,024$\\
|
|
$20$ & $8\,000$ & rund $1$ Million\\
|
|
$50$ & $125\,000$ & rund $10^{15}$\\
|
|
$100$ & $1\,000\,000$ & rund $10^{30}$\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
Bei $n = 10$ sind beide harmlos. Bei $n = 100$ ist $n^3$ immer noch eine
|
|
Millionstel Sekunde -- $2^n$ dagegen jenseits von allem. \emph{Diese Kluft ist
|
|
der Grund, warum wir polynomiell mit \glqq effizient\grqq{} gleichsetzen.}
|
|
\end{bsp}
|
|
|
|
\begin{intuition}
|
|
\glqq Polynomiell = effizient\grqq{} ist eine \emph{Konvention}, kein
|
|
Naturgesetz. Ein $n^{100}$-Algorithmus wäre praktisch nutzlos. Aber die
|
|
Konvention funktioniert erstaunlich gut: Polynomielle Algorithmen aus der Praxis
|
|
haben fast immer kleine Exponenten ($n$, $n^2$, $n^3$), und die Grenze
|
|
\glqq polynomiell\grqq{} bleibt stabil, egal welchen realistischen Computer man
|
|
zugrunde legt.
|
|
\end{intuition}
|
|
|
|
\begin{defn}{Die Klasse P}
|
|
$\Pclass$ ist die Menge aller Entscheidungsprobleme, die ein Algorithmus in
|
|
\emph{polynomieller} Zeit löst:
|
|
\[
|
|
\Pclass = \{\, L \mid \exists\ \text{Algorithmus } A,\ T_A(n) = O(n^d),\
|
|
d = O(1),\ A \text{ löst } L \,\}.
|
|
\]
|
|
In Worten: die Probleme, die wir \emph{effizient} lösen können.
|
|
\end{defn}
|
|
|
|
Beispiele für Probleme in $\Pclass$: Sortieren, kürzeste Wege im Graphen
|
|
(Dijkstra), minimale Spannbäume, das Finden eines Matchings. Für all das kennen
|
|
wir schnelle, polynomielle Algorithmen.
|
|
|
|
\subsection{Warum wir Probleme als Ja/Nein-Fragen schreiben}
|
|
|
|
Ein technischer, aber wichtiger Punkt. Die Theorie behandelt fast immer
|
|
\emph{Entscheidungsprobleme} -- Fragen mit Antwort \glqq Ja\grqq{} oder
|
|
\glqq Nein\grqq. Statt \glqq Wie groß ist die größte Clique?\grqq{} fragt man:
|
|
\glqq Gibt es eine Clique mit mindestens $k$ Knoten?\grqq
|
|
|
|
\begin{analogie}
|
|
Das ist wie die Frage \glqq Ist dieses Gewicht schwerer als 10\,kg?\grqq{}
|
|
statt \glqq Wie schwer ist es genau?\grqq. Wenn du die Ja/Nein-Frage für jede
|
|
Schranke beantworten kannst, kennst du am Ende auch den genauen Wert -- du
|
|
tastest ihn ein. Deshalb ist die Entscheidungsvariante \glqq gleich schwer\grqq{}
|
|
wie das Optimierungsproblem, aber viel einfacher zu vergleichen und zu
|
|
klassifizieren.
|
|
\end{analogie}
|
|
|
|
Um über \glqq alle Probleme\grqq{} sauber reden zu können, kodiert man jede
|
|
Eingabe als \emph{Wort} über einem Alphabet, und ein Problem wird zur
|
|
\emph{Menge der Ja-Wörter}.
|
|
|
|
\begin{defn}{Alphabet, Wort, Sprache, Entscheidungsproblem}
|
|
\begin{itemize}
|
|
\item Ein \emph{Alphabet} $\Sigma$ ist eine endliche Symbolmenge (z.\,B.
|
|
$\{0,1\}$). $\Sigma^*$ sind alle endlichen Wörter darüber; $|x|$ ist die Länge
|
|
von $x$.
|
|
\item Eine \emph{Sprache} ist eine Teilmenge $L \subseteq \Sigma^*$.
|
|
\item Ein \emph{Entscheidungsproblem} identifiziert man mit der Sprache $L$
|
|
seiner Ja-Instanzen: $A$ löst es, wenn $A(x) = 1$ für $x \in L$ und $A(x) = 0$
|
|
sonst.
|
|
\end{itemize}
|
|
\end{defn}
|
|
|
|
Du musst diese Kodierbrille nicht ständig vor Augen haben. Merke dir nur:
|
|
\emph{Ein Problem = die Menge seiner Ja-Eingaben.} Beim Cliquenproblem ist das
|
|
die Menge aller Paare $(G, k)$, für die $G$ wirklich eine $k$-Clique besitzt.
|
|
|
|
\begin{stolper}
|
|
\textbf{Zahlen sind binär kodiert -- und dadurch \glqq riesig\grqq.} Eine Zahl
|
|
$K$ hat als Eingabe nur die Länge $O(\log K)$ (ihre Ziffern), ist als
|
|
\emph{Wert} aber exponentiell größer. Ein Algorithmus, der bis $K$ zählt, ist
|
|
also \emph{nicht} polynomiell in der Eingabelänge. Genau daran hängt später,
|
|
warum \problem{SubSet Sum} schwer ist und was \glqq pseudopolynomiell\grqq{}
|
|
bedeutet. Behalte es im Hinterkopf.
|
|
\end{stolper}
|
|
|
|
\begin{selbstcheck}
|
|
Ist ein Algorithmus mit Laufzeit $n^5$ \glqq effizient\grqq{} im Sinne der
|
|
Theorie?\\[0.3em]
|
|
\emph{Antwort:} Ja. $n^5$ ist polynomiell ($d = 5$ ist eine feste Zahl), also
|
|
liegt das Problem in $\Pclass$. In der Praxis wäre $n^5$ vielleicht langsam --
|
|
aber die Theorie zieht die Grenze bei polynomiell gegen exponentiell, und auf
|
|
dieser Skala ist $n^5$ klar auf der guten Seite.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Prüfen ist leichter als Lösen}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir entdecken die vielleicht wichtigste Beobachtung der ganzen Theorie: Für
|
|
viele schwere Probleme ist es zwar hart, eine Lösung zu \emph{finden} -- aber
|
|
kinderleicht, eine vorgelegte Lösung zu \emph{prüfen}. Das führt uns zur Klasse
|
|
$\NP$.
|
|
\end{ziel}
|
|
|
|
\subsection{Die Sudoku-Beobachtung}
|
|
|
|
\begin{analogie}
|
|
Ein schweres Sudoku zu \emph{lösen} kann dich eine halbe Stunde kosten. Aber
|
|
wenn dir jemand ein ausgefülltes Gitter hinlegt und fragt \glqq stimmt das?\grqq,
|
|
prüfst du es in einer Minute: jede Zeile, jede Spalte, jeder Block. \emph{Lösen
|
|
ist schwer, Prüfen ist leicht.} Genau diese Asymmetrie steckt hinter $\NP$.
|
|
\end{analogie}
|
|
|
|
Übertragen auf die Clique: Eine Clique zu \emph{finden} ist mühsam. Aber wenn
|
|
dir jemand eine Gruppe von Gästen nennt und behauptet \glqq die bilden eine
|
|
Clique\grqq, prüfst du das schnell -- du schaust einfach nach, ob zwischen jedem
|
|
Paar eine Kante liegt.
|
|
|
|
Diese \glqq vorgelegte Lösung\grqq{} bekommt einen Namen: \emph{Zertifikat}.
|
|
|
|
\subsection{Zertifikat und Verifizierer}
|
|
|
|
\begin{defn}{Verifizierer und Zertifikat}
|
|
Ein \emph{Verifizierer} für ein Problem $L$ ist ein Algorithmus $A$, der zwei
|
|
Eingaben bekommt: die Instanz $x$ und einen \emph{Lösungsvorschlag} $c$. Er
|
|
erfüllt
|
|
\[
|
|
x \in L \quad\Longleftrightarrow\quad
|
|
\text{es gibt ein } c \text{ mit } A(x,c) = 1.
|
|
\]
|
|
Das $c$ heißt \emph{Zertifikat} (oder Zeuge). Der Verifizierer ist
|
|
\emph{polynomiell}, wenn er für jede Ja-Instanz ein Zertifikat gibt, das er in
|
|
polynomieller Zeit prüft.
|
|
\end{defn}
|
|
|
|
Lies die Äquivalenz genau: Für eine \emph{Ja}-Instanz gibt es ein Zertifikat,
|
|
das $A$ überzeugt. Für eine \emph{Nein}-Instanz gibt es \emph{kein} solches
|
|
Zertifikat -- egal, was man $A$ vorlegt, er sagt Nein.
|
|
|
|
\begin{defn}{Die Klasse NP}
|
|
$\NP$ ist die Menge aller Probleme, die einen \emph{polynomiellen Verifizierer}
|
|
besitzen.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
$\NP$ ist \glqq effizient \emph{überprüfbar}\grqq{} -- nicht \glqq effizient
|
|
lösbar\grqq. Der Name ist Programm: Eine Lösung zu finden mag exponentiell
|
|
teuer sein, aber \emph{hätte} man sie, könnte man sie billig kontrollieren. Das
|
|
Zertifikat ist die abgekürzte Antwort auf \glqq und woher weiß ich, dass das
|
|
stimmt?\grqq.
|
|
\end{intuition}
|
|
|
|
\begin{bsp}{Zertifikate für vier Probleme}
|
|
\begin{center}
|
|
\begin{tabular}{lll}
|
|
\toprule
|
|
Problem & Zertifikat $c$ & Prüfung in Polyzeit\\
|
|
\midrule
|
|
$k$-\problem{Clique} & die Knotengruppe $C$ & alle Paare verbunden? $|C| \ge k$?\\
|
|
\problem{SAT} & eine Belegung $\psi$ & macht $\psi$ die Formel wahr?\\
|
|
\problem{Vertex Cover} & die Knotenmenge $C$ & jede Kante getroffen? $|C| \le k$?\\
|
|
\problem{SubSet Sum} & die Teilmenge $S$ & ist $\sum_{j \in S} c_j = K$?\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
In jeder Zeile ist das Zertifikat kurz (polynomiell lang) und die Prüfung
|
|
einfach. Genau das macht diese Probleme zu Mitgliedern von $\NP$.
|
|
\end{bsp}
|
|
|
|
\subsection{Die zweite Brille: Raten}
|
|
|
|
Es gibt eine zweite, gleichwertige Art, $\NP$ zu sehen -- über das
|
|
\emph{Raten}. Stell dir einen Algorithmus vor, der an jeder Verzweigung
|
|
\emph{gleichzeitig alle Möglichkeiten} ausprobieren darf. So ein Algorithmus
|
|
heißt \emph{nichtdeterministisch}.
|
|
|
|
\begin{intuition}
|
|
Der nichtdeterministische Algorithmus arbeitet nach dem Muster: \emph{rate die
|
|
Lösung, dann prüfe sie}. Er \glqq rät\grqq{} in Polynomialzeit eine
|
|
Lösungskandidatin und prüft sie deterministisch. Er akzeptiert, wenn
|
|
\emph{mindestens ein} Rateweg zu \glqq Ja\grqq{} führt. Für eine Nein-Instanz
|
|
führt \emph{kein} Weg zum Ziel.
|
|
\end{intuition}
|
|
|
|
Formal beschreibt man das mit einer nichtdeterministischen Turingmaschine. Du
|
|
musst die Maschine nicht auswendig können, aber einmal gesehen haben:
|
|
|
|
\begin{defn}{Nichtdeterministische Turingmaschine (NDTM), knapp}
|
|
Eine NDTM darf zu jedem Zustand-Symbol-Paar \emph{mehrere} (oder keine)
|
|
Folgeschritte haben -- sie verzweigt. Sie \emph{akzeptiert} eine Eingabe, wenn
|
|
\emph{irgendein} Rechenweg in einem Endzustand hält, und zwar nach polynomiell
|
|
vielen Schritten. Hat sie überall höchstens einen Folgeschritt, ist sie
|
|
gewöhnlich (deterministisch) -- das ist der Fall, der $\Pclass$ definiert.
|
|
\end{defn}
|
|
|
|
\begin{satz}{Beide Sichten beschreiben dasselbe $\NP$}
|
|
Die Definition über Verifizierer und die über NDTMs ergeben genau dieselbe
|
|
Klasse.\\
|
|
\emph{Beweisidee:} Die Folge der Rateentscheidungen einer NDTM \emph{ist} ein
|
|
Zertifikat. Umgekehrt rät eine NDTM zuerst das Zertifikat und simuliert dann den
|
|
Verifizierer. \glqq Raten\grqq{} und \glqq ein Zertifikat bekommen\grqq{} sind
|
|
zwei Namen für dasselbe.
|
|
\end{satz}
|
|
|
|
\subsection{P steckt in NP -- und die Millionenfrage}
|
|
|
|
\begin{satz}{$\Pclass \subseteq \NP$}
|
|
Jedes effizient \emph{lösbare} Problem ist auch effizient \emph{überprüfbar}.\\
|
|
\emph{Beweisidee:} Wenn du ein Problem selbst schnell lösen kannst, brauchst du
|
|
gar kein Zertifikat -- du ignorierst es und rechnest die Antwort direkt aus.
|
|
Der Löser ist also ein (besonders fauler) Verifizierer.
|
|
\end{satz}
|
|
|
|
Die große offene Frage ist die \emph{Umkehrung}: Ist auch alles, was man
|
|
schnell \emph{prüfen} kann, schnell \emph{lösbar}? Also gilt $\Pclass = \NP$?
|
|
|
|
\begin{aha}
|
|
Ob $\Pclass = \NP$ gilt, weiß bis heute niemand. Es ist eines der sieben
|
|
Millennium-Probleme, mit einer Million Dollar Preisgeld. Die meisten Forscher
|
|
glauben $\Pclass \ne \NP$ -- also dass Prüfen \emph{echt} leichter ist als
|
|
Lösen. Beweisen konnte es keiner. \emph{Alles Folgende in diesem Guide --
|
|
NP-Vollständigkeit, ETH, Approximation -- ist der geschickte Umgang mit genau
|
|
dieser Unwissenheit.}
|
|
\end{aha}
|
|
|
|
\begin{zushang}
|
|
Halte die drei Begriffe auseinander, sie kommen ständig wieder:
|
|
\begin{itemize}
|
|
\item $\Pclass$ -- effizient \emph{lösbar} (finden ist leicht).
|
|
\item $\NP$ -- effizient \emph{überprüfbar} (prüfen ist leicht).
|
|
\item $\Pclass \subseteq \NP$ ist bewiesen; ob Gleichheit gilt, ist offen.
|
|
\end{itemize}
|
|
Im nächsten Kapitel bauen wir das Werkzeug, mit dem man Probleme \emph{innerhalb}
|
|
von $\NP$ nach Schwierigkeit vergleicht -- ohne $\Pclass = \NP$ zu kennen.
|
|
\end{zushang}
|
|
|
|
\begin{selbstcheck}
|
|
Warum ist \glqq $L$ hat einen polynomiellen Verifizierer\grqq{} \emph{nicht}
|
|
dasselbe wie \glqq $L$ ist in Polynomialzeit lösbar\grqq?\\[0.3em]
|
|
\emph{Antwort:} Der Verifizierer bekommt das Zertifikat schon \emph{geschenkt}
|
|
und muss es nur prüfen. Der Löser hat niemanden, der ihm die Lösung vorlegt --
|
|
er muss sie selbst finden, und das kann exponentiell viele Kandidaten bedeuten.
|
|
Prüfen startet einen Schritt weiter als Lösen.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{\glqq Mindestens so schwer wie\grqq{} -- Reduktionen}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir bauen das wichtigste Werkzeug der ganzen Theorie: die \emph{Reduktion}. Mit
|
|
ihr vergleicht man Probleme nach Schwierigkeit -- ohne für eines von beiden einen
|
|
Algorithmus zu kennen. Das klingt wie Zauberei, ist aber eine schlichte Idee.
|
|
\end{ziel}
|
|
|
|
\subsection{Ein Problem mit einem anderen lösen}
|
|
|
|
Angenommen, du hast einen fertigen Löser für Problem $B$. Und du stehst vor
|
|
Problem $A$, für das du keinen Löser hast. Wenn du jede $A$-Frage so
|
|
\emph{umformen} kannst, dass der $B$-Löser sie beantwortet, dann hast du $A$
|
|
gelöst -- geschenkt, über den Umweg $B$.
|
|
|
|
\begin{analogie}
|
|
Du willst wissen, ob eine Strecke länger als eine Meile ist, hast aber nur ein
|
|
Lineal in Kilometern. Kein Problem: Du rechnest \glqq länger als 1 Meile?\grqq{}
|
|
um in \glqq länger als 1{,}609\,km?\grqq{} und misst das. Die \emph{Umrechnung}
|
|
ist billig, das Messen erledigt das km-Lineal. Genau das ist eine Reduktion:
|
|
\emph{billiges Umformen} plus \emph{fremder Löser}.
|
|
\end{analogie}
|
|
|
|
\begin{defn}{Polynomielle Reduktion $A \redp B$}
|
|
Eine \emph{Reduktion} von $A$ auf $B$ ist eine Funktion $f$, die jede
|
|
$A$-Eingabe $w$ in eine $B$-Eingabe $f(w)$ übersetzt, sodass
|
|
\[
|
|
w \in A \quad\Longleftrightarrow\quad f(w) \in B.
|
|
\]
|
|
Sie ist \emph{polynomiell}, wenn $f$ in polynomieller Zeit berechenbar ist (dann
|
|
ist $f(w)$ auch nur polynomiell groß). Schreibweise: $A \redp B$.
|
|
\end{defn}
|
|
|
|
Lies die Bedingung genau: $f$ muss \emph{Ja} auf \emph{Ja} und \emph{Nein} auf
|
|
\emph{Nein} abbilden. Eine Ja-Instanz von $A$ wird zu einer Ja-Instanz von $B$
|
|
-- und eine Nein-Instanz von $A$ zu einer Nein-Instanz von $B$. Beide
|
|
Richtungen.
|
|
|
|
\begin{intuition}
|
|
$A \redp B$ heißt: \glqq $B$ ist \emph{mindestens so schwer} wie $A$.\grqq{}
|
|
Denn wer $B$ effizient lösen kann, löst damit auch $A$ effizient (erst $f$
|
|
rechnen, dann den $B$-Löser fragen). Die Schwierigkeit \glqq fließt\grqq{}
|
|
entlang des Pfeils: Ist $A$ schwer, muss $B$ es auch sein.
|
|
\end{intuition}
|
|
|
|
\subsection{Die Richtung -- der Fehler, der alle Punkte kostet}
|
|
|
|
\begin{stolper}
|
|
\textbf{Die Reduktionsrichtung ist der häufigste und teuerste Fehler.} Du
|
|
willst zeigen, dass ein \emph{neues} Problem $Y$ schwer ist. Dann reduzierst du
|
|
ein \emph{bekannt schweres} Problem $X$ \emph{auf} $Y$, also $X \redp Y$
|
|
(\glqq bekannt $\redp$ neu\grqq). Die Reduktion nimmt eine $X$-Instanz und baut
|
|
daraus eine $Y$-Instanz. \emph{Niemals} umgekehrt.
|
|
\end{stolper}
|
|
|
|
Warum diese Richtung? Weil du die Schwere von $X$ auf $Y$ \emph{übertragen}
|
|
willst. \glqq $X \redp Y$\grqq{} bedeutet \glqq $Y$ mindestens so schwer wie
|
|
$X$\grqq. Da $X$ schon als schwer bekannt ist, erbt $Y$ diese Schwere. Machst
|
|
du es andersherum ($Y \redp X$), zeigst du nur \glqq $Y$ ist \emph{höchstens} so
|
|
schwer wie das schwere $X$\grqq{} -- das sagt über $Y$ gar nichts aus.
|
|
|
|
\begin{analogie}
|
|
Du willst beweisen, dass ein neuer Gegner stark ist. Dann lässt du den
|
|
\emph{amtierenden Champion} gegen ihn antreten und zeigst: Wer den Neuen
|
|
besiegt, besiegt auch den Champion. Du schickst nicht den Neuen gegen einen
|
|
Anfänger. \glqq Bekannt stark $\redp$ neu\grqq.
|
|
\end{analogie}
|
|
|
|
\subsection{Reduktionen lassen sich verketten}
|
|
|
|
\begin{satz}{Transitivität}
|
|
Gilt $A \redp B$ und $B \redp C$, dann auch $A \redp C$.\\
|
|
\emph{Beweisidee:} Schalte die beiden Umformungen hintereinander: erst
|
|
$A \to B$, dann $B \to C$. Die Ausgabe der ersten ist polynomiell groß, also
|
|
bleibt auch die Verkettung polynomiell.
|
|
\end{satz}
|
|
|
|
Das ist der Grund, warum wir gleich eine ganze \emph{Kette} von Reduktionen
|
|
bauen können: Einmal $X$ als schwer bekannt, überträgt sich die Schwere Glied
|
|
für Glied auf alle folgenden Probleme.
|
|
|
|
\begin{selbstcheck}
|
|
Du willst zeigen, dass \problem{Vertex Cover} schwer ist, und weißt, dass
|
|
\problem{Clique} schwer ist. In welche Richtung reduzierst du?\\[0.3em]
|
|
\emph{Antwort:} $\problem{Clique} \redp \problem{Vertex Cover}$ -- vom bekannt
|
|
schweren \problem{Clique} auf das neue \problem{Vertex Cover}. So erbt
|
|
\problem{Vertex Cover} die Schwere. Andersherum hättest du nichts gezeigt.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Die härtesten Probleme}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Jetzt fassen wir die schwersten Probleme in $\NP$ mit einem Namen:
|
|
\emph{NP-vollständig}. Wir sehen, warum es überhaupt ein \glqq erstes\grqq{}
|
|
solches Problem gibt und warum ein einziger schneller Algorithmus für eines von
|
|
ihnen die gesamte Landschaft zum Einsturz brächte.
|
|
\end{ziel}
|
|
|
|
\subsection{NP-schwer und NP-vollständig}
|
|
|
|
Mit der Reduktion können wir \glqq am schwersten in $\NP$\grqq{} präzise machen:
|
|
ein Problem, auf das sich \emph{alle} Probleme aus $\NP$ reduzieren lassen.
|
|
|
|
\begin{defn}{NP-schwer, NP-vollständig}
|
|
\begin{itemize}
|
|
\item $L_0$ ist \emph{NP-schwer}, wenn sich \emph{jedes} Problem $L \in \NP$ auf
|
|
$L_0$ reduzieren lässt: $L \redp L_0$ für alle $L \in \NP$.
|
|
\item $L_0$ ist \emph{NP-vollständig}, wenn es NP-schwer ist \textbf{und} selbst
|
|
in $\NP$ liegt.
|
|
\end{itemize}
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Trenne die zwei Hälften sauber:
|
|
\begin{itemize}
|
|
\item \emph{NP-schwer} ist eine \textbf{untere} Schranke: \glqq mindestens so
|
|
schwer wie alles in $\NP$\grqq.
|
|
\item \emph{$\in \NP$} ist eine \textbf{obere} Schranke: \glqq nicht schwerer
|
|
als $\NP$\grqq.
|
|
\item \emph{NP-vollständig} = beides. Diese Probleme sind exakt die schwersten
|
|
\emph{innerhalb} von $\NP$.
|
|
\end{itemize}
|
|
\end{intuition}
|
|
|
|
\begin{stolper}
|
|
NP-schwer heißt \emph{nicht} automatisch \glqq in $\NP$\grqq. Es gibt Probleme,
|
|
die NP-schwer sind, aber \emph{außerhalb} von $\NP$ liegen -- das Halteproblem
|
|
(Kapitel~\ref{sec:halt}) ist so eines. \glqq Schwer\grqq{} und
|
|
\glqq überhaupt lösbar\grqq{} sind zwei verschiedene Achsen.
|
|
\end{stolper}
|
|
|
|
\subsection{Warum ein einziger Algorithmus alles verändern würde}
|
|
|
|
\begin{satz}{NP-vollständig verbindet $\Pclass$ und $\NP$}
|
|
Ist $L_0$ NP-vollständig, dann gilt: $\Pclass = \NP$ genau dann, wenn
|
|
$L_0 \in \Pclass$.\\
|
|
\emph{Beweisidee:} Läge $L_0$ in $\Pclass$, so könnte man \emph{jedes}
|
|
$L \in \NP$ lösen: erst die Reduktion $L \redp L_0$ rechnen, dann den schnellen
|
|
$L_0$-Löser anwerfen. Also wäre ganz $\NP$ in $\Pclass$.
|
|
\end{satz}
|
|
|
|
\begin{aha}
|
|
Das ist die Sprengkraft der NP-Vollständigkeit. Fände jemand für \emph{ein
|
|
einziges} NP-vollständiges Problem einen polynomiellen Algorithmus, dann wären
|
|
\emph{schlagartig alle} NP-Probleme effizient lösbar -- $\Pclass = \NP$.
|
|
Umgekehrt: Solange das niemandem gelingt, ist ein NP-Vollständigkeitsbeweis das
|
|
stärkste bekannte Indiz \glqq dieses Problem hat vermutlich keinen effizienten
|
|
Algorithmus\grqq.
|
|
\end{aha}
|
|
|
|
\subsection{Das erste NP-vollständige Problem: Cook--Levin}
|
|
|
|
Damit die Reduktionskette starten kann, braucht man \emph{ein} NP-vollständiges
|
|
Problem \glqq von Hand\grqq -- ohne sich auf ein anderes stützen zu können. Das
|
|
lieferten Cook und Levin. Das Problem heißt \problem{SAT}: Gegeben eine
|
|
aussagenlogische Formel, gibt es eine Belegung der Variablen, die sie wahr macht?
|
|
|
|
\begin{satz}{Cook (1971), Levin (1973)}
|
|
\problem{SAT} ist NP-vollständig.\\
|
|
\emph{Beweisidee:} Man nimmt ein \emph{beliebiges} Problem $L \in \NP$ mit seiner
|
|
ratenden Maschine und \glqq gießt\grqq{} deren Rechnung in eine Formel: Variablen
|
|
beschreiben \glqq welcher Zustand zur Zeit $t$\grqq, \glqq was steht auf dem
|
|
Band\grqq{} usw. Die Formel ist so gebaut, dass ihre \emph{erfüllenden
|
|
Belegungen genau den akzeptierenden Rechenwegen entsprechen}. Also:
|
|
$L$-Ja-Instanz $\iff$ Formel erfüllbar. Da $L$ beliebig war, ist \problem{SAT}
|
|
schwer für ganz $\NP$.
|
|
\end{satz}
|
|
|
|
Du musst diesen Beweis nicht im Detail können. Wichtig ist die Rolle: \problem{SAT}
|
|
ist der \emph{Anker}. Ab hier braucht man nie wieder \glqq alle $L \in \NP$\grqq{}
|
|
zu betrachten.
|
|
|
|
\subsection{Der Motor: das Vererbungskorollar}
|
|
|
|
\begin{satz}{Vererbungskorollar}
|
|
Ist $L_0$ bereits NP-vollständig, gilt $L_0 \redp L_1$, und liegt $L_1 \in \NP$,
|
|
dann ist auch $L_1$ NP-vollständig.\\
|
|
\emph{Beweisidee:} Für jedes $L \in \NP$ gilt $L \redp L_0 \redp L_1$
|
|
(Transitivität). Also ist $L_1$ NP-schwer; zusammen mit $L_1 \in \NP$ ist es
|
|
NP-vollständig.
|
|
\end{satz}
|
|
|
|
\begin{aha}
|
|
Das ist das Arbeitspferd. Um ein neues Problem als NP-vollständig zu entlarven,
|
|
brauchst du nur zwei Dinge:
|
|
\begin{enumerate}
|
|
\item eine \emph{Reduktion} von \emph{einem} bekannten NP-vollständigen Problem
|
|
auf das neue, und
|
|
\item den Nachweis, dass das neue Problem in $\NP$ liegt (Zertifikat angeben).
|
|
\end{enumerate}
|
|
Kein Wort mehr über \glqq alle $L \in \NP$\grqq. So wächst die Liste der
|
|
NP-vollständigen Probleme Schritt für Schritt -- genau das machen wir im nächsten
|
|
Kapitel.
|
|
\end{aha}
|
|
|
|
\begin{selbstcheck}
|
|
Du zeigst $\problem{SAT} \redp Y$ und weist nach, dass $Y \in \NP$. Was folgt
|
|
-- und welchen der beiden Teile darfst du auf keinen Fall vergessen?\\[0.3em]
|
|
\emph{Antwort:} Es folgt: $Y$ ist NP-vollständig. Vergiss nie den Teil
|
|
$Y \in \NP$. Ohne ihn hast du nur NP-\emph{Schwere} gezeigt, nicht
|
|
Vollständigkeit -- $Y$ könnte sonst noch schwerer als $\NP$ sein.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Der Problem-Zoo}\label{sec:zoo}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir gehen die Probleme der Vorlesung durch -- aber nicht als Liste zum Auswendig\-lernen,
|
|
sondern als \emph{Familie}, die über Reduktionen zusammenhängt. Zu jedem:
|
|
worum es geht, warum es schwer ist, woher die Schwere kommt.
|
|
\end{ziel}
|
|
|
|
\subsection{Die Landkarte: eine Kette ab SAT}
|
|
|
|
Alle folgenden Probleme sind NP-vollständig. Der Beweis ist immer dasselbe
|
|
Rezept (Vererbungskorollar): reduziere von einem schon bekannten Problem und
|
|
zeige $\in \NP$. Der Pfeil $\redp$ heißt \glqq wird reduziert auf\grqq.
|
|
|
|
\begin{center}
|
|
\small
|
|
\begin{tabular}{ccccc}
|
|
& & $\boxed{\textbf{\problem{SAT}}}$ {\footnotesize (Cook--Levin)} & & \\[0.4em]
|
|
$\swarrow$ & & $\downarrow$ & & $\searrow$ \\[0.4em]
|
|
$\problem{3-SAT}$ & & $\problem{$k$-Clique}$ & & $\problem{3-DM}$ \\[0.4em]
|
|
$\downarrow$ & & $\downarrow$ & & $\downarrow$ \\[0.4em]
|
|
$\problem{$k$-Color}$ & & $\problem{IS},\ \problem{VC}$ & & $\problem{3-EC}$ \\[0.4em]
|
|
$\downarrow$ & & & & $\downarrow$ \\[0.4em]
|
|
$\problem{3-SAT}'\!\to\!\problem{HK}\!\to\!\problem{TSP}$ & & & & $\problem{SubSet Sum}$ \\[0.4em]
|
|
& & & & $\downarrow$ \\[0.4em]
|
|
& & & & $\problem{Partition}\to P\|\Cmax;\ \problem{Knapsack}$ \\
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\begin{intuition}
|
|
Halte dir beim Lesen immer die Frage vor Augen: \glqq Von welchem Nachbarn erbt
|
|
dieses Problem seine Schwere?\grqq{} Das ist der rote Faden. Die Probleme sind
|
|
nicht einzeln schwer -- sie sind \emph{gemeinsam} schwer, verbunden durch die
|
|
Pfeile.
|
|
\end{intuition}
|
|
|
|
\subsection{Die Logik-Probleme}
|
|
|
|
\begin{defn}{SAT und 3-SAT}
|
|
\problem{SAT}: Gegeben eine Formel in \emph{konjunktiver Normalform} (KNF) --
|
|
also ein UND von Klauseln, jede Klausel ein ODER von Literalen ($x_j$ oder
|
|
$\neg x_j$). Frage: gibt es eine erfüllende Belegung?\\
|
|
\problem{3-SAT}: dasselbe, aber jede Klausel hat höchstens 3 Literale.
|
|
\end{defn}
|
|
|
|
\begin{bsp}{SAT von Hand}
|
|
$\alpha = (x_1 \vee x_{10}) \wedge (x_1 \vee \neg x_{10}) \wedge (x_{10})$.
|
|
Die dritte Klausel erzwingt $x_{10} = \true$. Dann verlangt die zweite Klausel
|
|
$x_1 = \true$. Beide gesetzt, ist auch die erste erfüllt. Also erfüllbar mit
|
|
$x_1 = x_{10} = \true$.
|
|
\end{bsp}
|
|
|
|
\problem{SAT} ist der Anker (Cook--Levin). \problem{3-SAT} ist die
|
|
\glqq handliche\grqq{} Version, von der aus fast alle weiteren Reduktionen
|
|
starten -- kurze Klauseln sind leichter zu verbauen.
|
|
|
|
\begin{zushang}
|
|
$\problem{SAT} \redp \problem{3-SAT}$: Man spaltet jede lange Klausel mit
|
|
Hilfsvariablen in eine Kette von 3er-Klauseln auf, ohne die Erfüllbarkeit zu
|
|
ändern. Dadurch bleibt \problem{3-SAT} genauso schwer wie \problem{SAT}.
|
|
\end{zushang}
|
|
|
|
\subsection{Die Graph-Probleme und ihr Dreieck}
|
|
|
|
Drei Probleme, die im Grunde ein einziges sind -- nur aus drei Blickwinkeln.
|
|
|
|
\begin{defn}{Clique, Independent Set, Vertex Cover}
|
|
Gegeben ein Graph $G$ und eine Zahl $k$.
|
|
\begin{itemize}
|
|
\item \problem{Clique}: eine Gruppe $C$, in der \emph{alle} paarweise verbunden
|
|
sind; gibt es eine mit $|C| \ge k$?
|
|
\item \problem{Independent Set (IS)}: eine Gruppe $I$, in der \emph{keine} zwei
|
|
verbunden sind; gibt es eine mit $|I| \ge k$?
|
|
\item \problem{Vertex Cover (VC)}: eine Knotenmenge $C$, die \emph{jede} Kante
|
|
berührt; gibt es eine mit $|C| \le k$?
|
|
\end{itemize}
|
|
\end{defn}
|
|
|
|
\begin{aha}
|
|
\textbf{Das Dualitätsdreieck.} Diese drei sind dasselbe Problem in
|
|
Verkleidung. In einem Graphen mit $n$ Knoten gilt:
|
|
\begin{align*}
|
|
C \text{ ist Clique in } G
|
|
&\iff C \text{ ist Independent Set im Komplementgraphen } \bar G\\
|
|
&\iff V \setminus C \text{ ist Vertex Cover in } \bar G.
|
|
\end{align*}
|
|
Merksatz: \emph{Vertex Cover = alles außer einem Independent Set}; \emph{Clique =
|
|
Independent Set, wenn man alle Kanten umdreht}. Verstehst du eines, verstehst du
|
|
alle drei -- und die Reduktionen zwischen ihnen sind bloße Umformulierungen.
|
|
\end{aha}
|
|
|
|
\begin{bsp}{Das Dreieck an einem Mini-Graphen}
|
|
Nimm ein Dreieck plus einen isolierten vierten Knoten:
|
|
$V = \{1,2,3,4\}$, Kanten $\{1,2\},\{1,3\},\{2,3\}$.
|
|
$\{1,2,3\}$ ist eine \emph{Clique} (alle verbunden). Im Komplement $\bar G$
|
|
(Kanten $\{1,4\},\{2,4\},\{3,4\}$) ist $\{1,2,3\}$ ein \emph{Independent Set}
|
|
(keine zwei verbunden). Und $\{4\}$ ist dort ein \emph{Vertex Cover} -- der
|
|
Knoten 4 berührt alle Kanten von $\bar G$. Ein Bild, drei Rollen.
|
|
\end{bsp}
|
|
|
|
\begin{defn}{Färbung und Hamiltonkreis}
|
|
\problem{$k$-Color}: Kann man die Knoten mit $k$ Farben so färben, dass keine
|
|
Kante zwei gleichfarbige Enden hat?\\
|
|
\problem{Hamiltonkreis (HK)}: Gibt es einen Rundweg, der \emph{jeden} Knoten
|
|
genau einmal besucht?
|
|
\end{defn}
|
|
|
|
Diese beiden sind \glqq berühmte\grqq{} schwere Probleme. \problem{$k$-Color}
|
|
erbt seine Schwere von \problem{3-SAT}, \problem{HK} von der 3-Literal-Variante
|
|
$\problem{3-SAT}'$.
|
|
|
|
\subsection{Eine Reduktion ganz durchgerechnet: $\problem{SAT} \redp \problem{$k$-Clique}$}
|
|
|
|
Damit du \emph{siehst}, wie eine Reduktion konkret arbeitet, hier eine komplett.
|
|
|
|
\begin{intuition}
|
|
Idee: Baue für jedes Literal-Vorkommen einen Knoten. Verbinde zwei Knoten genau
|
|
dann, wenn sie \emph{aus verschiedenen Klauseln} stammen und sich \emph{nicht
|
|
widersprechen}. Eine erfüllende Belegung wählt aus jeder Klausel ein wahres
|
|
Literal -- und diese Auswahl bildet dann eine Clique.
|
|
\end{intuition}
|
|
|
|
\begin{defn}{Die Konstruktion}
|
|
Zur Formel $F = F_1 \wedge \dots \wedge F_m$ (Klausel $F_i$ mit Literalen
|
|
$y_{i1},\dots$):
|
|
\begin{itemize}
|
|
\item \emph{Knoten:} $[i,j]$ für das $j$-te Literal in Klausel $i$.
|
|
\item \emph{Kanten:} $\{[i,j],[i',j']\}$ genau dann, wenn $i \ne i'$ (verschiedene
|
|
Klauseln) und die beiden Literale sich nicht widersprechen (nicht $x$ und
|
|
$\neg x$).
|
|
\item \emph{Gesuchte Cliquengröße:} $k = m$ (Anzahl der Klauseln).
|
|
\end{itemize}
|
|
\end{defn}
|
|
|
|
\emph{Warum es stimmt.} Eine $m$-Clique muss aus jeder Klausel genau einen
|
|
Knoten nehmen (Knoten derselben Klausel sind nie verbunden) und darf keine zwei
|
|
widersprüchlichen Literale enthalten. Das ist \emph{genau} eine Belegung, die
|
|
in jeder Klausel ein Literal wahr macht -- also eine erfüllende Belegung. Und
|
|
umgekehrt.
|
|
|
|
\begin{bsp}{Mit echten Zahlen}
|
|
$F = (x_1 \vee x_2 \vee x_3) \wedge (\neg x_1 \vee \neg x_2) \wedge
|
|
(x_1 \vee \neg x_2 \vee \neg x_3)$, also $m = 3$, gesucht $k = 3$.
|
|
Es entstehen 8 Knoten (3 + 2 + 3). Kanten zwischen allen Paaren aus
|
|
verschiedenen Klauseln \emph{außer} den widersprüchlichen, z.\,B. bekommt
|
|
$\{[1,1],[2,1]\}$ ($x_1$ gegen $\neg x_1$) \emph{keine} Kante.
|
|
Die Clique $\{[1,1],[2,2],[3,1]\}$ steht für $x_1,\ \neg x_2,\ x_1$ und liefert
|
|
die Belegung $x_1 = \true$, $x_2 = \false$ (und $x_3$ frei). Tatsächlich erfüllt
|
|
das $F$.
|
|
\end{bsp}
|
|
|
|
\subsection{Die Zahl- und Mengen-Probleme}
|
|
|
|
\begin{defn}{3-DM, 3-EC, SubSet Sum, Partition, Knapsack}
|
|
\begin{itemize}
|
|
\item \problem{3-dim. Matching (3-DM)}: drei gleich große Mengen und Tripel;
|
|
wähle Tripel, die jedes Element genau einmal treffen.
|
|
\item \problem{3-Exact Cover (3-EC)}: 3-elementige Mengen; wähle einige, die
|
|
das Universum \emph{exakt} (disjunkt) überdecken.
|
|
\item \problem{SubSet Sum}: Zahlen $c_1,\dots,c_n$ und Ziel $K$; gibt es eine
|
|
Teilmenge mit Summe genau $K$?
|
|
\item \problem{Partition}: gibt es eine Teilmenge, die genau die \emph{Hälfte}
|
|
der Gesamtsumme trägt?
|
|
\item \problem{Knapsack}: Gegenstände mit Gewicht und Profit, Kapazität $B$,
|
|
Zielprofit $P$; passt eine Auswahl mit Gewicht $\le B$ und Profit $\ge P$?
|
|
\end{itemize}
|
|
\end{defn}
|
|
|
|
\begin{zushang}
|
|
Diese fünf hängen in einer sauberen Kette:
|
|
$\problem{SAT}\redp\problem{3-DM}\redp\problem{3-EC}\redp\problem{SubSet Sum}
|
|
\redp\problem{Partition}$, und \problem{Knapsack} enthält \problem{SubSet Sum}
|
|
als Spezialfall ($w_j = p_j$, $P = B$). Schwere fließt von der Logik (\problem{SAT})
|
|
über Mengen (\problem{3-EC}) bis zu reinen Zahlen (\problem{SubSet Sum}).
|
|
\end{zushang}
|
|
|
|
\subsection{Zwei kurze, elegante Reduktionen}
|
|
|
|
\begin{bsp}{$\problem{3-EC} \redp \problem{SubSet Sum}$ -- Mengen werden Ziffern}
|
|
Kodiere jede 3-elementige Menge als Bitvektor über dem Universum und lies ihn
|
|
als Zahl zur \emph{Basis $n+1$}. Beispiel: $U = \{u_1,\dots,u_6\}$, Menge
|
|
$\{u_1,u_5,u_6\}$ wird zum Bitvektor $100011$, also zur Zahl
|
|
$(n{+}1)^0 + (n{+}1)^4 + (n{+}1)^5$. Zielwert $K$ ist die Zahl zum Vektor
|
|
$111111$.\\
|
|
\emph{Der Trick:} Bei Basis $n+1$ und höchstens $n$ Summanden gibt es
|
|
\emph{keinen Übertrag}. Eine Teilmenge trifft die Zielsumme genau dann, wenn
|
|
jede Stelle exakt einmal getroffen wird -- also eine exakte Überdeckung.
|
|
\end{bsp}
|
|
|
|
\begin{bsp}{$\problem{SubSet Sum} \redp \problem{Partition}$ -- zwei Zusatzzahlen}
|
|
Aus $(c_1,\dots,c_n,K)$ mit $N = \sum_j c_j + 1$ mache die Zahlenmenge, ergänzt
|
|
um $c_{n+1} = N-K$ und $c_{n+2} = K+1$. Die Gesamtsumme ist dann $2N$, die
|
|
Hälfte $N$.\\
|
|
\emph{Der Trick:} Die zwei Zusatzzahlen summieren sich zu $N+1$ -- sie können
|
|
also nie in derselben Hälfte landen. Eine Halbierung existiert genau dann, wenn
|
|
eine Original-Teilmenge den Wert $K$ trifft.
|
|
\end{bsp}
|
|
|
|
\begin{defn}{Scheduling: $P\|\Cmax$}
|
|
$n$ Jobs mit Laufzeiten $p_1,\dots,p_n$, $m$ identische Maschinen. Verteile die
|
|
Jobs so, dass die am stärksten belastete Maschine -- der \emph{Makespan}
|
|
$\Cmax = \max_i \sum_{J_j \text{ auf } M_i} p_j$ -- minimal wird.
|
|
\end{defn}
|
|
|
|
\begin{zushang}
|
|
$P\|\Cmax$ ist schon für $m = 2$ Maschinen NP-vollständig -- über
|
|
$\problem{Partition} \redp P2\|\Cmax$: Zwei Maschinen exakt gleich auszulasten,
|
|
heißt die Jobs zu \emph{halbieren}. Damit schließt sich der Kreis von der Logik
|
|
bis zum Scheduling.
|
|
\end{zushang}
|
|
|
|
\begin{selbstcheck}
|
|
Warum ist \problem{SubSet Sum} \glqq schwer\grqq, obwohl es doch nur um Addieren
|
|
von Zahlen geht?\\[0.3em]
|
|
\emph{Antwort:} Weil die Zahlen \emph{binär} kodiert sind (Stolperstein aus
|
|
Kapitel 2). Ihr Wert ist exponentiell in der Eingabelänge. Alle Teilsummen
|
|
auszuprobieren bedeutet $2^n$ Teilmengen -- das simple \glqq Addieren\grqq{}
|
|
versteckt eine exponentielle Suche.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Wie schwer \emph{genau}? Die ETH}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
NP-Vollständigkeit sagt nur \glqq vermutlich nicht polynomiell\grqq. Aber
|
|
\emph{wie} exponentiell? Die Exponentialzeit-Hypothese (ETH) gibt eine schärfere
|
|
Antwort -- und erlaubt konkrete untere Laufzeitschranken.
|
|
\end{ziel}
|
|
|
|
\subsection{Die Lücke, die NP-Vollständigkeit lässt}
|
|
|
|
NP-Vollständigkeit ist ein grobes Sieb. Sie unterscheidet nicht zwischen einem
|
|
Problem, das $2^n$ braucht, und einem, das nur $2^{\sqrt n}$ braucht -- beide
|
|
sind \glqq nicht polynomiell\grqq. Für viele Fragen will man aber genau wissen:
|
|
\emph{Geht es wenigstens subexponentiell?}
|
|
|
|
\begin{defn}{Klein-o und \glqq subexponentiell\grqq}
|
|
$f(n) = o(g(n))$ heißt: $f$ wächst \emph{echt langsamer} als $g$, also
|
|
$f(n)/g(n) \to 0$. Wichtig: $\delta n$ ist \emph{nicht} $o(n)$ für festes
|
|
$\delta > 0$. Ein \glqq $2^{o(n)}$-Algorithmus\grqq{} ist einer, dessen Exponent
|
|
langsamer als linear wächst -- er läuft \emph{subexponentiell} (z.\,B.
|
|
$2^{\sqrt n}$).
|
|
\end{defn}
|
|
|
|
\subsection{Die Hypothese und warum man sie braucht}
|
|
|
|
\begin{defn}{Exponentialzeit-Hypothese (ETH)}
|
|
Es gibt eine Konstante $\delta > 0$, sodass \problem{3-SAT} mit $n$ Variablen
|
|
\emph{nicht} in Zeit $2^{\delta n}\cdot\poly$ gelöst werden kann. Kurz: es gibt
|
|
\emph{keinen} $2^{o(n)}$-Algorithmus für \problem{3-SAT}.
|
|
\end{defn}
|
|
|
|
Das ist eine \emph{Annahme}, stärker als $\Pclass \ne \NP$, aber allgemein
|
|
geglaubt (die besten bekannten 3-SAT-Algorithmen brauchen $c^n$). Aus ihr leitet
|
|
man untere Schranken für viele Probleme ab.
|
|
|
|
\begin{intuition}
|
|
Das Beweismuster ist immer \emph{Kontraposition über eine Reduktion}: \glqq Gäbe
|
|
es einen zu schnellen Algorithmus für mein Zielproblem, dann ergäbe die Reduktion
|
|
einen zu schnellen Algorithmus für 3-SAT -- Widerspruch zur ETH.\grqq{} Man
|
|
überträgt also die Härte-Annahme entlang eines Pfeils, genau wie bei der
|
|
NP-Vollständigkeit -- nur zählt man diesmal die \emph{Größe} der konstruierten
|
|
Instanz mit.
|
|
\end{intuition}
|
|
|
|
\begin{satz}{Sparsification-Lemma (und warum es nötig ist)}
|
|
Unter der ETH gibt es sogar keine $2^{o(m)}$-Lösung für \problem{3-SAT}, wobei
|
|
$m$ die \emph{Klauselzahl} ist.\\
|
|
\emph{Warum man das braucht:} Die ETH spricht über die Variablenzahl $n$. Viele
|
|
Reduktionen erzeugen ihre Instanzgröße aber aus der Klauselzahl $m$. Weil $m$
|
|
gegenüber $n$ groß sein kann, folgt eine $m$-Schranke \emph{nicht} direkt aus
|
|
der ETH. Das Sparsification-Lemma schließt genau diese Lücke.
|
|
\end{satz}
|
|
|
|
\begin{aha}
|
|
Faustregel für die Praxis: \emph{Hängt der Parameter deiner konstruierten
|
|
Instanz an der Klauselzahl $m$, zitiere das Sparsification-Lemma.} Das ist der
|
|
Standardschritt in jedem ETH-Beweis -- und der, den man am leichtesten vergisst.
|
|
\end{aha}
|
|
|
|
Unter der ETH bekommt man so untere Schranken $2^{o(n)}$ z.\,B. für
|
|
\problem{3-Color}, \problem{Clique}, \problem{Vertex Cover}, \problem{Independent
|
|
Set} sowie \problem{SubSet Sum} und \problem{Partition}.
|
|
|
|
\begin{selbstcheck}
|
|
Wenn die ETH \emph{falsch} ist -- folgt dann $\Pclass = \NP$?\\[0.3em]
|
|
\emph{Antwort:} Nein. \glqq ETH falsch\grqq{} heißt nur: 3-SAT geht in
|
|
$2^{o(n)}$ -- das kann immer noch superpolynomiell sein, z.\,B. $2^{\sqrt n}$.
|
|
Umgekehrt gilt aber: $\Pclass = \NP$ würde die ETH sofort widerlegen.
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Damit leben: gute Näherungen}\label{sec:approx}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wenn ein Problem (vermutlich) keine schnelle \emph{exakte} Lösung hat, geben wir
|
|
uns mit einer \emph{beweisbar guten} Näherung zufrieden. Wir lernen, was
|
|
\glqq beweisbar gut\grqq{} heißt, und sehen die wichtigsten Näherungsalgorithmen
|
|
der Vorlesung in Aktion.
|
|
\end{ziel}
|
|
|
|
\subsection{Was heißt \glqq gute Näherung\grqq?}
|
|
|
|
\begin{defn}{Multiplikative Güte}
|
|
Sei $\OPT(I)$ der optimale Wert einer Instanz $I$. Ein Algorithmus $A$ hat
|
|
\emph{Güte $\alpha$}, wenn für \emph{alle} Instanzen gilt:
|
|
\begin{itemize}
|
|
\item Minimierung (z.\,B. TSP, Scheduling): $A(I) \le \alpha\cdot\OPT(I)$ --
|
|
\glqq höchstens $\alpha$-mal so groß wie das Optimum\grqq.
|
|
\item Maximierung (z.\,B. Knapsack): $\OPT(I) \le \alpha\cdot A(I)$ --
|
|
\glqq mindestens ein $\alpha$-tel des Optimums\grqq.
|
|
\end{itemize}
|
|
Die Güte ist \emph{scharf}, wenn es Instanzen gibt, die den Faktor (fast)
|
|
erreichen.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Güte $\alpha$ ist eine \emph{Garantie für den schlimmsten Fall}. Güte 2 bei
|
|
einem Minimierungsproblem heißt: Egal welche Eingabe -- meine Lösung ist nie
|
|
mehr als doppelt so teuer wie die beste mögliche. Kleineres $\alpha$ ist besser;
|
|
$\alpha = 1$ wäre exakt optimal.
|
|
\end{intuition}
|
|
|
|
\begin{defn}{PTAS, EPTAS, FPTAS -- Näherung nach Wunsch}
|
|
Manche Probleme erlauben eine \emph{ganze Familie} $(A_\varepsilon)$ mit Güte
|
|
$1+\varepsilon$ für \emph{jedes} $\varepsilon > 0$ -- man stellt die Genauigkeit
|
|
selbst ein. Nach Laufzeit gestaffelt:
|
|
\begin{itemize}
|
|
\item \emph{PTAS}: für jedes feste $\varepsilon$ polynomiell in $n$ (aber
|
|
$\varepsilon$ darf im Exponenten stecken, z.\,B. $n^{1/\varepsilon}$).
|
|
\item \emph{EPTAS}: Laufzeit $f(1/\varepsilon)\cdot\poly(n)$ -- $\varepsilon$
|
|
raus aus dem Exponenten von $n$.
|
|
\item \emph{FPTAS}: polynomiell in $n$ \emph{und} $1/\varepsilon$ (z.\,B.
|
|
$O(n^3/\varepsilon)$). Die stärkste Form.
|
|
\end{itemize}
|
|
\emph{Pseudopolynomiell} nennt man eine Laufzeit, die polynomiell in den
|
|
\emph{Zahlenwerten} der Eingabe ist -- erinnere den Stolperstein: das ist
|
|
\emph{nicht} polynomiell in der Eingabelänge.
|
|
\end{defn}
|
|
|
|
\subsection{TSP: von \glqq unmöglich\grqq{} zu Güte $1{,}5$}
|
|
|
|
Das Traveling-Salesman-Problem (kürzeste Rundreise durch alle Städte) zeigt die
|
|
ganze Spannweite der Approximation.
|
|
|
|
\begin{satz}{Allgemeines TSP ist gar nicht approximierbar}
|
|
Für beliebige Distanzen gibt es \emph{keinen} Näherungsalgorithmus mit
|
|
beschränkter Güte -- außer $\Pclass = \NP$.\\
|
|
\emph{Beweisidee:} Reduziere \problem{Hamiltonkreis}. Echte Kanten bekommen
|
|
Distanz 1, fehlende Kanten eine \emph{riesige} Distanz. Ein Algorithmus mit
|
|
beschränkter Güte müsste die billige (Hamilton-)Tour von der teuren
|
|
unterscheiden -- und könnte damit \problem{HK} exakt lösen.
|
|
\end{satz}
|
|
|
|
Der Ausweg ist eine sinnvolle Zusatzannahme: das \emph{metrische} TSP. Distanzen
|
|
sind symmetrisch und erfüllen die \emph{Dreiecksungleichung}
|
|
$d(i,j) \le d(i,k) + d(k,j)$ -- ein Umweg ist nie kürzer als der direkte Weg.
|
|
Das ist realistisch (echte Entfernungen) und macht das Problem approximierbar.
|
|
|
|
\begin{defn}{Eulerkreis}
|
|
Ein \emph{Eulerkreis} in einem (Multi-)Graphen ist ein Rundweg, der jede
|
|
\emph{Kante} genau einmal benutzt. Er existiert genau dann, wenn der Graph
|
|
zusammenhängend ist und \emph{jeder Knoten geraden Grad} hat.
|
|
\end{defn}
|
|
|
|
\begin{intuition}
|
|
Beide TSP-Algorithmen folgen demselben Dreisprung: (1) baue ein billiges Gerüst,
|
|
das alle Städte verbindet (einen minimalen Spannbaum), (2) mache daraus einen
|
|
Eulerkreis (alle Grade gerade), (3) kürze ihn zu einer Tour ab -- was dank
|
|
Dreiecksungleichung nie teurer wird.
|
|
\end{intuition}
|
|
|
|
\begin{defn}{$\Delta$TSP$_1$ -- MST-Verdopplung (Güte 2)}
|
|
\begin{enumerate}
|
|
\item Minimalen Spannbaum $T$ berechnen.
|
|
\item Jede Kante von $T$ verdoppeln $\to$ alle Grade gerade.
|
|
\item Eulerkreis bestimmen.
|
|
\item Zur Tour abkürzen (schon besuchte Städte überspringen).
|
|
\end{enumerate}
|
|
\emph{Warum Güte 2:} $w(T) \le \OPT$ (eine optimale Tour minus eine Kante ist
|
|
ein Spannbaum), Verdoppeln gibt $2w(T)$, Abkürzen verlängert nicht. Also
|
|
$\le 2\,\OPT$.
|
|
\end{defn}
|
|
|
|
\begin{bsp}{$\Delta$TSP$_1$ komplett durchgerechnet}
|
|
Städte $\{A,B,C,D,E\}$ mit u.\,a. $d(A,E)=1$, $d(B,C)=1$, $d(A,C)=2$,
|
|
$d(C,D)=2$ (die übrigen 2 oder 3). Optimale Tour: $[C,B,D,E,A,C]$ mit Länge
|
|
$\mathbf{8}$.
|
|
\begin{itemize}
|
|
\item \emph{MST} $T$: Kanten $A$--$E\,(1)$, $B$--$C\,(1)$, $A$--$C\,(2)$,
|
|
$C$--$D\,(2)$; Gewicht $w(T)=6$.
|
|
\item \emph{Verdoppeln} $\to$ Multigraph mit Gewicht $12$.
|
|
\item \emph{Eulerkreis} $[C,A,E,A,C,B,C,D,C]$, Länge $12$.
|
|
\item \emph{Abkürzen} $\to$ Tour $[C,A,E,B,D,C]$ mit Länge $\mathbf{10}$
|
|
$\le 2\cdot 8$.
|
|
\end{itemize}
|
|
\end{bsp}
|
|
|
|
Christofides verbessert Schritt 2: Statt \emph{alle} Kanten zu verdoppeln,
|
|
repariert er nur die \glqq schiefen\grqq{} Knoten -- die mit ungeradem Grad.
|
|
|
|
\begin{defn}{$\Delta$TSP$_2$ -- Christofides (Güte $1{,}5$)}
|
|
\begin{enumerate}
|
|
\item Minimalen Spannbaum $T$ berechnen.
|
|
\item $X :=$ Knoten mit \emph{ungeradem} Grad in $T$ (ihre Anzahl ist gerade).
|
|
\item Minimales perfektes Matching $K$ auf $X$ berechnen.
|
|
\item $T + K$ hat überall geraden Grad $\to$ Eulerkreis $\to$ abkürzen.
|
|
\end{enumerate}
|
|
\emph{Warum Güte $1{,}5$:} Das Matching kostet höchstens $\OPT/2$ (die optimale
|
|
Tour zerfällt auf $X$ in zwei Matchings), also $\le w(T) + \OPT/2 \le 1{,}5\,\OPT$.
|
|
\end{defn}
|
|
|
|
\begin{bsp}{Christofides am selben Graphen}
|
|
MST wie oben. Ungerade Grade: $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\}$ mit Gewicht $3$. Der Eulerkreis
|
|
$[C,B,C,A,E,D,C]$ kürzt ab zu $[C,B,A,E,D,C]$ mit Länge $\mathbf{9}$ -- besser
|
|
als die $10$ von $\Delta$TSP$_1$.
|
|
\end{bsp}
|
|
|
|
\begin{stolper}
|
|
Zwei Details, die Christofides oft falsch gemacht wird: (1) Das Matching wird
|
|
\emph{nur} auf den ungerad-gradigen Knoten des MST gebildet, nicht auf allen.
|
|
(2) Ohne die Dreiecksungleichung bricht das Abkürzen zusammen -- nur sie
|
|
garantiert, dass die abgekürzte Tour nicht länger wird.
|
|
\end{stolper}
|
|
|
|
\subsection{Knapsack: warum Gier allein scheitert}
|
|
|
|
Der Rucksack als Optimierungsproblem: pack Gegenstände mit maximalem Gesamtprofit
|
|
ein, ohne die Kapazität $B$ zu sprengen.
|
|
|
|
\begin{intuition}
|
|
Der naheliegende \emph{Greedy}: nach \glqq Profit pro Gewicht\grqq{} sortieren
|
|
und der Reihe nach einpacken, was passt. Meistens gut -- aber ohne jede
|
|
Garantie.
|
|
\end{intuition}
|
|
|
|
\begin{bsp}{Greedy kann beliebig schlecht sein}
|
|
Zwei Gegenstände: $(w_0,p_0) = (1,1)$ und $(w_1,p_1) = (B, B-1)$, Kapazität $B$.
|
|
Greedy nimmt Gegenstand 0 (Dichte 1 schlägt $(B-1)/B$), Gewinn nur $1$. Optimal
|
|
wäre Gegenstand 1 mit Gewinn $B-1$. Das Verhältnis $\OPT/\mathrm{GA} = B-1$
|
|
wächst unbeschränkt -- \emph{keine} konstante Güte.
|
|
\end{bsp}
|
|
|
|
\begin{aha}
|
|
Die Reparatur ist verblüffend einfach. \emph{Modified Greedy (MGA):} rechne
|
|
Greedy \emph{und} \glqq nimm nur den einen profitabelsten Gegenstand\grqq, gib
|
|
das Bessere aus. Schon das garantiert Güte 2. Der Grund: Greedy verliert nur am
|
|
einen \glqq Split-Item\grqq, das nicht mehr passte -- und dessen Profit fängt
|
|
das Einzel-Item ab.
|
|
\end{aha}
|
|
|
|
Will man noch näher ans Optimum, gibt es zwei Stufen: der \emph{Sahni}-Algorithmus
|
|
probiert alle kleinen Vorauswahlen (Güte $1 + 1/k$, ein PTAS), und das
|
|
\emph{FPTAS} skaliert die Profite herunter und löst exakt per dynamischer
|
|
Programmierung -- Güte $1+\varepsilon$ in Zeit $O(n^3/\varepsilon)$.
|
|
|
|
\subsection{Scheduling: einfache Regeln, scharfe Schranken}
|
|
|
|
Zurück zu $P\|\Cmax$: $n$ Jobs auf $m$ Maschinen, minimiere die höchste Last.
|
|
|
|
\begin{defn}{List Scheduling und LPT}
|
|
\emph{List Scheduling:} geh die Jobs der Reihe nach durch, leg jeden auf die
|
|
\emph{momentan am wenigsten belastete} Maschine.\\
|
|
\emph{LPT (Longest Processing Time):} sortiere die Jobs zuerst \emph{absteigend},
|
|
dann List Scheduling.
|
|
\end{defn}
|
|
|
|
\begin{satz}{Güten von List Scheduling und LPT}
|
|
List Scheduling hat Güte $2 - \frac1m$, LPT die bessere Güte
|
|
$\frac43 - \frac1{3m}$ -- beide scharf.\\
|
|
\emph{Beweisidee (List Scheduling):} Sei $J_k$ der letzte Job auf der vollsten
|
|
Maschine. Vor seiner Zuweisung war diese Maschine die leerste, also waren
|
|
\emph{alle} mindestens so voll. Mit den zwei Universalschranken
|
|
$\OPT \ge \frac1m\sum p_i$ (Durchschnittslast) und $\OPT \ge p_{\max}$ (größter
|
|
Job) folgt die Schranke.
|
|
\end{satz}
|
|
|
|
\begin{intuition}
|
|
Diese \emph{zwei Schranken} -- Durchschnittslast und größter Job -- sind das
|
|
Universalwerkzeug \emph{aller} Scheduling-Güte-Beweise. Sortieren (LPT) hilft,
|
|
weil der störende \glqq letzte große Job\grqq{} dann früh drankommt, wenn noch
|
|
alles leer ist.
|
|
\end{intuition}
|
|
|
|
\begin{bsp}{Warum List Scheduling die Schranke wirklich erreicht}
|
|
$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
|
|
setzt den großen obendrauf: Last $2m-1$. Optimal wäre: großer Job allein, Einsen
|
|
auf die restlichen Maschinen -- Last $m$. Verhältnis $\frac{2m-1}{m} = 2 - \frac1m$.
|
|
LPT würde den großen Job zuerst legen und das vermeiden.
|
|
\end{bsp}
|
|
|
|
\subsection{MAX-3-SAT: Güte 2 fast geschenkt}\label{sec:max3sat}
|
|
|
|
\begin{bsp}{Zwei Belegungen genügen}
|
|
Maximiere die Zahl erfüllter Klauseln. Werte die Formel nur zweimal aus: einmal
|
|
\glqq alles falsch\grqq{} ($\beta_0$), einmal \glqq alles wahr\grqq{} ($\beta_1$),
|
|
nimm das Bessere. Jede Klausel hat ein positives \emph{oder} ein negatives
|
|
Literal, wird also von $\beta_0$ \emph{oder} $\beta_1$ erfüllt. Damit erfüllen
|
|
beide zusammen $\ge m$ Klauseln, die bessere also $\ge m/2 \ge \OPT/2$. Güte 2
|
|
mit zwei Zeilen Aufwand.
|
|
\end{bsp}
|
|
|
|
\begin{selbstcheck}
|
|
Warum braucht Christofides zwingend die Dreiecksungleichung, $\Delta$TSP$_1$
|
|
scheinbar auch, das allgemeine TSP aber \glqq gibt es gar nicht\grqq?\\[0.3em]
|
|
\emph{Antwort:} Beide Näherungsalgorithmen \emph{kürzen} einen Eulerkreis ab --
|
|
das darf nur nicht verteuern, was allein die Dreiecksungleichung sichert. Ohne
|
|
sie (allgemeines TSP) kann Abkürzen beliebig teuer werden, und tatsächlich ist
|
|
dort \emph{jede} beschränkte Güte unmöglich (außer $\Pclass = \NP$).
|
|
\end{selbstcheck}
|
|
|
|
% ##################################################################
|
|
\section{Jenseits von NP: das Halteproblem}\label{sec:halt}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Ein kurzer Blick über den Rand: ein Problem, das NP-schwer ist -- aber
|
|
\emph{gar nicht} in $\NP$ liegt, weil es überhaupt nicht lösbar ist. Das zeigt,
|
|
dass \glqq schwer\grqq{} und \glqq in NP\grqq{} wirklich zwei verschiedene Dinge
|
|
sind.
|
|
\end{ziel}
|
|
|
|
\begin{defn}{Halteproblem}
|
|
Gegeben die Beschreibung eines Programms $M$ und einer Eingabe $w$: \emph{Hält
|
|
$M$ auf $w$ irgendwann an, 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}
|
|
von $M_\varphi$ aus $\varphi$ ist billig, und nur darauf kommt es bei einer
|
|
Reduktion an. Also ist das Halteproblem mindestens so schwer wie \problem{SAT},
|
|
aber es liegt nicht in $\NP$ (nicht einmal entscheidbar). NP-schwer $\ne$
|
|
NP-vollständig.
|
|
\end{aha}
|
|
|
|
% ##################################################################
|
|
\section{Das große Ganze}
|
|
% ##################################################################
|
|
|
|
\begin{ziel}
|
|
Wir ziehen die Fäden zusammen. Eine Landkarte, ein Selbsttest -- und der Weg
|
|
nach vorn.
|
|
\end{ziel}
|
|
|
|
\subsection{Die Reise in einem Bild}
|
|
|
|
\begin{center}
|
|
\small
|
|
\begin{tabular}{p{3.4cm}p{10.4cm}}
|
|
\toprule
|
|
Station & Kernidee \\
|
|
\midrule
|
|
$\Pclass$ & effizient \emph{lösbar} (polynomiell)\\
|
|
$\NP$ & effizient \emph{überprüfbar} (Zertifikat prüfen / raten)\\
|
|
$\Pclass \subseteq \NP$ & Lösen ist schwerer (oder gleich schwer) wie Prüfen; Gleichheit offen\\
|
|
Reduktion $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 zeigen: eine Reduktion + $\in\NP$\\
|
|
ETH & schärfer als NP-Vollständigkeit: konkrete $2^{o(\cdot)}$-Schranken\\
|
|
Approximation & bei schweren Optimierungsproblemen: beweisbar gute Näherung\\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
\subsection{Verständnis-Check: wahr oder falsch?}
|
|
|
|
Kannst du jede Aussage begründen? Die Begründung zählt, nicht das Kreuz.
|
|
|
|
\begin{center}
|
|
\small
|
|
\begin{tabular}{p{7.4cm}cp{4.7cm}}
|
|
\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, aber 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
|
|
$\problem{3-SAT}\in\Pclass$, aber $\problem{Clique}\notin\Pclass$ ist möglich. &
|
|
F & $\problem{Clique}\redp\problem{3-SAT}$; dann wäre auch Clique in $\Pclass$. \\
|
|
\addlinespace
|
|
ETH falsch $\Rightarrow \Pclass = \NP$. & F & $2^{o(n)}$ kann trotzdem
|
|
superpolynomiell sein. \\
|
|
\bottomrule
|
|
\end{tabular}
|
|
\end{center}
|
|
{\footnotesize $^{*}$ nicht als wahr beweisbar; äquivalent zu $\Pclass = \NP$.}
|
|
|
|
\subsection{Wie es weitergeht}
|
|
|
|
\begin{aha}
|
|
Du hast jetzt das \emph{Warum} beisammen: Was Probleme schwer macht, wie man
|
|
Schwere von einem Problem auf ein anderes überträgt, wo die Grenzen liegen und
|
|
was man tut, wenn exakte Lösungen zu teuer sind. Das ist das Fundament.
|
|
\end{aha}
|
|
|
|
\noindent Der nächste Schritt ist die \emph{Praxis}. Nimm dir die Präsenz-,
|
|
Haus- und Klausuraufgaben vor und führe dort selbst aus, was hier nur als Idee
|
|
stand: Reduktionen vollständig beweisen (beide Richtungen!), Güte-Schranken
|
|
sauber herleiten, Worst-Case-Instanzen konstruieren. Dieser Guide gibt dir das
|
|
Verständnis -- die Aufgaben geben dir das Können.
|
|
|
|
\begin{center}
|
|
\itshape Viel Erfolg.
|
|
\end{center}
|
|
|
|
\end{document}
|