Esempi di giocattoli per solutori Plotkin-Shmoys-Tardos e Arora-Kale

Vorrei capire come il solutore Arora-Kale SDP approssima il rilassamento di Goemans-Williamson in un tempo quasi lineare, come il solutore Plotkin-Shmoys-Tardos approssima i problemi frazionari di "impacchettamento" e "copertura" in un tempo quasi lineare, e come gli algoritmi sono istanze del quadro astratto "imparare dagli esperti".

La tesi di Kale ha una presentazione eccellente, ma trovo molto difficile saltare direttamente nel quadro astratto, e preferirei partire da un esempio di un problema semplice per il quale è assolutamente ovvio cosa fare, per poi passare a problemi più generali , aggiungendo progressivamente "funzionalità" all'algoritmo e alla sua analisi.

Per esempio:

In che modo Plotkin-Shmoys risolve il rilassamento di programmazione lineare della copertura dei vertici non ponderata? Copertura del vertice ponderata? Imposta la copertina? Abbinamento bipartito?

Qual è l'esempio più semplice in cui l'algoritmo Arora-Kale sta facendo qualcosa di interessante? Come calcola il più grande autovalore del Laplaciano di un grafico?

(Il calcolo del più grande autovalore del Laplaciano equivale al problema di risolvere una versione più debole del rilassamento SDP Goemans-Williamson di Max Cut, in cui, invece di richiedere che ogni vettore sia di lunghezza uno, si desidera la somma dei quadrati delle norme da essere | V |.)

Luca, da quando è passato un anno, probabilmente hai cercato la tua risposta. Sto rispondendo ad alcune delle tue domande qui solo per la cronaca. Rivedo alcuni algoritmi di rilassamento lagrangiano per i problemi menzionati e tracciamo la connessione all'apprendimento (in particolare, seguendo i consigli degli esperti). Non faccio commenti qui sugli algoritmi SDP.

Si noti che i particolari algoritmi citati non vengono eseguiti in un tempo quasi lineare. (Esiste un algoritmo a tempo quasi lineare per problemi espliciti di imballaggio o copertura. Vedi Beating Simplex per i pacchetti lineari di imballaggio e copertura frazionari .) Gli algoritmi che hai in mente in genere hanno varianti che girano in un numero quasi lineare di iterazioni , ma ciascuna l'iterazione richiede in genere anche un tempo almeno lineare. Discuto alcuni di questi algoritmi di seguito.

Alcune funzioni utili

Prima di iniziare, ecco alcune funzioni che utilizzeremo negli schizzi di prova. (Se sei interessato agli algoritmi, ma non ai dettagli della prova, puoi saltare avanti.) Per qualsiasi vettore $y$ , definisci $\mbox{Lmax}(y)$ come $\ln \sum_i \exp(y_i)$ . Questa funzione ha un limite superiore su$\max_i y_i$ :

$$\max_i y_i ~\le~ \mbox{Lmax}(y) ~\le~ \max_i y_i + \ln m.$$ Analogamente, definire$\mbox{Lmin}(y)$ essere$-\mbox{Lmax}(-y)$ , un limite inferiore di$\min_i y_i$ .

Per comodità in quanto segue, usiamo $g(y)$ per indicare il gradiente $\nabla \mbox{Lmin}(y)$ di Lmin. Usiamo $G(y)$ per indicare il gradiente $\nabla \mbox{Lmax}(y)$ di Lmax.

Esplicitamente, $g_i(y)$ è $\exp(-y_i)/\sum_{i'} \exp(-y_{i'})$ mentre$G_i(y)$ è$\exp(y_i)/\sum_{i'} \exp(y_{i'})$ .

Lmin e Lmax sono uniformi nel senso seguente: per ogni vettore $d\in[0,\varepsilon]^n$ e $y\in R^n$ ,

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

Si noti che entrambi i gradienti hanno 1 norma uguale a 1: $|G(y)| = |g(y)| = 1$ . (In tutto usiamo $|z|$ per indicare la 1-norma.)

