 # A new lower bound for classic online bin packing

We improve the lower bound on the asymptotic competitive ratio of any online algorithm for bin packing to above 1.54278. We demonstrate for the first time the advantage of branching and the applicability of full adaptivity in the design of lower bounds for the classic online bin packing problem. We apply a new method for weight based analysis, which is usually applied only in proofs of upper bounds. The values of previous lower bounds were approximately 1.5401 and 1.5403.

## Authors

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

The bin packing problem [20, 13, 9]

is a well-studied combinatorial optimization problem with origins in data storage and cutting stock. The input consists of items of rational sizes in

, where the goal is to split or pack them into partitions called bins, such that the total size of items for every bin cannot exceed . The online bin packing problem [10, 9] is its variant where items are presented one by one, and the algorithm assigns each item to a bin before it can see the next item.

For an algorithm and an input , let be the cost (number of bins) used by for . The algorithm can be an online or offline algorithm, and it can also be an optimal offline algorithm OPT. The absolute competitive ratio of algorithm for input is the ratio between and . The absolute competitive ratio of is the worst-case (or supremum) absolute competitive ratio over all inputs. Given an integer , we can consider the worst-case absolute competitive ratio over inputs where is not smaller than . Taking this sequence and letting grow to infinity, the limit is the asymptotic competitive ratio of . This measure is the standard one for analysis of the bin packing problem, and it is considered to be more meaningful than the absolute ratio (which is affected by very small inputs).

The current best online algorithm with respect to the asymptotic competitive ratio has an asymptotic competitive ratio no larger than , which was found recently by development of new methods of analysis. Previous results were achieved via a sequence of improvements [14, 15, 22, 16, 18, 19, 12]. In this work, we consider the other standard aspect of the online problem, namely, of establishing lower bounds on the asymptotic competitive ratio that can be achieved by online algorithms.

The first lower bound on the asymptotic competitive ratio was found by Yao , and it uses an input with at most three types of items: , , and (where is sufficiently small). For this input, if the entire input is presented, every bin of an optimal solution has one item of each type (and otherwise there are larger numbers of items in a bin, but all bins are still packed identically). It is possible to start the sequence with smaller items, for example, it can be started with and then , which increases the result. This was discovered by Brown and Liang (independently) [17, 8], who showed a lower bound of 1.53635. Van Vliet  found an interesting method of analysis and showed that the same approach (the same sequence with additional items) gives in fact a lower bound of 1.5401474. Finally, Balogh, Békési, and Galambos  showed that the greedy sequence above is actually not the best one among sequences with batches of identical items, and proved a lower bound of (see also  for an alternative proof). Their sequence starts with decreasing powers of plus epsilon (it can be started with items complementing the other items to but it does not change the bound), and after the other items are exactly those used by Yao . This result of  is the previously best known lower bound.

One drawback of the previous lower bounds is that while the exact input was not determined in advance, the set of sizes used for it was determined prior to the action of the algorithm by the input provider and it was known to the algorithm. Moreover, for classic bin packing, in all previously designed lower bound inputs, sizes of items were slightly larger than a reciprocal of an integer, and optimal solutions consisted of bins with identical packing patterns. The possible item sizes and numbers of items were known to the algorithm, but the stopping point of the input was unknown, and it was based on the action of the algorithm. It seemed unlikely that such examples are indeed the worst-case examples. We show here that different methods for proving lower bounds and new approaches to sizes of items give an improved lower bound.

### New features of our work.

Previous lower bound constructions for standard bin packing were defined for inputs without branching. Those are inputs where the possible inputs differ only by their stopping points. Here, we use an input with branching, which makes the analysis harder, as those branches are related (the additional items may use the same existing bins in addition to new bins), but at most one of them will be presented eventually. It is notable that branching was used to design an improved lower bound for the case where the input consists of three batches  (where for each one of the batches, all items are presented at once), but it was unknown whether it can be used to design improved lower bounds for standard online bin packing. That is, it was unknown if the impact of branching in  is similar to one additional batch or if it gives the adversary more power that can be used in the general settings as well.

It was also not known whether one can exploit methods of constructing fully adaptive inputs, where in some parts of the input every item size is based precisely on previous decisions of the algorithm. Such results were previously proved for online bin packing with cardinality constraints, where (in addition to the constraint on the total size) every bin is limited to containing items, for a fixed parameter [7, 1, 11, 3]. Thus, in addition to branching we will use the following theorem proved in  (see the construction in Section 3.1 and Corollary 3 in ).

###### Theorem 1

