Spielzeugbeispiele für Plotkin-Shmoys-Tardos- und Arora-Kale-Löser

Ich möchte verstehen, wie der Arora-Kale-SDP-Löser die Goemans-Williamson-Relaxation in nahezu linearer Zeit approximiert, wie der Plotkin-Shmoys-Tardos-Löser gebrochene "Packungs-" und "Deckungsprobleme" in nahezu linearer Zeit approximiert und wie die Algorithmen sind Instanzen des abstrakten Frameworks "Lernen von Experten".

Die Arbeit von Kale hat eine ausgezeichnete Präsentation, aber ich finde es sehr schwierig, direkt in den abstrakten Rahmen zu springen, und ich würde es vorziehen, von einem Beispiel eines einfachen Problems auszugehen, für das es absolut offensichtlich ist, was zu tun ist, und mich dann allgemeineren Problemen zuzuwenden und fügt dem Algorithmus und seiner Analyse schrittweise "Merkmale" hinzu.

Beispielsweise:

Wie lösen Plotkin-Shmoys die lineare Programmierrelaxation einer ungewichteten Vertex-Abdeckung? Gewichtete Scheitelpunktabdeckung? Deckung setzen? Bipartite Matching?

Was ist das einfachste Beispiel, in dem der Arora-Kale-Algorithmus etwas Interessantes bewirkt? Wie berechnet es den größten Eigenwert des Laplace-Werts eines Graphen?

(Die Berechnung des größten Eigenwerts des Laplace-Werts entspricht dem Problem, eine schwächere Version der Goemans-Williamson-SDP-Relaxation von Max Cut zu lösen, bei der nicht jeder Vektor die Länge eins haben muss, sondern die Summe der Quadrate der Normen zu sein | V |.)

Luca, seit ein Jahr vergangen ist, hast du wahrscheinlich deine eigene Antwort recherchiert. Ich beantworte einige Ihrer Fragen hier nur zur Veranschaulichung. Ich überprüfe einige Lagrange-Relaxationsalgorithmen auf die von Ihnen genannten Probleme und skizziere den Zusammenhang mit dem Lernen (insbesondere unter Befolgung fachmännischer Empfehlungen). Ich kommentiere hier keine SDP-Algorithmen.

Beachten Sie, dass die von Ihnen erwähnten Algorithmen nicht in nahezu linearer Zeit ausgeführt werden. (Es gibt einen nahezu linearen Zeitalgorithmus für explizit gegebene Packungs- oder Abdeckungsprobleme. Siehe Beating Simplex für gebrochenes Packen und Abdecken linearer Programme .) Die Algorithmen, an die Sie denken, haben normalerweise Varianten, die in einer nahezu linearen Anzahl von Iterationen ausgeführt werden Die Iteration erfordert typischerweise auch mindestens eine lineare Zeit. Ich diskutiere einige dieser Algorithmen unten.

Einige nützliche Funktionen

Bevor wir beginnen, sind hier einige Funktionen, die wir in den Proofskizzen verwenden werden. (Wenn Sie an den Algorithmen interessiert sind, aber nicht an den , können Sie .) Definieren Sie für jeden Vektor als . Diese Funktion ist eine Obergrenze für : Analog definieren Sie als , eine Untergrenze für .$y$$\mbox{Lmax}(y)$$\ln \sum_i \exp(y_i)$$\max_i y_i$

$$\max_i y_i ~\le~ \mbox{Lmax}(y) ~\le~ \max_i y_i + \ln m.$$ $\mbox{Lmin}(y)$$-\mbox{Lmax}(-y)$$\min_i y_i$

Der bezeichnen wir mit den Gradienten von Lmin. Wir verwenden , um den Gradienten von Lmax zu bezeichnen.$g(y)$$\nabla \mbox{Lmin}(y)$$G(y)$$\nabla \mbox{Lmax}(y)$

Explizit ist während ist .$g_i(y)$$\exp(-y_i)/\sum_{i'} \exp(-y_{i'})$$G_i(y)$$\exp(y_i)/\sum_{i'} \exp(y_{i'})$