Si noti inoltre che, per una matrice $A$ , il gradiente della funzione $x\mapsto \mbox{Lmin}(Ax)$ rispetto a $x$ è (secondo la regola della catena) $(g(Ax))^T A$ . Più esplicitamente, la derivata parziale della funzione rispetto a$x_j$ è$\sum_i A_{ij} \exp(-A_i x) / \sum_i \exp(-A_i x)$. Allo stesso modo, la derivata parziale di Lmax $(Ax)$ rispetto a $x_j$ è $\sum_i A_{ij} \exp(A_i x)/\sum_i \exp(A_i x)$ .

Copertura frazionaria del set

Correggi un'istanza Set-Cover. Lascia che $A$ indichi l'elemento / imposta la matrice di incidenza. Pertanto, $A_{es} = 1$ se $e\in s$ , altrimenti 0 e $A_e x$ è la misura in cui la copertura frazionaria $x$ copre l'elemento $e$ .

L'LP è $\min\{ |x| : A x \ge 1; x \ge 0\}$ . Dato $\varepsilon\in (0,1)$ , l'algoritmo è

---

1. Inizializza tutto $x_s = 0$ . Sia $N=\log(n)/\varepsilon$ .

2. Ripetere fino $\min_e A_e x \ge N$ :

   2.1. Scegli $s$ massimizzando la derivata parziale di Lmin $(Ax)$ wrt $x_s$ .
   (Esplicitamente, scegli $s$ massimizzando $\sum_{e\in s} \exp(-\sum_{s'\ni e} x_{s'})$ .)

   2.2. Aumenta $x_s$ di $\varepsilon$ .

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

---

L'algoritmo restituisce una soluzione approssimativa $(1+O(\varepsilon))$ in $O(|x^*|\log(n)/\varepsilon^2)$iterazioni log ( n ) / ε 2 ) , dove$n$ è il numero di elementi e$x^*$ è la copertura ottimale dell'insieme frazionario (banalmente$|x^*|\le n$ ). (Un algoritmo simile appare neldocumento citato da Chandra. Vertex Cover è ovviamente un caso speciale.)

( Nota: si noti che il limite di iterazione non dipende dal numero di set, ma solo dal numero di elementi. Pertanto, l'algoritmo può essere utilizzato con un sistema di set implicitamente definito, purché, dati i pesi sugli elementi, si possa efficientemente trova un insieme di peso totale massimo (o quasi massimo). Questo tipo di oracolo è uguale all'oracolo di separazione richiesto per applicare l'algoritmo ellissoide al doppio problema. Per problemi di imballaggio come l'insieme di imballaggi, è necessario un oracolo che, dati pesi sugli elementi, restituisce un set minimizzando il peso totale. Per problemi come il flusso multi-merce, potrebbe essere necessario, ad esempio, trovare un percorso che minimizzi la somma di alcuni pesi del bordo).

Ecco uno schizzo della prova della garanzia di prestazione. In ogni iterazione, la derivata parziale rispetto alla $s$ scelta è almeno $1/|x^*|$, dove $x^*$ è la copertura ottimale del set frazionario.

(Per capire perché, ricordiamo che il gradiente di Lmin $(Ax)$ rispetto a $x$ è $(g(Ax))^T A$ Se dovessimo scegliere un set $s'$ a caso dalla distribuzione$x^*/|x^*|$ , il valore atteso della derivata parziale rispetto a$x_{s'}$ sarebbe quindi$(g(Ax))^T \,A x^*/|x^*|$. Poiché$Ax^* \ge 1$ , questo è almeno$|g(Ax)|/|x^*|$. Dal$|g(Ax)|=1$ , questo è almeno$1/|x^*|$. Pertanto, devono esistere alcuni$s$ danno derivato parziale almeno$1/|x^*|$. Poiché l'algoritmo sceglie $x_s$ in ciascuna iterazione per massimizzare la derivata parziale, ottiene una derivata parziale di almeno $1/|x^*|$.)

Quindi, la dimensione del passo $\varepsilon$ viene scelta solo abbastanza piccola in modo che nessuna coordinata di $A x$ aumenti di più di $\varepsilon$ . Pertanto, a causa della morbidezza di Lmin, aumentando $x_s$ per $x_s+\varepsilon$ aumenta $\mbox{Lmin}(Ax)$ di almeno $(1-O(\varepsilon))\varepsilon/|x^*|$.