Let be a large positive integer and let be an integer. Assume that we are given an arbitrary deterministic online algorithm for a variant of bin packing and a binary condition on the possible behavior of an online algorithm for one item (on the way that the item is packed). An adversary is able to construct a sequence of values () such that for any , , and in particular (defining item sizes is done using a given linear function of the values ), such that for any item satisfying and any item not satisfying , it holds that .

Examples for the condition can be the following: “the item is packed as a first item of its bin”, “the item is packed into a non-empty bin”, “the item is packed into a bin already containing an item of size above ”, etc. Here, the condition will be that the item is not packed into an empty bin (or a new bin).

Our method of analysis is based on a new type of a weighting function. This kind of analysis is often used for analyzing bin packing algorithms, that is, for upper bounds. It was used for lower bounds  and by van Vliet 

(where the term weight is not used, and the values given to items are based on the dual linear program, but the specific kind of dual variables and their usage can be adapted to a weighting function). However, those weights were defined for inputs without branching and we extend the use of these weights for inputs with branching for the first time, which adds technical challenges to our work also in the analysis. The advantage of weights is that we do not need to test all packing patterns of an algorithm, whose number can be very large, and thus we obtain a complete and verifiable proof with much smaller number of cases than that of pattern based proofs (see for example

).

## 2 The input

Let be an integer, let be small constant, let be a large integer and let ( is a large integer divisible by ). The condition on is: .

Given a specific algorithm ALG, we will analyze it for the set of inputs defined here, where the input depends on the actions of ALG both with respect to stopping the input, but also some of the sizes will be based on the exact action of ALG, and on the previously presented items and their number.

Let , and for , let . The input starts with batches of items of the sizes , for every , where the input may be stopped after each one of these batches. An item of size is called a –item.

Afterwards, there are items called –items. The sizes of –items will be all strictly larger than but strictly smaller than . Any –item packed as a first item into a bin will be called a large –item, and any other –items will be called a small –item. During the construction, based on the actions of the algorithm, we will ensure that for any large –item, its difference from is larger by a factor of more than than the difference from of any small –item. The details of attaining this property are given below (see Lemma 2).

Let be such that the size of every small –item is at most while the size of every large –item is above (where ). The input may be stopped after –items are introduced (the number of items is no matter how many of them are small and how many are large). Let denote the number of large –items, and therefore there are small –items. Even though the –items will have different sizes and they cannot be presented at once to the algorithm, we see them as one batch.

If the input is not stopped after the arrival of –items, there are three options to continue the input (i.e., we use branching at this point). In order to define the three options, we first define the following five items types. A –item has size . A –item has size and a –item has size . A –item has size and a –item has size (this size is above ).

The first option to continue is with –items, such that a batch of such items arrive. The second option is with a batch of –items, possibly followed by a batch of –items. In this option, the number of items of each batch is . The third option is that a batch of –items arrive, possibly followed by a batch of –items. In the last case, we define the numbers of items based on as follows. The number of –items (if they are presented) is . The number of –items (if they are presented) is . This concludes the description of the input (see Figure 1 for an illustration). Figure 1: An illustration of the input. Every box contains a set of items, and the input may be stopped after presenting the items of any box. In cases with branching, at most one path is selected, and any such path may be presented as an input.

We conclude this section by showing that indeed we can construct the batch (or subsequence) of –items satisfying the required properties.

###### Lemma 2

The sizes of –items can be constructed as described.

Proof. We use Theorem 1. Condition is that the item is packed into a bin that already contains at least one item (this item may be of a previous batch of items). Let . The items sizes are . We find that all item sizes are in . We also have for two items of sizes and , where the second item does not satisfy while the first one satisfies that . Let be the maximum size of any value of an item satisfying . Then, we have and , as required.

In order to give some motivation regarding the sizes of items, note that by , we have , while .

## 3 Bounds on the optimal costs

We find upper bounds on optimal costs. We denote the optimal cost after the batch of items of sizes is presented by (for ). Similarly, we denote an optimal cost after the batch of –items by .

###### Lemma 3

For , we have , and . Furthermore, let , then the total size of one item of each batch up to the batch of –items (if ) or up to the batch of –items (if ) is at most .

Proof. First, consider . The total size of items, each of a different size out of is , as . Thus, it is possible to pack items of each size into every bin and get a feasible solution with bins, so .

A similar bound can be used for the input up to the batch of –items as well. In this case the total size of one item of each size together with one –item (small or large) is at most . Thus, (by packing six items of each batch into every bin).

We let , , , , , denote costs of optimal solutions for the inputs after the batches of –items, –items, –items, –items, and –items were presented, respectively. In the next lemma we present upper bounds on these optimal costs.