Lmin und Lmax sind in folgendem Sinne glatt : Für alle Vektoren und gilt und $d\in[0,\varepsilon]^n$$y\in R^n$

$$\mbox{Lmin}(y+d) ~\ge~ \mbox{Lmin}(y) ~+~ (1-O(\varepsilon))\, d \cdot g(y)$$ $$\mbox{Lmax}(y+d) ~\le~ \mbox{Lmax}(y) ~+~ (1+O(\varepsilon))\, d \cdot G(y).$$

Man beachte, dass beide Gradienten eine 1-Norm haben, die gleich 1 ist: . (Wir verwenden für die Bezeichnung der 1-Norm.)$|G(y)| = |g(y)| = 1$$|z|$

Man beachte auch, dass für eine Matrix der Gradient der Funktion in Bezug auf (nach der Kettenregel) . Insbesondere kann die partielle Ableitung der Funktion in Bezug explizit auf IS . Ebenso ist die partielle Ableitung von Lmax mit Bezug auf IS .$A$$x\mapsto \mbox{Lmin}(Ax)$$x$$(g(Ax))^T A$$x_j$$\sum_i A_{ij} \exp(-A_i x) / \sum_i \exp(-A_i x)$$(Ax)$$x_j$$\sum_i A_{ij} \exp(A_i x)/\sum_i \exp(A_i x)$

Bruchteile Satzabdeckung

Reparieren Sie eine Set-Cover-Instanz. Let bezeichnen die Element / set Inzidenzmatrix. Somit ist wenn , andernfalls 0, und ist das Ausmaß, in dem die gebrochene Abdeckung das Element bedeckt .$A$$A_{es} = 1$$e\in s$$A_e x$$x$$e$

Die LP ist . Bei ist der Algorithmus$\min\{ |x| : A x \ge 1; x \ge 0\}$$\varepsilon\in (0,1)$

---

1. Initialisiere alle . Sei . $x_s = 0$$N=\log(n)/\varepsilon$

2. Wiederholen, bis : $\min_e A_e x \ge N$

   2.1. Wählen Sie die partielle Ableitung von Lmin zu maximieren WRT . (Explizit wählen maximier .) $s$$(Ax)$$x_s$ s ∑ e ∈ s exp ( - ∑ s ′ ∋ e x s ′ )
   $s$$\sum_{e\in s} \exp(-\sum_{s'\ni e} x_{s'})$

   2.2. Erhöhe um . $x_s$$\varepsilon$

3. Sie .$x/\min_{e} A_e x$

---

Der Algorithmus gibt eine ungefähre Lösung in Iterationen von , wobei die Anzahl der Elemente und das Optimum ist gebrochene Deckung setzen (trivial ). (Ein ähnlicher Algorithmus erscheint in der erwähnten Veröffentlichung Chandra . Vertex Cover ist natürlich ein Sonderfall.)$(1+O(\varepsilon))$$O(|x^*|\log(n)/\varepsilon^2)$$n$$x^*$$|x^*|\le n$

( Anmerkung: Es ist zu beachten, dass die gebundene Iteration nicht von der Anzahl der Mengen abhängt, sondern nur von der Anzahl der Elemente. Somit kann der Algorithmus mit einem implizit definierten Mengen-System verwendet werden, solange bei gegebener Gewichtung der Elemente effizient gearbeitet werden kann Finden Sie eine Menge von maximalem (oder nahezu maximalem) Gesamtgewicht. Diese Art von Orakel entspricht dem Trennungs-Orakel, das erforderlich ist, um den Ellipsoid-Algorithmus auf das doppelte Problem anzuwenden . Wenn Sie die Elemente gewichten, wird eine Menge zurückgegeben, die das Gesamtgewicht minimiert . Bei Problemen wie dem Multi-Commodity-Flow müssen Sie möglicherweise einen Pfad finden, der die Summe einiger gegebener Kantengewichte minimiert.)