In questo modo, l'algoritmo mantiene invariante

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

Al termine, nell'invariante, il termine $\ln n$ è $O(\varepsilon)$ volte il lato sinistro, quindi calcolando si ottiene $\min_e A_e x \ge (1-O(\varepsilon)) |x|/|x^*|$. Dopo la normalizzazione nell'ultima riga dell'algoritmo, questo implica $|x| \le (1+O(\varepsilon))|x^*|$.

FWIW, le disuguaglianze coinvolte nel dimostrare l'invariante sono essenzialmente le stesse di quelle coinvolte nel dimostrare il limite di Chernoff. (In effetti, questo algoritmo può essere derivato applicando il metodo delle probabilità condizionate a uno schema di arrotondamento randomizzato che ripetutamente campiona insiemi dalla distribuzione $x^*/|x^*|$ (con sostituzione), aumentando $x_s$ per ogni insiemi campionati $s$ . Questa derandomizzazione di ciò fornisce l'algoritmo: l'invariante sottostante è solo che lo stimatore pessimistico rimane al di sotto di 1. Le penalità esponenziali nello stimatore pessimistico provengono dall'uso del limite di Chernoff nell'analisi dello schema di arrotondamento. Questa idea di base è spiegata ulteriormente inil documento di cui parla Chandra .)

Copertura frazionaria ponderata del set (e copertura frazionaria generale)

Per gestire in modo efficiente problemi come la Copertura ponderata del set , modifichiamo l'algoritmo per utilizzare incrementi non uniformi (un'idea dovuta a Garg e Konemann ).

L'LP è $\min\{ c\cdot x : (\forall e) \sum_{s\ni e} x_s \ge 1\}$ , dove $e$ spazia sugli elementi, $s$ spazia sugli insiemi e tutte le variabili non sono negative. Per presentare l'algoritmo, innanzitutto riscrivere il problema come un problema di copertura generale. Sia $A_{es} = 1/c_s$ per$e\in s$e$A_{es} = 0$altrimenti. Quindi (con un cambiamento di variabili, ridimensionando ogni $x_s$ di $c_s$ ), l'LP è $\min\{ |x| : A x \ge 1; x \ge 0\}$ , che possiamo visualizzare come LP di copertura generale. Ecco l'algoritmo:

---

1. Inizializza tutto $x_s = 0$ . Sia $N=\log(n)/\varepsilon$ .

2. Ripetere fino a quando tutti i vincoli di copertura sono stati eliminati:

   2.1. Scegli $s$ massimizzando la derivata parziale di Lmin $(Ax)$ wrt $x_s$ .
   (Esplicitamente, scegli $s$ massimizzando $\sum_{e\in s} \exp({-\sum_{s'\ni e} x_{s'}})/c_s$ .)

   2.2. Aumenta di $x_s$ di$\delta$ , dove$\delta$ viene scelto al massimo in modo tale che, per ogni restante limite di copertura$e$ , l'aumento di$A_e \cdot x$ sia al massimo$\varepsilon$ .

   2.3 Elimina tutti i vincoli che coprono $e$ tale che $A_e\cdot x \ge N$ .

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

---

L'algoritmo restituisce una soluzione $(1+O(\varepsilon))$ approssimata nelle iterazioni $O(n\log(n)/\varepsilon^2)$ , dove$n$ è il numero di vincoli di copertura. (Ogni iterazione aumenta alcuni$A_e x$ rimanentidi$\varepsilon$ ; ciò può accadere solo$N/\varepsilon$ volte a un vincolo prima che venga eliminato.) La prova di correttezza è essenzialmente tramite lo stesso invariante di Set Cover.

La copertura dei vertici ponderata è un caso speciale.

Corrispondenza bipartita frazionaria massima

Dato un grafico $G=(U,W,E)$ , l'LP naturale per il problema è$\max\{|x| : \forall v.\, \sum_{e\ni v} x_e \le 1\}$ .

Nella rappresentazione matrice, si tratta di un LP di imballaggio $\max\{|x| : Ax \le 1; x \ge 0\}$ con coefficienti 0-1 ($A_{ve} = 1$ se$v\in e$ ). Tali problemi non richiedono incrementi non uniformi, quindi un semplice algoritmo analogo all'algoritmo Set Cover non ponderato (ma per l'imballaggio) farà:

---

1. Inizializza tutto $x_e = 0$ . Sia$N=\log(n)/\varepsilon$ .

2. Mentre $A x < N$ :

   2.1. Scegli $e$ minimizzando la derivata parziale di Lmax $(Ax)$ wrt $x_e$ .
   (Esplicitamente, selezionare $e$ per ridurre a icona $\sum_{v\in e} \exp(\sum_{e'\ni v} x_{e'})$ .)

   2.2. Aumentare $x_e$ da $\varepsilon$ .

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

---

L'algoritmo restituisce un $(1-O(\varepsilon))$ approssimata nelle iterazioni$O(n\log(n)/\varepsilon^2)$ . (Questo perché ogni iterazione aumenta$|x|$ di$\varepsilon$ , e infine, prima della normalizzazione,$|x| = O(N n)$ .)

Solo per divertimento, ecco un curioso algoritmo alternativo per Perfect Bipartite Matching. Ricorda che $G=(U,W,E)$ . Sia $n=|U|=|W|$.

---

1. Inizializza tutto $x_e = 0$ . Sia $N=4\ln(n)/\varepsilon$ .

2. Ripeti $n\,N$ volte:

   2.1. Scegliere$u$ uniformemente a caso da$U$ .
   2.2. Scegli$w$ tale che$(u,w)\in E$ minimizzando$\sum_{e\ni w} x_e$ .
   2.3. Aumenta$x_{uw}$ da$\varepsilon$ .

3. Ritorno $x/N$ .

---

Se $G$ ha una corrispondenza perfetta, l'algoritmo restituisce una $x$ tale che $|x|=n$ , e, con alta probabilità, per tutti i vertici $u\in U$ ,$1-O(\varepsilon) \le \sum_{e\ni u} x_e \le 1+O(\varepsilon)$ , e per tutti i vertici$w\in W$ ,$\sum_{e\ni w} x_e \le 1+O(\varepsilon)$ . Se sei interessato ai dettagli della prova, chiedi ...

Imballaggio misto e copertura

Potresti aver chiesto informazioni sulla corrispondenza bipartita sperando in un esempio di a problema misto di imballaggio e copertura, ovvero uno dei moduli

$$\exists x?~ Px \le p; Cx \ge c; x \ge 0.$$ Ecco un algoritmo per tali problemi. In primo luogo, normalizzare modo che $p=\overline 1$ e $c=\overline 1$ .

Sia $m$ il numero di vincoli (righe in $P$ più righe in $C$ ).

---

1. Inizializza tutto $x_j = 0$ . Sia $N=2\ln(m)/\varepsilon$ .

2. Mentre $P x < N$ :

   2.1. Scegli $j$ modo che la derivata parziale di Lmax $(Px)$ rispetto a $x_j$ sia al massimo la derivata parziale di Lmin$(Cx)$ rispetto a$x_j$ . (Esplicitamente, scegli$j$ tale che

   $$\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. Aumenta $x_j$ di $\delta$ , dove $\delta$ viene scelto al massimo in modo tale che nessun vincolo $P_i x$ o restante vincolo $C_i x$ aumenti di più di$\varepsilon$ .

   2.3. Elimina tutti $i$ vincoli di copertura in modo tale$C_i x \ge N$ .

3. Ritorno $x/\max_i P_i x$ .

---

Supponendo che il problema dato sia fattibile, l'algoritmo restituisce una $x$ tale che $Px\le 1$ e $Cx\ge 1-O(\varepsilon)$ . Il numero di iterazioni è$O(m\ln(m)/\varepsilon^2)$ , poiché ogni iterazione aumenta alcuni vincoli di$\varepsilon$ , e ciò può accadere per ogni vincolo al massimo$N$ volte.

La prova di correttezza è tramite l'invariante

$$\mbox{Lmax}(Px) \le 2\ln(m) + (1+O(\varepsilon)) \mbox{Lmin}(Cx).$$ L'invariante implica $$\max Px \le 2\ln(m) + (1+O(\varepsilon)) \min Cx.$$ Alla fine il lato sinistro è Ω (log ($\Omega(\log(m)/\varepsilon)$ , a dimostrazione della garanzia di prestazione.

Nel passaggio 2.1, il $j$ desiderato deve esistere fino a quando il problema originale è fattibile. (Questo perché, per ogni fattibile $x^*$ e ogni $x$ , se dovessimo scegliere un casuale $j'$ dalla distribuzione $x^*/|x^*|$ , il valore atteso della derivata parziale di Lmax $(Px)$ rispetto a $x_{j'}$ sarebbe al massimo $1/|x^*|$(vedi lo schizzo di prova precedente per Set Cover). Allo stesso modo, il valore atteso della derivata parziale di Lmin $(Cx)$ è al massimo la derivata parziale di Lmin ( C x ) .)rispetto a $x_{j'}$ sarebbe almeno $1/|x^*|$. Pertanto, esiste una $j$ tale che la derivata parziale di Lmax $(Px)$ rispetto a $x_{j'}$$(Cx)$