###### Lemma 4

We have , , , , and .

Proof. We have , as it is possible to pack three items of each batch and one –item into each bin of a feasible solution, since their total sizes are below .

We have , as it is possible to pack two items of each batch and two –items into each bin of a feasible solution, since their total sizes are below .

We have , as it is possible to pack one item of each batch, one –item and one –item into each bin, since their total sizes are below .

If the third option for continuing the input is used, we define solutions as follows. The first solution is for the input up to –items. There are bins with six large –items, and six items of each one of the preceding batches, there are bins with two –items and two small –items, and finally there are bins with two –items and items of each of the sizes . The numbers of bins of the three types are , , and , respectively. We next argue that this is a feasible solution. The number of –items that are packed is , the number of large –items that are packed is , the number of small –items that are packed is , and for every (), the number of –items is , so all items are packed. The bins are valid as the total size of items packed into a bin is at most , as we show now. For a bin of the first type, the total size of items is at most . The total size of items packed into a bin of the second type is at most . Finally, the total size of items packed into a bin of the third type is at most . Thus, .

The second solution is for the input up to –items. Every bin has one –item. The other contents are as follows. There are bins with three large –items, and three items of each one of the preceding batches, there are bins with one –item and one small –item, and finally there are bins with one –item and items of each of the sizes . Those are halves of the contents of the bins in the case that –items do not arrive, and the total sizes of such halves are at most . The total size packed into each bin is at most . Thus, .

We next prove that the optimal costs are at least (for all possible inputs). We have , as while , and by . Thus, as all inputs contain the first batch of –items, and every bin has at most such items, we get that an optimal solution has at least bins.

## 4 An analysis using weights

In this section we provide a complete analytic proof of the claimed lower bound that we establish using our construction. In fact we verified the tightness of our analysis (for this construction) by solving a mathematical program for some very small values of . Our analytic proof is based on assigning weights to items, defining prices to bins using the weights and bin types, and finally using these prices to establish the lower bound.

### The assignment of weights to items.

We assign weights to items as follows. For a –item, where , we let its weight be . The weight of a –item is . The weight of a large –item is denoted by where . The weight of any other item is , those are –items, –items, –items, –items, –items, and small –items.

### Definition of bin type.

For a bin packed by the algorithm, we say that it has type if it has a –item for some and no smaller items (i.e., for any such that , it has no –item). We say that it has type if it has an –item and no smaller items (i.e., it has no –item for all ). We say that it is a double bin if it has a –item or a –item and no smaller items (i.e., no –item for all and no –item), and we say that it is a single bin if it has only items of sizes above , i.e., a –item or a –item or a –item (where every such bin has exactly one item).

### The price of a bin type.

We define the price of a bin type as follows. A bin of a certain type may receive additional items after its first batch of items out of which its first item comes. Moreover, its contents may differ in different continuations of the input (due to branching). Consider the contents of for all continuations simultaneously (taking into account the situation where these items indeed arrive), and define a set of items based on this (one can think of as a virtual bin, which is valid for any possible input). For example, if the bin has one (large) –item, and in the first continuation it will receive a –item, in the second continuation it will receive one –item and one –item, and in the third continuation it would receive two –items, then the set contains six items (one of size approximately , one of size approximately , two of sizes approximately , and two of sizes approximately ). The price of is defined as the total weight of items of (for the example, this price is ). The price of a bin type is the supremum price of any bin of this type.

### Calculating the prices of the bin types.

Let denote the price of bin type , for , let denote the price of a double bin, and let denote the price of a single bin.

###### Lemma 5

For the weights defined above, we have , , and .

Proof. We have and as all items of sizes above have weights of . This holds as a single bin has exactly one item, while for a double bin , and there is just one continuation to be considered (so it either has two identical items, or its second item has size above , and in both cases the price is ).

Consider now type bins. For such a bin , we consider . This is a bin whose first item is an –item, it has one large –item and possibly also small –items. The weight of its large –item is , and we calculate the weight of other items, and show that it is at most . The number of small –items of is between zero and five (as the sizes of –items are above ).

• If has at least four small –items, it has no space for further items (as the total size would be above ). In this case, , and its price is at most .

• If has exactly three small –items, the space for other items is below , so can have one –item and one –item, and its price is again .

• If has exactly two small –items, can have one item for every continuation, and , so its price is again .

• If has exactly one small –item, can have one –item (or one –item), but it cannot have two –items, as the size of one small –item, one large –item, and two –items is above . It can contain a –item, and it can contain two –items. Thus, , so its price is again .

• Finally, if it has no small –items, it can contain two –items or one –item or two –items, and in this case we also have , and a price of .