Hier ist eine Skizze des Nachweises der Leistungsgarantie. In jeder Iteration ist die partielle Ableitung bezüglich des gewählten mindestens, wobei die optimale Teilmenge ist.$s$$1/|x^*|$$x^*$

(Um zu sehen , warum erinnert, dass der Gradient von Lmin in Bezug auf ist Wenn wir einen Satz wählen waren. aus der Verteilung zufällig , der erwartete Wert der partiellen Ableitung in Bezug auf wäre somit . Da , this ist mindestens . Da , ist dies mindestens . Es müssen also mindestens einige existieren , die eine partielle Ableitung ergeben . Da der Algorithmus wählt$(Ax)$$x$$(g(Ax))^T A$$s'$$x^*/|x^*|$$x_{s'}$$(g(Ax))^T \,A x^*/|x^*|$$Ax^* \ge 1$$|g(Ax)|/|x^*|$$|g(Ax)|=1$$1/|x^*|$$s$$1/|x^*|$$x_s$Um die partielle Ableitung zu maximieren, wird in jeder Iteration eine partielle Ableitung von mindestens.) 1 / | x ∗ |$1/|x^*|$

Dann wird die Schrittgröße gerade so klein gewählt, dass keine Koordinate von um mehr als zunimmt . Somit ist es aufgrund der Glätte von Lmin, zunehmenden zu erhöht durch mindestens .$\varepsilon$$A x$$\varepsilon$$x_s$$x_s+\varepsilon$$\mbox{Lmin}(Ax)$$(1-O(\varepsilon))\varepsilon/|x^*|$

Auf diese Weise der Algorithmus die Invariante aufrecht (Beachten Sie, dass Lmin gleich .)

$$\mbox{Lmin}(Ax) \ge (1-O(\varepsilon)) |x|/|x^*| - \ln n.$$ $(\overline 0)$$\ln n$

Bei Beendigung ist in der Invariante der Term mal die linke Seite, so dass man rechnerisch erhält. Nach der Normalisierung in der letzten Zeile des Algorithmus impliziert dies.$\ln n$$O(\varepsilon)$$\min_e A_e x \ge (1-O(\varepsilon)) |x|/|x^*|$$|x| \le (1+O(\varepsilon))|x^*|$

FWIW, die Ungleichungen beim Nachweis der Invariante sind im Wesentlichen die gleichen wie beim Nachweis der Chernoff-Bindung. (Tatsächlich kann dieser Algorithmus abgeleitet werden, indem die Methode der bedingten Wahrscheinlichkeiten auf ein randomisiertes Rundungsschema angewendet wird, bei dem Mengen aus der Verteilung (mit Ersetzung) wiederholt abgetastet werden , wobei für jede abgetastete Menge erhöht wird Diese Derandomisierung ergibt den Algorithmus: Die zugrunde liegende Invariante ist nur, dass der pessimistische Schätzer unter 1 bleibt in der Zeitung Chandra erwähnt .)$x^*/|x^*|$$x_s$$s$

Fractional Weighted Set Cover (und allgemeine fraktionierte Deckung)

Um Probleme wie Weighted Set Cover effizient zu behandeln , modifizieren wir den Algorithmus so, dass ungleichmäßige Inkremente verwendet werden (eine Idee von Garg und Konemann ).

Die LP lautet , wobei sich über die Elemente erstreckt, sich über die Mengen erstreckt und alle Variablen nicht sind -Negativ. Um den Algorithmus zu präsentieren, schreiben Sie das Problem zunächst als allgemeines Abdeckungsproblem um. sei für und . Dann (mit einer Änderung der Variablen, wobei jedes durch ) ist die LP , das wir als allgemeine Covering-LP betrachten können. Hier ist der Algorithmus:$\min\{ c\cdot x : (\forall e) \sum_{s\ni e} x_s \ge 1\}$$e$$s$$A_{es} = 1/c_s$$e\in s$$A_{es} = 0$$x_s$$c_s$$\min\{ |x| : A x \ge 1; x \ge 0\}$

---

1. Initialisiere alle . Sei .$x_s = 0$$N=\log(n)/\varepsilon$