Quindi l'invariante viene mantenuto in ogni iterazione perché, con la scelta di $x_j$ e $\delta$ , e la levigatezza di Lmin e Lmax, aumentando $x_j$ a $x_j+\delta$ aumenta Lmax $(Px)$ al massimo di $1+O(\varepsilon)$ volte l'aumento di Lmin $(Cx)$ .

Apprendimento (a seguito di esperti / potenziamento)

Un riferimento per comprendere questa connessione è il gioco adattivo che utilizza pesi moltiplicativi , di Freund e Schapire. Ecco un breve riassunto per dare l'idea tecnica.

Considera il seguente gioco ripetuto. In ogni round $t$ :

1. Scegli una distribuzione di probabilità $p^t$ su $[n]$ (i $n$ cosiddetti esperti ).
2. Conoscendo $p^t$ , l'avversario sceglie quindi un vettore di payoff $a^t\in [0,1]^{n}$ .
3. Ricevi il payoff $p^t\cdot a^t$ per il round.

Il gioco si interrompe dopo un certo numero di round. Il tuo obiettivo è ridurre al minimo il tuo rimpianto rispetto a qualsiasi singolo esperto (vale a dire, pura strategia) $i$ . Cioè, il tuo obiettivo è ridurre al minimo $(\max_i \sum_t a^t_i) - \sum_t p^t\cdot a^t$ .

Correggi qualsiasi $\varepsilon>0$ . Lascia che il vettore $y^t$ indichi $\varepsilon \sum_{s \le t} a^s$ , cioè $\varepsilon$ volte la somma vettoriale dei vettori di payoff fino al tempo$t$ . Ricorda che$G(y)$ è il gradiente di Lmax$(y)$ .

Ecco la strategia di base che analizzeremo: al giro $t$ , scegli $p^t$ per essere $G(y^{t-1})$ .

Per ispezione, questo ti dà il profitto $a^t \cdot G(y^{t-1})$ al giro $t$ .

A causa della proprietà di levigatezza di $F$ ,

