Online Bin Packing with Advice

We consider the online bin packing problem under the advice complexity model where the “online constraint” is relaxed and an algorithm receives partial information about the future items. We provide tight upper and lower bounds for the amount of advice an algorithm needs to achieve an optimal packing. We also introduce an algorithm that, when provided with logn+o(logn)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\log n + o(\log n)$$\end{document} bits of advice, achieves a competitive ratio of 3/2\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$3/2$$\end{document} for the general problem. This algorithm is simple and is expected to find real-world applications. We introduce another algorithm that receives 2n+o(n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$2n + o(n)$$\end{document} bits of advice and achieves a competitive ratio of 4/3+ε\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$4/3 + \varepsilon $$\end{document}. Finally, we provide a lower bound argument that implies that advice of linear size is required for an algorithm to achieve a competitive ratio better than 9/8.


Introduction
In the classical one-dimensional bin packing problem the goal is to pack a given sequence of items into a minimum number of bins with fixed and equal capacities. For convenience, it is assumed that items sizes are in the range (0, 1] and the capacities of bins are 1. In the online version of the problem, the items are revealed one by one, and an algorithm must pack each item without any knowledge about future items. The decisions of an online algorithm are irrevocable, i.e., it is not possible to move an item from one bin to another after it is packed in a bin.
The online bin packing problem has many applications in practice, from loading trucks subject to weight limitations to creating file backups in removable media [10]. Heuristics that have been proposed for the problem include Next-Fit (NF), First-Fit (FF), Best-Fit (BF), and the Harmonic-based class of algorithms. NF maintains a single open bin and places an item in that bin; in the case the item does not fit, it closes the bin and opens a new one. FF keeps a list of bins in the order they are opened, packs an item in the first bin that has enough space, and opens a new bin if necessary. BF performs similarly to FF, except that the bins are ordered in increasing order of their remaining capacity. Harmonic-based algorithms are based on the idea of packing items of similar sizes together in a bin. For Harmonic K , an item has type i (1 ≤ i ≤ K − 1) if it is in the range ( 1 i+1 , 1 i ], and type K if it is in the range (0, 1 K ]. The algorithm applies the NF strategy for items of each type separately.
As for other online problems, the standard method for comparing bin packing algorithms is competitive analysis. Under competitive analysis, the performance of an algorithm A is compared to that of OPT, which is the optimal offline algorithm. More precisely, the competitive ratio of an algorithm A is the asymptotically maximum ratio of the cost of A to that of OPT for serving the same sequence σ. FF and BF have the same competitive ratio of 1.7, while the best Harmonic-based algorithm has a competitive ratio of at most 1.58889 [22]. It is also known that no online algorithm can have a competitive ratio better than 1.54037 [3].
The total lack of information about the future is unrealistic in many real-world scenarios [13]. A natural approach for addressing this issue is to relax the problem by providing extra information about the input sequence. For the online bin packing problem, such relaxations have been studied in the contexts of lookahead, in which the online algorithm can look at the items arriving in the near future [16], and closed bin packing, in which the length of the request sequence is known to the online algorithm [1]. In both cases, the average performance of the online algorithm improves, compared to the online algorithms with no information about the future. The advice complexity model for online algorithms is a more general framework under which the "no knowledge assumption" behind online algorithms is relaxed, and the algorithm receives some bits of advice about the future requests. The advice can be any information about the input sequence and is generated by an offline oracle which has unbounded computational power. Provided with the appropriate advice, the online algorithms are expected to achieve improved competitive ratios. The advice model has received significant attention since its introduction [8,17,13,7,18,20,9,4,11,15,19,6,5,21].
In this paper, we study the advice complexity of the online bin packing problem. Our interest in studying the problem under this setting is mostly theoretical. Nevertheless, in many practical scenarios, it can be justified to allow a fast offline oracle to take a "quick look" at the input sequence and send some advice to the online algorithm. For example, it may be possible to take a quick look and count the number of items which are larger than 1/2 and smaller than 2/3 of the bin capacity. We show that this form of advice can be used to achieve an algorithm which outperforms all online algorithms.

Model
In the last few years, slightly different models of advice complexity have been proposed for online problems. All these models assume that there is an offline oracle with infinite computational power, which provides the online algorithm with some bits of advice. How these bits of advice are given to the algorithm is the source of difference between the models. In the first model, presented in [12], an online algorithm poses a series of questions which are answered by the offline oracle in blocks of answers. The total size of the answers, measured in the number of bits, defines the advice complexity. The problem with this model is that a lot of information can be encoded in the individual length of each block. To address this issue, another model is proposed in [13] which assumes that online algorithms receive a fixed number of bits of advice per request. We call this model the advice-with-request model. This model is studied for problems, such as metrical task systems and k-server, and the results tend to use at least a constant number of bits of advice per request [13,20]. Nevertheless, there are many online problems for which a sublinear and even a constant number of bits of advice in total is sufficient to achieve good competitive ratios. However, under the advice-with-request model, the possibility of sending a sublinear number of advice bits to the algorithm is not well defined. In [8,7] another model of advice complexity is presented which assumes that the online algorithm has access to an advice tape, written by the offline oracle. At any time step, the algorithm may refer to the tape and read any number of advice bits. The advice complexity is the number of bits on the tape accessed by the algorithm. We refer to this model as advice-on-tape model. Since its introduction, the advice-on-tape model has been used to analyze the advice complexity of many online problems including paging [8,17,18], disjoint path allocation [8], job shop scheduling [8,18], k-server [7,20], knapsack [9], various coloring problems [4,15,5,21], set cover [19,6], maximum clique [6], and graph exploration [11].
Under the advice-on-tape model, we require a mechanism to infer how many bits of advice the algorithm should read at each time step. This could be implicitly derived during the execution of the algorithm or explicitly encoded in the advice string itself. For example, we may use a self-delimited encoding as used in [7], in which the value of a non-negative integer X is encoded by writing the value of ⌈log(⌈log(X + 1)⌉ + 1)⌉ in unary (a string of 1's followed by a zero), the value of ⌈log(X + 1)⌉ in binary 3 , and the value of X in binary. These codes respectively require ⌈log(⌈log(X + 1)⌉ + 1)⌉ + 1, ⌈log(⌈log(X + 1)⌉ + 1)⌉, and ⌈log(X + 1)⌉ bits. Thus, the self-delimited encoding of X requires e(X) = ⌈log(X + 1)⌉ + 2⌈log(⌈log(X + 1)⌉ + 1)⌉ + 1 bits. The existence of self-delimited encodings at the beginning of the tape usually adds a lower-order term to the number of advice bits required by an algorithm.
Regarding notation, we use A(σ) to denote the costs of A for packing a request sequence σ. When σ follows from the context, we simply use A to denote this cost. We use similar notation for all algorithms, including OPT.
We consider the bin packing problem under the advice-on-tape model, which is formally defined as follows, based on the definition of the advice model in [7]: Definition 1. In the online bin packing problem with advice, the input is a sequence of items σ = x 1 , . . . , x n , revealed to the algorithm in an online manner (0 < x i ≤ 1). The goal is to pack these items in the minimum number of bins of unit size. At time step t, an online algorithm should pack item x t into a bin. The decision of the algorithm to select the target bin is a function of Φ, x 1 , . . . , x t−1 , where Φ is the content of the advice tape. An algorithm A is c-competitive with advice complexity s(n) if there exists a constant c 0 such that, for all n and for all input sequences σ of length at most n, there exists some advice Φ such that A(σ) ≤ c OPT(σ) + c 0 , and at most the first s(n) bits of Φ have been accessed by the algorithm. If c = 1 and c 0 = 0, then A is optimal.

Contribution
We answer different questions about the advice complexity of the online bin packing problem. First, we study how many bits of advice are required to achieve an optimal so-lution. We consider two different settings of the problem. When there is no restriction on the number of distinct items or their sizes, we present the easy result that n⌈log OPT(σ)⌉ bits of advice are sufficient to achieve an optimal solution, where OPT(σ) is the number of bins in an optimal packing. We also prove that at least (n − 2 OPT(σ)) log OPT(σ) bits of advice are required to achieve an optimal solution.
When there are m distinct items in the sequence, we prove that at least (m − 3) log n − 2m log m bits of advice are required to achieve an optimal solution. If m is a constant, there is a linear time online algorithm that receives m log n + o(log n) bits of advice and achieves an optimal solution. We also show that, even if m is not a constant, there is a polynomial time online algorithm that receives m⌈log(n+1)⌉+o(log n) bits of advice and achieves a packing with (1 + ε) OPT(σ) + 1 bins.
We also study a relevant question that asks how many bits of advice are required to perform strictly better than all online algorithms. We bound this by providing an algorithm which receives log n + o(log n) bits of advice and achieves a competitive ratio of 3/2. Recall that any online bin packing algorithm has a competitive ratio of at least 1.54037 [3]. Hence, our algorithm outperforms all online algorithms.
Moreover, we introduce an algorithm that receives 2n + o(n) bits of advice and achieves a competitive ratio of 4/3 + ε, for any fixed value of ε > 0. We also prove a lower bound that implies that a linear number of bits of advice are required to achieve a competitive ratio of 9/8 − δ for any fixed value of δ > 0.

Optimal Algorithms with Advice
In this section we study the amount of advice required to achieve an optimal solution. We first investigate the theoretical setting in which there is no restriction on the number of distinct items or on their sizes. We observe that there is a simple algorithm that receives n⌈log OPT(σ)⌉ bits of advice and achieves an optimal solution. Such an algorithm basically reads ⌈log OPT(σ)⌉ bits for each item, encoding the index of the bin that includes the item in an optimal packing. We show that the upper bound given by this algorithm is tight up to lower order terms, when n − 2 OPT(σ) ∈ Θ(n).

Theorem 1.
To achieve an optimal packing for a sequence of size n and optimal cost OPT(σ), it is sufficient to receive n⌈log OPT(σ)⌉ bits of advice. Moreover, any deterministic online algorithm requires at least (n − 2 OPT(σ)) log OPT(σ) bits of advice to achieve an optimal packing.
Proof. Upper Bound: Consider an offline oracle that knows an optimal packing (note that such an oracle has unbounded computational power). This oracle simply writes on the advice tape, for each item x, except for the last two, the index of the bin in an optimal packing that x is packed in. To pack any item x, the online algorithm simply reads the index of the bin that x should be packed in and packs x accordingly. For the last two items, the algorithm simply uses Best-Fit. Since the packing is the same as one for an optimal algorithm up to that point, if it is impossible to fit both of the remaining items in the bins already used, Best-Fit will ensure that at least one fits if that is possible. If both of the remaining items fit in the same already open bin, it is fine to put the first one of the last two items anywhere it fits, since there will still be space remaining for the last. If both of the remaining items fit in open bins, but should be in different bins, using Best-Fit will ensure that they are both placed there. This requires ⌈log OPT(σ)⌉ bits of advice per item which sums up to (n−2)⌈log OPT(σ)⌉ bits of advice. The algorithm should also know the value of X = ⌈log OPT(σ)⌉ in order to read the appropriate number of bits on each request. This can be done by encoding X in unary and terminating with a zero. This uses no more than 2⌈log OPT(σ)⌉ bits. Consequently the number of advice bits used by the algorithm is n⌈log OPT(σ)⌉ as stated by the theorem.
Lower Bound: Consider a set S = {σ 1 , . . . , σ N } of sequences, so that each σ r has length n for 1 ≤ r ≤ N . Let 1 ≤ k ≤ n − 1. Each sequence σ r in the set has the form For example, when n = 8 and k = 3, the vector (1, 2, 3, 2, 1) is a vector in V .
We associate with each vector V r ∈ V a sequence σ r ∈ S. For a vector V r ∈ V and bin j, Note that all u j s are strictly larger than 0.5. Clearly, OPT(σ r ) = k for all r. We refer to the first n − OPT(σ) items as small items and the last OPT(σ) items as large items. In fact, V r indicates in which bin each of the first n − OPT(σ) items of σ r should be packed, and at the end, u r j fills the empty space of the jth bin to capacity to achieve an optimal packing P for a given sequence (it is optimal since all bins are fully packed). The restriction that the sequence starts with k distinct items ensures that we do not need to consider permutations of the bins in P as additional optimal packings. We claim that P is the unique optimal packing. Suppose there is another optimal packing P ′ . Observe that each bin includes at most one large item, and indeed exactly one since we assume it is also optimal. Let a i (1 ≤ i ≤ n − OPT(σ)) be the first item which is packed in some other bin in P ′ than the one prescribed by P . Consider the bin B that a i is packed into in P . This bin cannot be fully packed in P ′ since a i is strictly larger than the total size of all remaining small items, i.e., even if we put all of them in the empty space of a i , there is still some empty space in B. As a result P ′ cannot be optimal. Hence there is unique solution for packing each sequence in the set S.
Note that there are N = OPT(σ) n−2 OPT(σ) sequences S. We claim that these sequences need separate advice strings. Suppose otherwise, and let σ r , σ r ′ ∈ S (r = r ′ ) be two different sequences with the same advice string. Note that the first n − OPT(σ) items in these sequences are the same. Since the online algorithm performs deterministically and we assume it receives the same advice for both σ r and σ r ′ , the partial packings of the algorithms after serving the first n − OPT(σ) items are the same for both sequences. However, as discussed earlier, this implies that the final packing of the algorithm is different from the optimal packing prescribed by V r ′′ for at least one of the sequences. As discussed, such a packing is the unique optimal packing and deviating from that increases the cost of the algorithm by at least one unit. As a result, the algorithm performs non-optimally for at least one of σ r or σ r ′ . We conclude that the sequences in the set S need separate advice strings. Since there are N = OPT(σ) n−2 OPT(σ) sequences in S, at least log(OPT(σ) n−2 OPT(σ) ) = (n − 2 OPT(σ)) log OPT(σ) bits of advice are required to get that many distinct advice strings.
⊓ ⊔ Next, we consider a more realistic scenario where there are m ∈ o(n) distinct items and the values of these items are known to the algorithm. Assume that the advice tape specifies the number of items of each size. If we are not concerned about the running time of the online algorithm, there is enough information to obtain an optimal solution. If we are concerned, we can use known results for solving the offline problem [2,14,23]. We formalize this in what follows.

Lemma 1 ([2]). Consider the restriction of the bin packing problem to instances in which the number of distinct item sizes is a constant non-negative integer m. There is a linear time algorithm that optimally solves this restricted problem.
If there are more than a constant number of distinct items sizes, we can solve the problem almost optimally if the item sizes are lower bounded by a fixed value ε.

Lemma 2 ([14,23]).
There is a polynomial algorithm for the bin packing problem which opens at most (1 + ε) OPT(σ) + 1 bin, in which ε is any small but constant value.
We use the above results to otain the following: Theorem 2. Consider the online bin packing problem in which there are m distinct items. If m is a constant, there is a (linear time) optimal online algorithm that receives m log n + o(log n) bits of advice. If m is not a constant, there is a (polynomial time) online algorithm that reads m⌈log(n + 1)⌉ + o(log n) bits of advice and achieves an almost optimal packing with at most (1 + ε) OPT(σ)+ 1 bins, for any small but constant value of ε.
Proof. The offline oracle simply encodes the input sequence, considered as a multi-set, in m⌈log(n + 1)⌉ bits of advice. In order to do that, it writes the number of occurrences of each of the m distinct items on the tape. The online algorithm uses the algorithms of Lemma 1 (for constant values of m) or that of Lemma 2 (for non-constant m) to compute an (almost) optimal packing. Then it packs the items in an online manner according to such an (almost) optimal packing. The algorithms reads frequencies of items in chunks of X = ⌈log(n + 1)⌉ bits and consequently needs to know the value of X. So, we add self-delimited encodings of X at the beginning of the tape using e(X) bits. The number of advice bits used by the algorithm is thus m⌈log(n + 1)⌉ + O (log log n), which is m⌈log(n + 1)⌉ + o(log n) as m ∈ o(n).
⊓ ⊔ We show that the above upper bound is asymptotically tight. We start with the following simple lemma.

Lemma 3. Consider the equation
and X are non-negative integers. If X is sufficiently large, then this equation has at Assign arbitrary values in the range [0..X/A] to all x i s for 2 ≤ i ≤ α (for simplicity assume X/A is an integer). There are (1+X/A) α−1 different such assignments. Any of these assignments defines a valid solution for the equation since by definition of A we have α i=2 ix i ≤ X, and we can assign Proof. We define a family of sequences of length n and containing m distinct items and show that the sequences in this family need separate advice strings to be optimally served by an online algorithm. To define the family, we fix m item sizes as being To simplify the argument, we scale up the sizes of bins and items by a factor of 2m. So, we assume the item sizes are {1, m + 2, m + 3 . . . , 2m − 1, 2m}, and the bins have capacity 2m. Each sequence in the family starts with n/2 items of size 1. Consider any packing of these items in which all bins have level at most equal to m − 2. Such a packing includes a 1 bins of level 1 (one item of size 1 in each), a 2 bins of level 2 (two items of size 1 in each), etc., such that the a i s are non-negative integers and a 1 + 2a 2 + . . . + (m − 2)a m−2 = n/2. By Lemma 3, there distinct packings with the desired property. For any of these packings, we define a sequence in our family. Such a sequence starts with n/2 items of size 1 and is followed by another n/2 items. Let B denote the number of bins in a given packing of the first n/2 items, so that B ≤ n/2. The sequence associated with the packing is followed by B items of size larger than m + 1 which completely fit these bins (in non-increasing order of their sizes). Finally, we include another n/2 − B items of size 2m in the sequence to achieve a sequence of length n.
We claim that any of the sequences in the family has a unique optimal packing of size n/2. This is because there are exactly n/2 large items of size strictly greater than m (more than half the capacity of the bin), and the other n/2 items have small size 1 (which fit the empty space of all bins). So each bin is fully packed with one large item of size x and 2m − x items of size 1 (see Figure 1).
The unique optimal packing of each sequence is defined by the partial packing of the first n/2 small items. Consider a deterministic online algorithm A receiving the same The packing of sequence 1 (15) 11 11 11 11 11 11 11 8 8 12 (6)  advice string for two sequence σ 1 and σ 2 . Since A is deterministic and both sequences start with the same sub-sequence of small items, the partial packing of the algorithm after packing the first n/2 items is the same for both σ 1 and σ 2 . As a result, the final packing of A is sub-optimal for at least one them. We conclude that any deterministic online algorithm should receive distinct advice strings for each sequence in the family.
Since there are at least 1 +

An Algorithm with Sublinear Advice
In what follows we introduce an algorithm that receives log n + o(log n) bits of advice and achieves a competitive ratio of 3 2 , for any instance of the online bin packing problem. An offline oracle can compute and write the advice on the tape in linear time, and the online algorithm runs as fast as First-Fit. Thus, the algorithm might be applied in practical scenarios in which it is allowed to have a "quick look" at the input sequence.
The algorithm reads the advice tape, obtains α, opens α bins, called critical bins, and reserves 2/3 of the space in each of them. This reserved space will be used to pack a medium item in each of the critical bins, and these bins have a virtual level of size 2/3 at the beginning. All other bins have virtual level zero when they are opened. The algorithm serves an item x in the following manner: Note that the critical bins appear first in the ordering maintained by the algorithm as they are opened before other bins.

Theorem 4.
There is an online algorithm which receives log n+ o(log n) bits of advice and has cost 3/2 OPT(σ) + 3 for serving any sequence σ of size n.
Proof. We prove that the algorithm described above has the desired property. The value of α is encoded in X = ⌈log(n + 1)⌉ bits of advice. In order to read this properly from the tape, the algorithm needs to know the value of X. This can be done by adding the self-delimited encoding of X in e(X) = ⌈log X⌉ + 2⌈log log(X)⌉ + 2 bits at the beginning of the tape. Consequently the number of advice bits used by the algorithm is X + O (log X), which is log n + o(log n) as stated by the theorem.
Consider the final packing of the algorithm for serving a sequence σ. There are two cases. In the first case, there is a critical bin B so that no other item, except a medium item, is packed in it. Since all tiny items are smaller than 1/3 and can fit in B, all the non-critical bins that are opened after B include small and large items only. More precisely, they include either a single large item or two small items (except the last one In the second case, we assume that all critical bins include another item in addition to the medium item. We claim that at the end of serving a sequence all bins, except possibly two, have level at least 2/3. First, we verify this for non-critical bins (bins without medium items). If a non-critical bin is opened by a large item, it clearly has level higher than 2/3. All other non-critical bins only include items of size at most 1/2. Hence, these bins, except possibly the last one, include at least two items. Among the non-critical bins that include two items, consider two bins b i and b j (i < j) that have levels smaller than 2/3. Since b j contains at least two items, at least one of them has size smaller than 1/3. This item could fit in b i by the FF property. We conclude that all non-critical bins, except possibly two, have level at least 2/3. Now, suppose two critical bins b i and b j have levels smaller than 2/3. Consider the first non-medium item x which is packed in b j (in the second case, such an item exists). Since a medium item is packed in the bin, x should be either tiny or small. If x is small, then the level of b j is at least 1/2 + 1/3, which contradicts the level of b j being smaller than 2/3. Similarly, x cannot be a tiny item of size larger than 1/6 (since 1/2 + 1/6 ≥ 2/3). Hence, x is a tiny item of size at most 1/6. This implies that at the time the online algorithm packs x, bin b i has a virtual level of at least 5/6. The virtual level is at most 1/6 larger than the actual level (the final level). Hence, the actual level of b i is at least 5/6 − 1/6 = 2/3. We conclude that at most one critical bin has level smaller than 2/3. To summarize, at most three bins have level smaller than 2/3. Hence, the cost of the algorithm is at most 3/2 OPT(σ) + 3.

An Algorithm with Linear Advice
In this section, we present an algorithm that receives 2n + o(n) bits of advice and achieves a competitive ratio of 4/3 + ε for any sequence of size n, and arbitrarily small (but constant) values of ε. Consider an algorithm that receives an approximate size for each sufficiently large item x encoded using k bits. The approximate size of x would be larger than its actual size by at most an additive term of 1/2 k . The algorithm can optimally pack items by their approximate sizes and achieve an approximate packing which includes a reserved space of size x + ε (ε ≤ 1/2 k ) for each item. Precisely, for each sufficiently large item x, the approximate packing includes a reserved space of size x + ε (ε ≤ 1/2 k ) for x. This enables the algorithm to place x in the reserved space for it in the approximate packing. Smaller items are treated differently and the algorithm does not reserve any space for them. In the reminder of this section, we elaborate this idea to achieve a 4/3-competitive algorithm. Notice that the cost of an approximate packing can be as large as 3 2 times the cost of OPT. To see that, consider a sequence which is a permutation of 1 2 + ε 1 , 1 2 − ε 1 , 1 2 + ε 2 , 1 2 −ε 2 , . . . , 1 2 +ε n/2 , 1 2 −ε n/2 , where ε i < 1/2 n (1 ≤ i ≤ n/2). Since OPT packs all bins tightly, an increase in the sizes of items by a constant (small) ε results in opening a new bin for each two bins OPT uses. Hence the cost of the optimal approximate packing can be as bad as 3 2 OPT. This example suggests that using approximate packings is not good for the bins in which a small number of large items are tightly packed. To address this issue we divide the bins of OPT into two groups: Definition 2. Consider an optimal packing of a sequence σ. Given a small parameter ε ′ < 1/60, define good bins to be those where the total size of the items smaller than 1/4 in the bin is at least 5ε ′ . Define all other bins to be bad bins.
A part of the advice received for each item x indicates if x is packed by OPT in a good bin or in a bad bin. This enables us to treat items packed in these two groups separately.

Lemma 4.
Consider sequences for which all bins in the optimal packing are good (as defined above). There is an online algorithm that receives o(n) bits of advice and achieves a competitive ratio of 4/3.

Proof.
Call an item small if it is smaller than or equal to 1/6 and large otherwise. The advice bits define the approximate sizes of all large items with a precision of ε ′ . The amount of advice will be roughly 2 1/ε ′ log n which is o(n) for constant values of ε ′ . The online algorithm A can build the optimal approximate packing of large items. In such a packing, there is a reserved space of size at most x + ε ′ for any large item of size x. The algorithm considers this packing as a partial packing and initializes the level of each bin to be the total sizes of approximated items in that bin. For packing an item x, if x is large, A packs it in the space reserved for it in the approximate packing. It also updates the level of the bin to reflect the actual size of x. If x is small, A simply applies the First-Fit strategy to pack x in a bin of the partial packing (and opens a new bin for it if necessary). We prove that A is 4/3-competitive. In the final packing by A, call a bin "red" if all items packed in it are small items and call it "blue" otherwise (the blue bins constitute the approximated packing at the beginning). There are two cases to consider.
In the first case, there is no red bin in the final packing of A, i.e., all small items fit in the remaining space of the bins in the approximate packing of large items. Let σ ′ be a copy of the input sequence in which the sizes of large items are approximated, i.e., increased by at most ε ′ ; also let X be the number of bins for the optimal packing of σ ′ . Since there is no red bin in the final packing of A, the cost of A is equal to X. Consider the optimal packing of the actual input sequence σ. Since all bins are good, one can transfer a subset of items to provide an available space of size at least 5ε ′ in each bin. After such a transfer, we can increase the sizes of large items to their approximate sizes. Since there are at most 5 large items in each bin and also available space of size at least 5ε ′ , the packing constructed this way is a valid packing for the sequence σ ′ . Since the size of the transferred items for each bin is at most 1/4, the transferred items from each group of four bins can fit in one new bin. Consequently the number of bins in the new packing is at most 5/4 OPT(σ). We know that the final packing by A is the optimal packing for σ ′ (with cost X), and in particular not worse than the packing constructed above. Hence, the cost of A is not more than 5/4 OPT(σ).
In the second case, there is at least one red bin in the final packing of A. We claim that all bins in the final packing of A, except possibly the last, have levels larger than 3/4. The claim obviously holds for the red bins since the levels of all these bins (excluding the last one) are larger than 5/6. Moreover, since there is a bin which is opened by a small item, all blue bins have levels larger than 5/6, i.e., the total size of packed items and reserved space for the large items is larger than 5/6. Since there are at most 5 large items in each bin, the actual level of each bin in the final packing of A is at least 5/6 − 5ε ′ , which is not smaller than 3/4 for ε ′ ≤ 1/60. So, all bins, except possibly one, have levels larger than 3/4. Consequently, the algorithm is 4/3-competitive.
⊓ ⊔ It remains to address how to deal with bad bins. The next three lemmas do this.

Lemma 5.
Consider sequences for which all bins in the optimal packing include precisely two items. There is an algorithm that receives 1 bit of advice per request and achieves an optimal packing.
Proof. The single bit of advice for an item x determines whether or not the p artner of x appeared as a previous request, where the partner of x is the i tem which is packed in the same bin as x in OPT's packing. Consider an algori thm A that works as follows: If the partner of x has not been requested yet , A opens a new bin for x. Otherwise, it uses the BF strategy to pack x i n one of the open bins.We claim that A achieves an optimal packing. Assume that initially we have a mapping that maps the last item to go into a bin to the item it goes on top of in the optimal packing, i.e., it maps the second item of each bin to the first item. We update this mapping when necessary and maintain the invariant that we can always pack optimally according to the mapping. For serving a request x , if BF does not pack according to this mapping, it packs x on top of y ′ , while, according to the mapping, it was supposed to pack x on top of y, and a later x ′ is supposed to go on top of y ′ . Due to the BF strategy, y ′ geqy, so we can update the mapping to map the currently unprocessed x ′ to y, and, of course, x to y ′ .
⊓ ⊔ Lemma 6. Consider a sequence σ for which all items have sizes larger than 1/4 and for which each bin in OPT's packing includes precisely three items. The cost of the Harmonic algorithm is at most 4/3 OPT(σ) + 3 for serving such a sequence.
Proof. The proof is based on a simple weighting function. Call an item x large if 1/3 < x < 1/2 and small otherwise (1/4 < x ≤ 1/3). Define the weight of x to be 1/2 if x is large and 1/3 if it is small. Consider a bin B in the packing of σ by OPT. Since there are three items in B, its weight is maximized when there are two large items and one small item in it (three large item do not fit in the same bin). Hence, the weight of each bin in the OPT packing is at most 2 × 1/2 + 1/3 = 4/3. Consequently, we have OPT(σ) ≥ 3/4W , where W is the total weights of all items. The Harmonic algorithm (HA) simply packs small and large items in separate collections of bins. So, each of the algorithm's bins, except possibly two bins, contains either three small items or two large items. In both cases, the weight of each bin is at least 1 and we have HA(σ) ≤ W + 2. As a conclusion HA(σ) ≤ 4/3 OPT(σ) + 2 which completes the proof.
⊓ ⊔ Lemma 7. Consider a sequence σ for which all bins in the optimal packing are bad bins (as defined earlier). There is an algorithm that receives two bits of advice for each request, and opens at most (4/3 + 5ε ′ 1−5ε ′ ) OPT(σ) + 3 bins.
Proof. By the definition of bad bins, for any bin in the optimal packing, all items are either smaller than 5ε ′ or larger than 1/4. We call the former group of items tiny items and pack them separately using the FF strategy. We refer to other items as normal items.
Consider an offline packing P which is the same as OPT's packing, except that all tiny items are removed from their bins and packed separately in new bins using the FF strategy. This implies that the cost of P is larger than OPT(σ) by a multiplicative factor of at most 1 + 5ε ′ 1−5ε ′ . Let Q be the optimal packing for normal items. Since all normal items are larger than 1/4, each bin of Q contains at most three items. We say a bin of Q has type i (i ∈ {1, 2, 3}), if it contains i normal items. Similarly, we say an item x has type i if it is packed in a type i bin. All items in type 3 bins have sizes smaller than 1/2 (otherwise one will have size at most 1/4 which contradicts the assumption). Moreover, the sizes of the items in all type 1 bins (except possibly the last one) are larger than 1/2 (otherwise a better packing is achieved by pairing two of them). With two bits of advice, we can detect the type of an item as follows: Let b denote the two bits of advice with item x. If b is "01" and x > 1/2, then x has type 1; if b is "01" and x ≤ 1/2, then x has type 3; and if b is "10" or b is "11", then x has type 2. Note that the code "00" is not used at this point (this is used later on), and the use of "10" and "11" is still to be detailed.
Let X i denote the number of bins of type i (1 ≤ i ≤ 3). Hence, the cost of Q is X 1 + X 2 + X 3 , and consequently the cost of P is at least X 1 + X 2 + X 3 + X ′ , where X ′ is the number of bins filled by tiny items. Consider an algorithm A that performs as follows. If an item x has type 1, A simply opens a new bin for x. If x has type 2, A applies the strategy of Lemma 5 to place it in one of the bins maintained for items of type 2. Recall that the advice in this case is either "10" or "11", so the second bit provides the advice required by Lemma 5. If x has type 3, A applies the Harmonic strategy to pack the item in a set of bins maintained for type 3 items. By Lemma 6, the cost of A for these items is at most 4/3X 3 + 3. Finally, A uses the FF strategy to pack tiny items in separate bins. Consequently, the cost of the algorithm is at most . ⊓ ⊔ Provided with the above results, we arrive at the following result: Theorem 5. There is an online algorithm which receives two bits of advice per request, plus an additive lower order term, and achieves a competitive ratio of 4/3 + ε, for any positive value of ε.
Proof. Define ε ′ to be 11ε 60 . For ε < 1/11, we have ε ′ < 1/60. Moreover, we have In an optimal packing, divide bins into good and bad bins using Definition 2. Also, let Gd and Bd respectively denote the number of good and bad bins. Use advice bits to distinguish items which are packed in good and bad bins, and pack them in separate lists of bins. More precisely, let the two bits of advice for an item x be "00" if it is packed by OPT in a good bin, and apply Lemma 4 to pack these items in at most 4/3Gd bins. Similarly, apply Lemma 7 to pack items from bad bins in at most (4/3 + 5ε ′ 1−5ε ′ )Bd + 3 ≤ (4/3 + ε)Bd + 3 bins, using bits of advice of the form "01", "10", or "11", as discussed in the proof of Lemma 7. Consequently, the cost of the algorithm will be at most 4/3Gd + (4/3 + ε)Bd + 3 ≤ (4/3 + ε) OPT(σ) + 3. ⊓ ⊔

A Lower Bound for Linear Advice
The GMP problem [13] and the String Guessing Problem [6] both contain a core special case of guessing a binary sequence. We use their results to show that an online algorithm needs a linear number of bits of advice to achieve a competitive ratio better than 9/8 for bin packing.

Definition 3 ([13,6]).
The Binary String Guessing Problem with known history (2-SGKH) is the following online problem. The input I = (n, σ = x 1 , x 2 , . . . , x n ) consists of n items that are either "0" or "1" and that are revealed one by one. For each item x t , the online algorithm A must guess if it is a "0" or a "1". After the algorithm has made a guess, the value of x t is revealed to the algorithm.
Since the number of bits needed to express the number of "0"s in the input is at most ⌈log(n + 1)⌉ ≤ log n + 1, and this number can be given as advice by an oracle, if it is not given to the algorithm otherwise, we easily obtain the following lemma. Recall that the definition of e, the length of the encoding function, is given in Section 1.1.

Lemma 9.
Consider instances of size n of the 2-SGKH problem in which the number of "0"s is given to the algorithm as part of the input. For these instances, any deterministic algorithm that is guaranteed to guess correctly on more than αn bits, for 1/2 ≤ α < 1, needs to read at least (1 + (1 − α) log(1 − α) + α log α)n − e(n) bits of advice.
Proof. Assume to the contrary that the statement is not true. Hence, there is an algorithm, BSGA, that knows the number of "0"s and receives fewer than (1+(1−α) log(1− α) + α log α)n − e(n) bits of advice while guessing correctly on more than αn bits. This algorithm can be used to serve arbitrary instances of the 2-SGKH problem (in which the number of "0"s is not known). Modify the advice tape used by the algorithm BSGA so that it contains at most e(n) additional bits at the beginning specifying the number of "0"s. (This can be done with the self-delimited encoding of the number of "0"s.) The algorithm for 2-SGKH reads this number and gives it to BSGA. Then it asks BSGA for its guess for each bit in the sequence and answers the same as BSGA. It also informs BSGA of when it is correct and when it is wrong, with the same information it is given. The algorithm is correct exactly when BSGA is correct. The total number of advice bits will be less than e(n) However, Lemma 8 implies that no algorithm can guess correctly on more than αn bits with this many bits of advice. In conclusion, the initial assumption is incorrect and the statement holds.

⊓ ⊔
In order to relate the Binary String Guessing Problem to the online bin packing problem, we introduce another problem called the Binary Separation Problem.

Definition 4.
The Binary Separation Problem is the following online problem. The input I = (n 1 , σ = y 1 , y 2 , . . . , y n ) consists of n = n 1 + n 2 positive values which are revealed one by one. There is a fixed partitioning of the set of items into a subset of n 1 large items and a subset of n 2 small items, so that all large items are larger than all small items. Upon receiving an item y i , an online algorithm for the problem must guess if y belongs to the set of small or large items. After the algorithm has made a guess, it is revealed to the algorithm whether y i actually belongs to class of small or large items.
We provide reductions from the modified Binary String Guessing Problem to the Binary Separation Problem, and from the Binary Separation Problem to the online bin packing problem. In order to reduce a problem P 1 to another problem P 2 , given an instance of P 1 defined by a sequence σ 1 and a set of parameters η 1 (such as the length of σ 1 or the number of "0"s in it), we create an instance of P 2 which is defined by a sequence σ 2 and also a set of parameters η 2 . In our reductions, we assume η 2 is derived from η 1 , and since σ 1 is revealed in an online manner, σ 2 is created in an online manner by looking only at η 1 and the revealed items of σ 1 .

Algorithm 1 Implementing Binary String Guessing via Binary Separation.
The Binary Guessing algorithm knows the number of "0"s (n1) and passes it as a parameter (the number of large items) to the Binary Separation algorithm 1: small = 0; large = 1 2: repeat 3: mid = (large − small) / 2 4: class guess = SeparationAlgorithm.ClassifyThis(mid) 5: if class guess = "large" then 6: bit guess = 0 7: else 8: bit guess = 1 9: actual bit = Guess(bit guess) {The actual value is received after guessing (2-SGKH).} 10: if actual bit = 0 then 11: large = mid {We let "large" be the correct decision.} 12: else 13: small = mid {We let "small" be the correct decision.} 14: until end of sequence Lemma 10. Assume that there is an online algorithm that solves the Binary Separation Problem on sequences of length n with b(n) bits of advice, and makes at most r(n) mistakes. Then there is also an algorithm that solves the Binary String Guessing Problem on sequences of length n, assuming the number of "0"s is given as a part of input, so that the algorithm receives b(n) bits of advice and makes at most r(n) errors.
Proof. We assume that we have an algorithm BSA that solves the Binary Separation Problem under the conditions of the lemma statement. Using that algorithm, we define the number n 1 of large items to be the number of "0"s in the instance of the Binary String Guessing Problem. Then, we implement our algorithm BSGA for the Binary String Guessing Problem as outlined in Algorithm 1, which defines the reduction. This BSGA implementation, defined in Algorithm 1, functions as an adversary for BSA, e.g., in Line 4, BSGA gives BSA its next request. Notice that we ensure that the BSGA makes a correct guess if and only if BSA makes a correct guess. The advice tape is filled with bits of advice for this combined algorithm. The BSGA uses the BSA as a sub-routine, but all the questions are effectively coming from the BSA.
The set-up, reminiscent of binary search, is carried out as specified in the algorithm with the purpose of ensuring that when the BSA is informed of the actual class of the item it considered, no result can contradict information already obtained. Specifically, the next item for the BSA to consider is always in between the largest item which has previously been deemed "small" and the smallest item which has previously been deemed "large". The fact that we give the middle item from that interval is unimportant; any value chosen from the open interval would work.
⊓ ⊔ Now, we prove that if we can solve a special case of the bin packing problem, we can also solve the Binary Separation Problem. Lemma 11. Consider the bin packing problem on sequences of length 2n for which OPT opens n bins. Assume that there is an online algorithm A that solves the problem on these instances with b(n) bits of advice and opens at most n + r(n)/4 bins. Then there is also an algorithm BSA that solves the Binary Separation Problem on sequences of length n with b(n) bits of advice and makes at most r(n) errors.
Proof. In the reduction, we encode requests for the BSA as items for bin packing. Assume we are given an instance I = (n 1 , σ = y 1 , y 2 , . . . , y n ) of the Binary Separation problem, in which n 1 is the number of large items (n 1 + n 2 = n), and the values of y t s are revealed in an online manner (1 ≤ t ≤ n). We create an instance of the bin packing problem which has length 2n. Algorithm 2 shows the details of the reduction. The bin packing sequence starts with n 1 items of size 1 2 + ε min (in Algorithm 2, the variable "NumberOfLargeItems" is n 1 from the Binary Separation Problem). Any algorithm needs to open a bin for each of these n 1 items. We create the next n items in an online manner, so that we can use the result of their packing to guess the requests for the Binary Separation Problem. Let τ = y t (1 ≤ t ≤ n) be a requested item of the Binary Separation Problem; we ask the bin packing algorithm to pack an item whose size is an increasing function of τ , and slightly less than 1 2 . Depending on the decision of the bin packing algorithm for opening a new bin or placing the item in one of the existing bins, we decide the type of τ as being consecutively small or large. The last n 2 items of the bin packing instance are defined as complements of the items in the bin packing instance associated with small items in the binary separation instance (the complement of item x is 1 − x). We do not need to give the last items complementing the small items in order to implement the algorithm, but we need them for the proof of the quality of the correspondence that we are proving.
Call an item in the bin packing sequence "large" if it is associated with large items in the Binary Separation Problem, and "small" otherwise. For the bin packing sequence produced by the reduction, an optimal algorithm pairs each of the large items with one of the first n 1 items (those with size 1 2 + ε min ), placing them in the first n 1 bins. OPT pairs the small items with their complements, starting one of the next n 2 bins with each of these small items. Hence, the cost of an optimal algorithm is n 1 + n 2 = n. The values ε min and ε max in Algorithm 2 must be small enough so that no more than two of any of the items given in the algorithm can fit together in a bin. No other restriction is necessary.
We claim that each extra bin used by the bin packing algorithm, but not by OPT, results in at most four mistakes made by the derived algorithm on the given instance of the Binary Separation Problem. Consider an extra bin in the final packing of A. This bin is opened by a large item which is incorrectly guessed as being small (bins which are opened by small items also appear in OPT's packing). Note that large items do not fit in the same bins as complements of small items. The extra bin has enough space for another large item. Moreover, there are at most two small items which are incorrectly guessed as being large and placed in the space dedicated to the large items of the extra bin. Hence, there is an overhead of at least one for four mistakes. To summarize, A has to decide if a given item is small or large and performs accordingly, and it pays a cost of at least 1/4 for each incorrect decision. If A opens at most n + r(n)/4 bins, the algorithm derived from A for the Binary Separation Problem makes at most r(n) mistakes.

Concluding Remarks
We conjecture that a sublinear number of bits of advice is enough to achieve competitive ratios smaller than 4/3. Note that our results imply that we cannot hope for ratios smaller than 9/8 with sublinear advice.