###### Lemma 6

For the weights defined above, we have for , and .

Proof. Consider a type bin (for ). As an –item can be large only in the case that it is packed into an empty bin, may only have small –items (and items which are not –items).

In the case , we claim that every –item for any can be replaced with –items. The total size of items is not increased (the size of a item is above while the total size of –items is below , so for any possible continuation after the –items, the remaining members of can still be packed. Similarly, every (small) –item is replaced with –items (whose total size is smaller). The weight is unchanged since the weight of every –item is , so the total weight of –items is , which is the weight of a –item, and this is valid for the case (of –items) as well. Thus, we assume that has some number of –items, and calculate the number of –items, –items, and –items that can be packed given the number of –items (as and , and they all have weights of , we consider only single items and pairs of –items and pairs of –items).

We show what cannot be included in . The maximum number of –items is . We will use the following property: . This property holds as and therefore

 (28⋅7t−2+1)⋅294\upvarepsilon+\upvarepsilon≤(24⋅7t+1+295)\upvarepsilon<25⋅7t+1\upvarepsilon<25⋅7t+16t⋅73t<16t−1⋅72t−2 ,

as .

• If there are at least –items in , there cannot be two –items as .

• If there are at least –items in , there cannot be two –items as .

• If there are at least –items in , there cannot be a –item as .

• If there are at least –items in , there cannot be a –item and there cannot be a –item as and the fact that a item is larger than a –item.

Now, we can find upper bounds on the prices in all cases.

• If the number of –items is at most , the price is at most .

• If the number of –items is at least and at most , the price is at most .

• If the number of –items is at least and at most , the price is at most .

• If the number of –items is at least and at most , the price is at most .

• If the number of –items is at least , the price is at most .

Next, we consider for , and show that the price is slightly smaller. No bin can contain more than –items (as their sizes are above ). Here, we can replace every item of size (for ) by exactly –items without modifying the total weight and similarly we can replace every small item by items without changing the total weight. Thus, we will assume that does not contain such items. We will use the properties that the numbers and are divisible by , and the numbers and are divisible by .

• If there are at least –items in , there cannot be two –items as .

• If there are at least –items in , there cannot be two –items as .

• If there are at least –items in , there cannot be a –item as .

• If there are at least –items in , there cannot be a –item as .

• If there are at least –items in , there cannot be a –item as .

Now, we can find upper bounds on the price in all cases.

• If the number of –items is at most , the price is at most .

• If the number of –items is at least and at most , the price is at most , as .

• If the number of –items is at least and at most , the price is at most , as .

• If the number of –items is at least and at most , the price is at most .

• If the number of –items is at least and at most , the price is at most , as .

• If the number of –items is at least , the price is at most .

This concludes the proof.

### Using the prices of bin types to establish the lower bound on the asymptotic competitive ratio.

Let denote the number of bins opened for –items (bins used for the first time when the batch of –items is presented). Let denote the number of bins opened for –items. Let denote the number of bins opened for –items, for , where . Moreover, as large –items are exactly those –items that are packed as first items of their bins, we have .

Let denote the cost of the algorithm for the input up to the batch of –items, and let denote the cost of the algorithm up to the batch of –items. Let denote the cost of the algorithm up to the batch of –items for .

Let be the asymptotic competitive ratio of ALG, and let be a function such that and for any input it holds that .

We have for . We also have for .

Let denote the total weight of all items (for all branches, such that every possible item is counted exactly once). Since , we have

 W = N⋅(16⋅7t−2+t−1∑j=217j−1)+w⋅nL+(N−nL)+N3+2N+n31+n32 = N6+(w−1)nL+10N3+7N−7nL6+7N−5nL6 = w⋅nL−3⋅nL+35N6 .
###### Lemma 7

We have .

Proof. The weight of every item is included in the price of exactly one bin used by the algorithm. Thus, the total weight is equal to the total price of bins. Given the supremum prices, we get an upper bound on the total price. This proves the inequality, the equality holds by substituting the values of and .

Let , and .

###### Lemma 8

For any value of () and for any value of (), we have , and therefore .

Proof. As the optimal costs are not smaller than , and can be chosen to be sufficiently large, we will neglect the additive term of , and assume that for every input for which , we have .

We will write the constraints for all possible inputs (with all stopping points and continuations), and we will take a linear combination of them using positive multipliers. For an input , we will exhibit a formula for and an upper bound for . The inequality for this input is that the formula for is at most times the upper bound for . This inequality is the one we multiply by the corresponding multiplier.

For we have and . The multiplier for is , and the multiplier for is . For , we have . For , we have