$$\mbox{Lmax}(y^t) \le \mbox{Lmax}(y^{t-1}) + (1+O(\varepsilon)) \varepsilon a^t \cdot G(y^{t-1}).$$ Cioè, in ogni round, $\mbox{Lmax}(y^t)$ non può aumentare di più di $\varepsilon(1+O(\varepsilon))$ volte il tuo guadagno. Dal momento che $\mbox{Lmax}(\overline 0) = \ln n$, questo mantiene il invariante che$\mbox{Lmax}(y^t)$ è al massimo i tempi di payoff totali$\varepsilon(1+O(\varepsilon)$ , più$\ln(n)$ . D'altra parte, il tuo rimpianto rispetto al miglior esperto$i$ è$\max_i \sum_t a^t_i$ , ovvero$\varepsilon^{-1} \max_i y^t_i$ , che è a sua volta al massimo$\varepsilon^{-1} \mbox{Lmax}(y^t)$.

Pertanto, il tuo rimpianto è al massimo $\varepsilon^{-1} \ln(n)$ , più $O(\varepsilon)$ volte il tuo guadagno totale.

Nota: penso, come sottolinea Freund e Schapire, anche un algoritmo di "potenziamento" (nella teoria dell'apprendimento) è implicito in questa analisi. Vedi il loro documento per maggiori dettagli.

Riduzione al minimo del profitto totale

È possibile derivare una strategia simile per l'impostazione in cui l'obiettivo è minimizzare , piuttosto che massimizzare, il payoff totale. Il tuo rimpianto, che vuoi ancora minimizzare, è $\sum_t p^t\cdot a^t - \min_i a^t_i$ . In tal caso, la strategia corrispondente è scegliere $p^t$ come gradiente di $\mbox{Lmin}(y^t)$ . Con questa strategia il tuo rimpianto è di nuovo al massimo $\varepsilon^{-1} \ln n$ più$O(\varepsilon)$ volte il tuo guadagno totale.

Connessione agli algoritmi di rilassamento lagrangiano

Per vedere la connessione agli algoritmi di rilassamento lagrangiano, correggi un'istanza Set-Cover. Considera l'ultimo tipo di gioco (con l'obiettivo di minimizzare il payoff), in cui gli esperti corrispondono agli elementi $e$ del tuo sistema set. In ogni round, scegli la distribuzione di probabilità $p^t$ come gradiente di Lmin $(y^t)$ come sopra e fai in modo che l'avversario scelga il vettore di payoff $a^t$ in funzione di $p^t$ come segue: scegli il set $s^t$ massimizza $\sum_{e\in s} p^t_e$ , quindi lascia$a^t_e = 1$altrimenti. se$e\in s^t$ e$a^t_e = 0$

Data la condizione di arresto corretta (discussa di seguito), questo processo fornisce esattamente l'algoritmo Set-Cover discusso all'inizio.

La garanzia di prestazione dell'algoritmo segue dal rimpianto legato come segue. Let $X_s$ essere il numero di volte in cui l'avversario ha scelto insieme $s$ durante il gioco. Sia $x^*$ la copertura ottimale del set frazionario. Sia $T=|X_s|$essere il numero di round giocati. Il limite di rimpianto implica

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

Utilizzando la definizione di $a^t$ , la $t$ ° payoff (il $t$ esimo termine nella somma a sinistra) è uguale a $\sum_{e\in s^t} p^t_e$ . L'avversario ha scelto $s^t$ per ridurre al minimo questo payoff. Se l'avversario avesse invece scelto $s^t$ casualmente dalla distribuzione $x^*/|x^*|$, l'aspettativa del payoff sarebbe stata

$$\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^*|}.$$ (Sopra usiamo che$\sum_{s\ni e} x^*_s \ge 1$per tutte$e$, e$|p^t| = 1$) Poiché ogni payoff è almeno$1/|x^*|$, il rimpianto associato implica $$\frac{T}{|x^*|} \le \varepsilon^{-1}\ln(m) + \min_e \sum_t a_e^t.$$ Per definizione di$X$, abbiamo$|X| = T$(ogni round sceglie un set), e$\sum_t a_e^t = \sum_e [e\in s^t] = \sum_{s\ni e} X_s$ , dando $$\frac{|X|}{|x^*|} \le \varepsilon^{-1}\ln(m) +\min_e \sum_{s\ni e} X_s.$$ Facciamo arrestare il processo quando$\min_e \sum_{s\ni e} X_s = \Omega(\varepsilon^{-2}\ln m)$, quindi (riordinando i termini) $$\frac{|X|}{\min_e \sum_{s\ni e} X_s}~ \le~ (1+O(\varepsilon)|x^*|.$$ Ovvero, la normalizzazione di $X$ fornisce una copertura frazionaria della dimensione al massimo $(1+O(\varepsilon))$ volte ottimali.

Nota: in un certo senso, questa interpretazione della teoria dell'apprendimento generalizza l'interpretazione algoritmica. Tuttavia, alcune delle tecniche algoritmiche necessarie per l'efficienza (come gli incrementi non uniformi e l'eliminazione dei vincoli di copertura soddisfatti) non sembrano ripercuotersi naturalmente sulla teoria dell'apprendimento. Allo stesso modo, gli algoritmi per gli imballaggi misti e gli LP coprenti (ad es. Questi ) non sembrano avere analoghi naturali nell'impostazione della teoria dell'apprendimento.