2. Wiederholen, bis alle Covering-Einschränkungen gelöscht wurden:

   2.1. Wählen Sie Maximieren der partiellen Ableitung von Lmin bezüglich . (Explizit wählen maximier .)$s$$(Ax)$$x_s$ s ∑ e ∈ s exp ( - ∑ s ' ∋ e x s ' ) / c s
   $s$$\sum_{e\in s} \exp({-\sum_{s'\ni e} x_{s'}})/c_s$

   2.2. Erhöhe um , wobei maximal so gewählt wird, dass für jede verbleibende Bedeckungsbedingung die Zunahme von höchstens .$x_s$$\delta$$\delta$$e$$A_e \cdot x$$\varepsilon$

   2.3 Löschen aller abdeckt Einschränkungen , so dass .$e$$A_e\cdot x \ge N$

3. Return .$x/\min_e A_e\cdot x$

---

Der Algorithmus gibt eine - ungefähre Lösung in Iterationen von , wobei die Anzahl der überdeckenden Bedingungen ist. (Jede Iteration erhöht einige verbleibende um ; dies kann nur mal vorkommen, bevor eine Einschränkung gelöscht wird.) Der Beweis der Richtigkeit erfolgt über im Wesentlichen dieselbe Invariante wie für Set Cover.$(1+O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$n$$A_e x$$\varepsilon$$N/\varepsilon$

Weighted Vertex Cover ist ein Sonderfall.

Maximales fraktioniertes zweiteiliges Matching

Bei einem Graphen ist die natürliche LP für das Problem .$G=(U,W,E)$$\max\{|x| : \forall v.\, \sum_{e\ni v} x_e \le 1\}$

In der Matrixdarstellung ist dies eine Packungs-LP mit 0-1 Koeffizienten ( wenn ). Für solche Probleme sind keine uneinheitlichen Inkremente erforderlich. Ein einfacher Algorithmus, der dem ungewichteten Set-Cover-Algorithmus (aber für das Packen) entspricht, ist also ausreichend:$\max\{|x| : Ax \le 1; x \ge 0\}$$A_{ve} = 1$$v\in e$

---

1. Initialisiere alle . Sei .$x_e = 0$$N=\log(n)/\varepsilon$

2. Während :$A x < N$

   2.1. Wählen Sie die partielle Ableitung von Lmax bezüglich . (Wählen Sie explizit um zu minimieren .)$e$$(Ax)$$x_e$
   $e$$\sum_{v\in e} \exp(\sum_{e'\ni v} x_{e'})$

   2.2. Erhöhen von . $x_e$$\varepsilon$

3. Sie .$x/\max_{v} A_v x$

---

Der Algorithmus gibt eine - ungefähre Lösung in -Iterationen zurück. (Dies liegt daran, dass jede Iteration um zunimmt und schließlich vor der Normalisierung .)$(1-O(\varepsilon))$$O(n\log(n)/\varepsilon^2)$$|x|$$\varepsilon$$|x| = O(N n)$

Aus Spaß ist hier ein kurioser alternativer Algorithmus für Perfect Bipartite Matching. Denken Sie daran, dass . Sei.$G=(U,W,E)$$n=|U|=|W|$

---

1. Initialisiere alle . Es sei . $x_e = 0$$N=4\ln(n)/\varepsilon$

2. Wiederhole mal:$n\,N$

   2.1. Wähle gleichmäßig zufällig aus . 2.2. Wählen , so dass Minimierungs . 2.3. Erhöhen von . $u$$U$w ( u , w ) ∈ E ∑ e ∋ w x e x u w ε
   $w$$(u,w)\in E$$\sum_{e\ni w} x_e$
   $x_{uw}$$\varepsilon$

3. Zurück .$x/N$

---

Wenn eine perfekte Abstimmung hat, kehrt der Algorithmus eine , so dass , und mit hohen Wahrscheinlichkeit für alle Scheitelpunkte , und für all Vertices , . Wenn Sie an den Details des Beweises interessiert sind, fragen Sie bitte ...$G$$x$$|x|=n$$u\in U$$1-O(\varepsilon) \le \sum_{e\ni u} x_e \le 1+O(\varepsilon)$$w\in W$$\sum_{e\ni w} x_e \le 1+O(\varepsilon)$

Gemischte verpackung und abdeckung

Möglicherweise haben Sie nach einem zweigliedrigen Abgleich gefragt, in der Hoffnung, ein Beispiel für ein gemischtes Packungs- und Abdeckungsproblem zu finden, d. Eine der Formen Hier ist ein Algorithmus für solche Probleme. Normalisieren Sie zunächst so, dass und .

$$\exists x?~ Px \le p; Cx \ge c; x \ge 0.$$ $p=\overline 1$$c=\overline 1$

Sei die Anzahl der Nebenbedingungen (Zeilen in plus Zeilen in ).$m$$P$$C$

---

1. Initialisiere alle . Es sei .$x_j = 0$$N=2\ln(m)/\varepsilon$

2. Während :$P x < N$

   2.1. Wählen Sie so, dass die partielle Ableitung von Lmax in Bezug auf höchstens die partielle Ableitung von Lmin in Bezug auf . (Wähle explizit so, dass$j$$(Px)$$x_j$$(Cx)$$x_j$$j$

   $$\frac{\sum_i P_{ij} \exp(P_i x)}{\sum_{i}\exp(P_i x)} \le \frac{\sum_i C_{ij} \exp(-C_i x)}{\sum_{i}\exp(-C_i x)}.)$$

   2.2. Erhöhe um , wobei maximal so gewählt wird, dass keine Einschränkung oder verbleibende Einschränkung um mehr als zunimmt .$x_j$$\delta$$\delta$$P_i x$$C_i x$$\varepsilon$

   2.3. Löscht alle abdeckt Einschränkungen so dass .$i$$C_i x \ge N$

3. Rückgabe .$x/\max_i P_i x$

---

Unter der Annahme, dass das gegebene Problem realisierbar ist, gibt der Algorithmus ein so dass und . Die Anzahl der Iterationen ist , da jede Iteration eine Einschränkung um erhöht , und dies kann für jede Einschränkung höchstens mal vorkommen.$x$$Px\le 1$$Cx\ge 1-O(\varepsilon)$$O(m\ln(m)/\varepsilon^2)$$\varepsilon$$N$

Der Beweis der Richtigkeit erfolgt über die Invariante Die Invariante impliziert Bei Beendigung ist die linke Seite , was die Leistungsgarantie belegt.

$$\mbox{Lmax}(Px) \le 2\ln(m) + (1+O(\varepsilon)) \mbox{Lmin}(Cx).$$ $$\max Px \le 2\ln(m) + (1+O(\varepsilon)) \min Cx.$$ $\Omega(\log(m)/\varepsilon)$

In Schritt 2.1 muss das gewünschte existieren, solange das ursprüngliche Problem realisierbar ist. (Dies liegt daran, dass für jedes mögliche und jedes , wenn wir ein zufälliges aus der Verteilung wählen , der erwartete Wert der partiellen Ableitung von Lmax in Bezug auf wäre höchstens (siehe vorherige Beweisskizze für Set Cover) Ebenso der erwartete Wert der partiellen Ableitung von Lmin in Bezug auf wäre mindestens . Es gibt also ein$j$x ≤ x j ′ x ≤ / | x ∗ | ( P x ) x j ' 1 / | x ∗ | ( C x ) x j ' 1 / | x ∗ | j ( P x ) x j ' ( C x ) $x^*$$x$$j'$$x^*/|x^*|$$(Px)$$x_{j'}$$1/|x^*|$$(Cx)$$x_{j'}$$1/|x^*|$$j$so dass die partielle Ableitung von Lmax in Bezug auf höchstens die partielle Ableitung von Lmin .)$(Px)$$x_{j'}$$(Cx)$

Dann wird die Invariante in jeder Iteration beibehalten, weil durch die Wahl von und und die Glätte von Lmin und Lmax durch Erhöhen von auf Lmax um höchstens das fache erhöht wird Zunahme von Lmin .$x_j$$\delta$$x_j$$x_j+\delta$$(Px)$$1+O(\varepsilon)$$(Cx)$

Lernen (nach Experten / Boosten)

Eine Referenz zum Verständnis dieses Zusammenhangs ist das adaptive Spielen mit multiplikativen Gewichten von Freund und Schapire. Hier ist eine kurze Zusammenfassung, um die technische Idee zu geben.

Betrachten Sie das folgende wiederholte Spiel. In jeder Runde : $t$

1. Sie wählen eine Wahrscheinlichkeitsverteilung auf (die sogenannten Experten ). $p^t$$[n]$$n$
2. In Kenntnis von wählt der Gegner dann einen Auszahlungsvektor . $p^t$$a^t\in [0,1]^{n}$
3. Sie erhalten Auszahlung für die Runde. $p^t\cdot a^t$

Das Spiel stoppt nach einigen Runden. Ihr Ziel ist es, Ihr Bedauern im Vergleich zu einem einzelnen Experten (dh einer reinen Strategie) so gering wie möglich zu halten .Das heißt, Ihr Ziel ist es, zu minimieren .$i$$(\max_i \sum_t a^t_i) - \sum_t p^t\cdot a^t$

Fix jedes . Der Vektor bezeichne , mal die Vektorsumme der Auszahlungsvektoren bis zum Zeitpunkt . Denken Sie daran, dass der Gradient von Lmax .$\varepsilon>0$$y^t$$\varepsilon \sum_{s \le t} a^s$$\varepsilon$$t$$G(y)$$(y)$

Hier ist die grundlegende Strategie, die wir analysieren werden: Wählen Sie in Runde als .$t$$p^t$$G(y^{t-1})$

Nach Prüfung erhalten Sie eine Auszahlung von in Runde .$a^t \cdot G(y^{t-1})$$t$

Wegen der von ist Das heißt, in jeder Runde kann nicht mehr als das -fache Ihrer Auszahlung betragen. Da , wird die Invariante beibehalten, dass höchstens Ihre Gesamtauszahlungszeit plus ist auf der anderen Seite, Ihr Bedauern im Vergleich zu den besten Experten. ist , dh$F$

$$\mbox{Lmax}(y^t) \le \mbox{Lmax}(y^{t-1}) + (1+O(\varepsilon)) \varepsilon a^t \cdot G(y^{t-1}).$$ $\mbox{Lmax}(y^t)$$\varepsilon(1+O(\varepsilon))$$\mbox{Lmax}(\overline 0) = \ln n$$\mbox{Lmax}(y^t)$$\varepsilon(1+O(\varepsilon)$$\ln(n)$$i$$\max_i \sum_t a^t_i$$\varepsilon^{-1} \max_i y^t_i$ ist wiederum höchstens .$\varepsilon^{-1} \mbox{Lmax}(y^t)$

Daher ist Ihr Bedauern höchstens plus multipliziert mit Ihrer Gesamtauszahlung.$\varepsilon^{-1} \ln(n)$$O(\varepsilon)$

Bemerkung: Ich denke, wie Freund und Schapire hervorheben, ist in dieser Analyse auch ein "Boosting" -Algorithmus (in der Lerntheorie) enthalten. Weitere Einzelheiten finden Sie in ihrem Artikel.

Minimierung der Gesamtauszahlung

Sie können eine ähnliche Strategie für die Einstellung ableiten, bei der das Ziel eher die Minimierung als die Maximierung der Gesamtauszahlung ist. Ihr Bedauern, das Sie immer noch minimieren möchten, ist . In diesem Fall besteht die entsprechende Strategie darin, als Gradienten von zu wählen . Mit dieser Strategie ist Ihr Bedauern wieder höchstens plus mal Ihre Gesamtauszahlung.$\sum_t p^t\cdot a^t - \min_i a^t_i$$p^t$$\mbox{Lmin}(y^t)$$\varepsilon^{-1} \ln n$$O(\varepsilon)$

Anbindung an Lagrange-Relaxationsalgorithmen

Korrigieren Sie eine Set-Cover-Instanz, um die Verbindung zu Lagrange-Relaxationsalgorithmen zu sehen. Betrachten Sie die letztere Art von Spiel (mit dem Ziel, die Auszahlung zu minimieren), bei der die Experten den Elementen Ihres festgelegten Systems entsprechen. Wählen Sie in jeder Runde die Wahrscheinlichkeitsverteilung als den Gradienten von Lmin wie oben, und lassen Sie den Gegner den Auszahlungsvektor als eine Funktion von wie folgt wählen : Wählen Sie die Menge maximiere , dann lasse wenn , und ansonsten .$e$$p^t$$(y^t)$$a^t$$p^t$$s^t$$\sum_{e\in s} p^t_e$$a^t_e = 1$$e\in s^t$$a^t_e = 0$

Unter der Voraussetzung, dass die Stoppbedingung korrekt ist (siehe unten), erhalten Sie bei diesem Vorgang genau den zu Beginn beschriebenen Set-Cover-Algorithmus.

Die Leistungsgarantie des Algorithmus ergibt sich aus dem Bedauern wie folgt. Lassen die Anzahl der Zeiten der Gegner wählte Satz während des Spiels. Sei die optimale Deckung für gebrochene Mengen. Seisei die Anzahl der gespielten Runden. Das gebundene Bedauern impliziert $X_s$$s$$x^*$$T=|X_s|$

$$\textstyle \sum_t a^t\cdot p^t \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$

Unter Verwendung der Definition von ist der te Gewinn (der te Term in der Summe auf der linken Seite) gleich . Der Gegner wählte diese Auszahlung zu minimieren. Wenn der Gegner stattdessen zufällig aus der Verteilung, die Erwartung der Auszahlung wäre gewesen (Oben verwenden wir für alle und ) Da jede Auszahlung mindestens ist$a^t$$t$$t$$\sum_{e\in s^t} p^t_e$$s^t$$s^t$$x^*/|x^*|$

$$\sum_s \frac{x^*_s}{|x^*|} \sum_{e\in s} p^t_e ~=~ \frac{1}{|x^*|} \sum_e p^t_e \sum_{s\ni e} x^*_s ~\ge~ \frac{1}{|x^*|} \sum_e p^t_e ~=~ \frac{1}{|x^*|}.$$ $\sum_{s\ni e} x^*_s \ge 1$$e$$|p^t| = 1$$1/|x^*|$bedeutet das gebundene Bedauern Nach der Definition von haben wir (jede Runde wählt eine Menge) und , was ergibt Wir stoppen den Prozess, wenn , also (Begriffe neu ordnen) Das heißt, die Normalisierung von ergibt eine Teilmenge von höchstens mal optimal. $$\frac{T}{|x^*|} \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$ $X$$|X| = T$$\sum_t a_e^t = \sum_e [e\in s^t] = \sum_{s\ni e} X_s$ $$\frac{|X|}{|x^*|} \le \varepsilon^{-1}\ln(m) +\min_e \sum_{s\ni e} X_s.$$ $\min_e \sum_{s\ni e} X_s = \Omega(\varepsilon^{-2}\ln m)$ $$\frac{|X|}{\min_e \sum_{s\ni e} X_s}~ \le~ (1+O(\varepsilon)|x^*|.$$ $X$$(1+O(\varepsilon))$

Bemerkung: Diese lerntheoretische Interpretation verallgemeinert gewissermaßen die algorithmische Interpretation. Einige der für die Effizienz erforderlichen algorithmischen Techniken (wie ungleichmäßige Inkremente und das Fallenlassen erfüllter Bedeckungsbeschränkungen) scheinen sich jedoch nicht auf die Lerntheorie zu übertragen. Ebenso scheinen Algorithmen für gemischte Pack- und Covering-LPs (z. B. diese ) keine natürlichen Analoga in der Lerntheorie zu haben.