We study the vector packing problem (VP) [20, 19, 2, 1, 3]. In VP with dimension , a set of items is given, where every item is a non-zero -dimensional vector whose components are rational numbers in . This set is to be split into subsets called bins, such that the vector sum of every subset does not exceed in any component. This constraint is called the capacity constraint. Cardinality Constrained Bin Packing (CCBP) [4, 7] is a special case of VP with dimension , defined as follows. Seeing CCBP as a one-dimensional packing problem, there is an integer parameter such that in addition to the capacity constraint, no bin can have more than items. In an equivalent input for VP with , the second component of every item is , while the first component is in (the other components are zeroes).
In this paper we consider lower bounds on the worst-case performance guarantees of online algorithms for VP. Online algorithms receive input items one by one, and pack each new item irrevocably before the next item is presented, into an empty (new) bin or non-empty bin. Such algorithms receive an input as a sequence, while offline algorithms receive an input as a set. An arbitrary optimal offline algorithm, which uses the minimum number of bins for packing the items of the input or instance, is denoted by . For an input and algorithm , we let denote the number of bins that uses to pack also called the cost of algorithm on input . We also let denote the number of bins that uses for a given input . The absolute competitive ratio of an algorithm is defined as the supremum ratio over the following ratios. These are the ratios for all inputs , where the ratio for is between the number of its bins and the number of the bins of , . The asymptotic competitive ratio is the limit of absolute competitive ratios when tends to infinity, and takes into account only inputs for which uses at least bins. That is, the asymptotic competitive ratio of is
In this paper we mostly deal with the asymptotic competitive ratio, which is the most natural measure for bin packing algorithms, and we sometimes refer to it by the term competitive ratio. When we discuss the absolute competitive ratio, we use this last term explicitly.
Note that VP is defined as a distinct optimization problem for every fixed value of . For each such value (which is a dimension), there might be an online algorithm that is the best possible with respect to the absolute competitive ratio (the one whose absolute competitive ratio is minimized), and there might be an online algorithm that is the best possible with respect to the asymptotic competitive ratio. Such algorithms may be different.
Denote by the best possible absolute competitive ratio of an online algorithm for VP with dimension , and let denote the best possible asymptotic competitive ratio of an online algorithm for VP with dimension . If there are values of for which such best possible online algorithms do not exist, we define the corresponding values of and as the infimums of the corresponding ratios where the infimum is taken over all online algorithms for VP with dimensions. Thus these values are well-defined for all even though we currently do not know their values. It is known that these values are at most linear in (see below).
Observe that both and are monotone non-decreasing functions of as we can use the online algorithm with larger dimension in order to pack the lower dimension vectors by simulating a higher dimension input using additional components which are always set to . Furthermore, by the definitions of the asymptotic competitive ratio and the absolute competitive ratio, we conclude that for every , we have .
In this work, we improve the known lower bounds on the asymptotic competitive ratio for all fixed values of that are at least , for the online VP scenario. This improves the known results for the absolute ratios as well. That is, we improve upon the state of the art of lower bounding for all . Our main result is that the order of growth of the asymptotic competitive ratio is . Recall that the term asymptotic here is not the asymptotic growth of , but the asymptotic definition of the asymptotic competitive ratio, which is the most common measure for bin packing problems. To do that, we present four constructions leading to different lower bounds on . For every specific value of , one may use the construction that lead to the largest possible lower bound. In Section 3, we present our results for very large values of . That is, in that section, we show that for , there is a lower bound of on , and for sufficiently large and fixed values of , the lower bound proved for the asymptotic competitive ratio for online VP is . The statement regarding values of that are sufficiently large is explained in that section as well. In Section 4 we show a lower bound of that applies for all fixed values of , and the same type of construction yields better results for relatively small values of . For example, in the case we get a lower bound of on the asymptotic competitive ratio. Then, in Section 5 we show a lower bound of on . Finally, in Section 6, we show a lower bound of on .
The last three constructions, of Sections 4, 5, and 6, are based on using a technique called adaptive constructions for packing problems that we will explain in detail below. We note that our lower bound of is the largest lower bound that we prove for a big variety of values of . This holds even for extremely large values of like , for which the value of this lower bound is at least . Comparing this result to the values of lower bounds of Section 3, we find that they are much smaller, and in fact the values resulting from the constructions of that section are not larger than and , respectively. Thus, for every reasonable value of , the lower bounds that we obtain based on the adaptive construction method are much better than the ones of Section 3.
The lower bounds on established in Azar et al.  were not computed explicitly in the sense that they are only stated as for every . These lower bounds hold only in the absolute sense, and their order of growth is . In order to compare their bounds to our lower bounds on , we examined their proofs. Their lower bounds are basically the deterministic lower bounds on node coloring of graphs where the nodes arrive in an online fashion, thus they are using black-box reductions from the (deterministic) lower bounds of Halldórsson and Szegedy . These black-box reductions are the main reason that they are not able to find lower bounds the asymptotic competitive ratio and only the absolute competitive ratio which may be larger (and it is not the standard tool to analyze bin packing problems). Note that we improve the known absolute lower bound for a large number of values of . For example, the deterministic lower bound resulting from the construction of  for is while our results imply a lower bound above (which holds even in asymptotic case and for a slightly lower dimension of ).
In the work of , the part of randomized lower bounds consists of two constructions. In the first one, the value of is relatively large so we can use Stirling’s formula to approximate with a constant multiplicative error, while the second one holds for all dimensions . In Section 3, we use the ideas of Halldórsson and Szegedy  to get similar lower bounds on the asymptotic competitive ratio of VP. Unlike the work of , we do not apply black-box reduction from node coloring. The main motivation for that is that we need a lower bound with respect to a different coloring problem in which we are interested in fractional coloring. Since this variant was not studied before, we cannot use an existing result for that, and we cannot use a black-box reduction from it. Instead, we present the lower bound construction for VP. The transition to this fractional coloring is the main tool that we use in order to lift the construction of  so that it will allow us to prove a lower bound on the asymptotic competitive ratio for VP.
Next, we consider the literature of bounds of . In  it is shown that when grows to infinity there is a lower bound that tends to , thus . Observe that with respect to this bound we replace by . The interesting part is that this lower bound of  applies even if all components of all vectors are small. That is, for every small such that all components are smaller than , the lower bound of  holds, and it holds even when tends to . This matches the upper bound of for this very specific case of VP (of small components) established by . In , the authors consider the case of and show its difference from CCBP. With respect to VP in two dimensions they showed that , and thus for all it was known that . Prior to the pair of papers [3, 7], the lower bounds on were weaker [19, 13, 12]. As for upper bounds on , the best known result  is (still) that the First-Fit algorithm has an asymptotic competitive ratio of for VP in dimensions. Prior to that work, there was a slightly weaker bound of by Kou and Markowsky . For the absolute competitive ratio, the resulting bound is also [20, 25] (an upper bound of follows from the simple property that for greedy algorithms, no two bins of the output have a sum of at most in all components).
We stress the interesting fact that prior to our work it was unknown whether there is an online algorithm for VP for any dimension (or for sufficiently large dimensions) such that for every input , its cost satisfies (where is the dimension of the input). The reason for this is that the known lower bound of holds in fact for any additive term, while the non-constant known lower bound uses just items for dimension .
We discuss the relation of VP to other bin packing problems. Online CCBP, which is a special case of VP in two dimensions as explained above, is now fully understood. There are matching bounds of on the asymptotic competitive ratio as well as the absolute competitive ratio (see [4, 11, 7]). As mentioned above, it was already established in the past  that VP in two dimensions is strictly harder than CCBP since it is shown that . The special case of of VP is simply BP and it was studied for half a century [22, 23]. The current best bounds on (for the online version) are a lower bound of  and an upper bound of , while .
There is also vast literature on the offline versions of all the problems mentioned above [15, 9, 10, 14, 17, 18, 24]. In particular, similar lower bounds to those of  on the absolute approximation ratio for VP (under a certain standard complexity assumption, that NPZPP) were observed for the offline scenario [15, 10], also by reductions from coloring problems. The lower bounds are for the absolute measures since for every dimension , the number of items is simply .
The other bin packing problems discussed here (BP and CCBP) admit polynomial time asymptotic approximation schemes [14, 17, 18, 24], but one can show that unless P=NP, there cannot be such schemes for the absolute cases, and the absolute approximation ratio is at least . This can serve as evidence that lower bounds for the absolute approximation ratio or the absolute competitive ratio are not sufficient for the analysis of the asymptotic approximation ratio or the asymptotic competitive ratio. In fact, it holds also for online bin packing problems that the absolute measure is different from the asymptotic one. For example, for BP, we already mentioned that the best possible absolute competitive ratio is , while the asymptotic competitive ratio is much smaller . For CCBP, one example is the parameter , for which the best possible absolute competitive ratio is [4, 7] while an improved asymptotic competitive ratio below is known .
2 Preliminaries: adaptive constructions
In some of the constructions, we define inputs using a method presented in the past . In that method, a binary condition on the assignment of every item is defined, and it is used by the adversary (who presents the input) in the definition of the properties of the following item. More precisely, the algorithm keeps an active interval of (scalar) values (contained in ), and it modifies the interval after the assignment of every input item by the algorithm. These values are not necessarily the actual sizes of input items even in the one-dimensional case, though item sizes are based on them in a simple pre-specified way. This means that the generated value is not necessarily the size of the new input item, nor will it always be equal to a component of its vector, but this generated value is used in the definition of the new item, for example, it may be subtracted from some fixed value or added to a fixed size.
The number of required items is decided in advance, or (in some cases) an upper bound on the number of required items is given in advance in cases where the exact number of required items is revealed later on. This number of required items is used to decide upon the initial interval of the values too. The initial interval is also based on the required sizes and properties of the values. The initial interval is always defined such that the smallest size is strictly positive and the largest size is sufficiently small.
Input items are presented one by one. After the assignment of an item by the algorithm, the validity of the condition is tested for this item. During the process of input construction, it is ensured (via a process resembling binary search or geometric binary search) that values corresponding to items satisfying the binary condition are larger by a pre-specified (constant) multiplicative factor than the value of any item not satisfying the binary condition. In this way the process determines two regions as explained in what follows. We will call the resulting ranges of values large and small, respectively, where the two ranges are disjoint. Items with large values, i.e., from the large range, are called large, and items with small values, i.e., from the small range, are called small. Note that this definition of large and small does not indicate that the size of a large item is larger than the size of a small item (since sizes maybe be based for example on subtraction of the values).
Note that when an item is presented, its size is defined without any knowledge of the assignment, so it is still unknown at that moment if the binary condition holds for this item. Thus, its value is defined without the knowledge regarding whether it is small or large. This knowledge is gained based on the action of the algorithm once the item is packed. Based on the packing, if its value is required to be large, future values will be much smaller, and if its value is required to be small, future values will be much larger.
The construction allows us to define positive values smaller than a given value , such that for a pre-defined (constant) multiplicative factor , any large value is more than times larger than any small value. Thus, there is a value such that every small value is smaller than and every large value is larger than . If items are one dimensional and their sizes are simply these values, this means for example that an item of size can be packed with small items, but cannot be packed with one large item into the same bin. Note that in this case large items are also quite small, though not as small as small items. It is possible to define items differently in one dimension, and not only in the way that their sizes are equal to the values. One option is to use the values as complements of sizes (to ). Another option is to use an additive term, for example, items can have sizes of plus the defined value. In this case, one can define a value of such that , for example. For items that are vectors, one can define a part of the components to be defined based on the corresponding value. For example, it is possible in the case that two components will be equal to the value while three other components are equal to zero.
3 The lower bound for large values of
In this section we consider the cases where the dimension is very large. Our lower bounds are in fact not smaller than the weaker results of Azar et al.  which were proved only for the absolute competitive ratio measure (as a function of the dimension for large enough values of ), while here we consider the stronger measure of asymptotic competitive ratio.
In order to consider the asymptotic competitive measure, we have an integer parameter , and both the upper bound on the cost of an optimal offline solution as well as the lower bound on the cost of the online solution constructed by an algorithm are linear functions of . Then, by letting grow to infinity, the lower bound on the asymptotic competitive ratio follows.
We have exactly phases in total, where the th phase consists of identical items whose size vector has as their th component, all components of indexes larger than are while the components of indexes smaller than are either or where . The number of items will be , so components of values no larger than (zero or ) will not prevent the packing of items into the same bin. The idea of such components was presented in .
Note that by definition, two items of the same phase cannot fit into a common bin, and furthermore, a collection of items fit into a bin if and only if no item in the collection has an component if another item of the collection has in the same component. To complete the description of the input sequence, we still need to describe the specific rules for defining components of indexes smaller than (if they are or ). Furthermore, a construction of this form satisfies that any solution has cost of at least and of at most regardless of its specific details.
The definition of the item sizes depends on a fixed offline solution that is maintained after each phase. Our offline solution is not necessarily optimal, though we use its cost as an upper bound on the optimal cost. The offline solution has an integer parameter (which will be chosen later as a function of ), and maintains classes of bins each of which has bins that we refer to as the bins of the class. One can think of the numbers as colors, though there are multiple instances of bins for every color.
We say that the offline solution packs the items of the th phase into class and mean that the th item of the phase is packed into the th bin of the class (for all ). Using this rule means that in order to guarantee feasibility of this packing we can consider only the first bin of each class (simply because the items of each phase are the same and the packing of each bin of the class is equivalent up to indexes of equal sized items).
For every phase , there is a unique class of our offline solution such that the items of phase are packed into bins of class . Thus, the assignment of phases to classes is a surjective function. In this case, we will say that class is the class of phase . On the other hand, every class can be the class of several phases, and for a class , we will say that these phases are the phases of class . Note that the phases of a certain class are defined gradually, they are an empty set initially, and for every new phase whose class is defined to be , the set of phases of is extended by .
Next, consider a bin of the online algorithm (at some point during the lower bound construction). We associate with every such bin the subset of classes (of the offline solution) that contain items that are packed into . Thus, it will always be the case that . Note that the definition is with respect to classes of the offline solution, where a class may be relevant for one phase or multiple phases. The set may be extended later, and it is called the associated set of . Here, we are interested in the existence of at least one item of the class in this bin (an item of a phase that belongs to this class), and we do not distinguish between the cases of one such item or more than that. That is, when , this means that there exists at least one phase such that is the class of phase in our offline solution, and an item of phase is packed into . Note that it is possible that for two bins such that , the values of (where is the class of phase ) are distinct.
Let be the set of classes of the offline solution, and let be its power set (i.e., the set of all its subsets), and let . The goal is to capture the bin types of the online algorithm with respect to classes of the offline solution. We will need the next assumption, which will hold for two choices of pairs of and used in the proof.
There exists a set of subsets such that and for every pair such that we have that their symmetric difference satisfies .
Next, we provide specific pairs of and that satisfy the assumption.
Proof. For the first part, consider being the set , then it has elements as required, and each pair of distinct elements represents non-equal subsets of so they differ by at least one element. We fix the value of to 1 in this case.
The second part was proven by  who showed that if we pick a random sub-collection of subsets of with subsets each of which consisting of exactly elements of
(chosen independently at random), then with some positive probability (for large enough value of) each pair of these selected subsets satisfies the condition on their symmetric difference. Using the probabilistic method, they were able to prove our claim (deterministically) for large enough values of (that they have not specified).
Let be a pair of positive parameters. Let be fixed. Next, we define a subset in that represents a bin of the algorithm. We say that represents bin of the algorithm (and that is represented by ) if .
Every bin of the algorithm is represented by at most one set .
Proof. Assume by contradiction that a bin is represented by two sets .
Recall that (by Assumption 1), but for (by the definition of representation). First, consider the elements of . Some of those elements belong to while other do not. Observe that so . Since , we conclude that . Therefore, . Similarly (by changing the roles of and ) we conlcude that . Thus, contradicting our assumption on .
Note that if , then every non-empty bin is simply represented by , but if , then there might be bins that are not represented at all by a set of , while by Lemma 3, if is represented by a set in it is not represented by other members of .
For a set , we denote by the number of bins (of the online algorithm) that it represents. This value is initialized as and remains non-negative in all times. Next, we define the vectors of a phase whose index is .
Assume that after the previous phase, we have computed the values for all . If after phase (this cannot happen for ), we stop the construction. Since every bin of the algorithm is represented by at most one set, we conclude that the algorithm has at least bins while the offline solution has at most bins, and we get a lower bound of . Otherwise, we pick a set such that at the moment is below . In the second case, the existence of can be guaranteed by the pigeonhole principle. The items for this phase are defined carefully in what follows. The set is a subset of classes that is not represented sufficiently in the packing of the algorithm.
The items of phase (where ) have a component of in all indexes such that the class of phase is in . In the th component these items have , while all other components (of these items) are zero (this includes all components larger than and components smaller than such that the classes of their phases are in ). By definition, the first phase consists of items that are unit vectors whose first component is equal to , and every phase has exactly items.
The online algorithm may pack items of phase only in bins such that before the item is added it holds that , which we show next. This includes packing an item into a new bin, for which the current value of before the item is packed is the empty set. Let be a class such that . If class is currently empty, then every bin does not contain an item of an empty class, so , as required. Otherwise, for any bin such that there is an item with a component of for some phase whose class is , while every item of phase has a th component of for every such . In this case there is at least one such value of .
Since there are identical items (in this phase and any other phase), and the number of bins represented by is at most , we conclude that at least of these items are packed by the online algorithm into bins that were not represented by .
If less than phases were completed, we already saw that the number of bins of the algorithm is at least . This may happen after phase as well, but in that case we will not use this bound, since we analyze phases generally in a different way. In order to show the bound after phases, we use a potential function. Our potential function used for assisting us in finding a lower bound on the number of bins of the algorithm is as follows. It is the sum of over all bins of the algorithm. That is, . Observe that the cost of the online algorithm is at most and not smaller than , since for any it holds that .
Let , which allows us to treat the two cases of uniformly. Consider a bin that was used to pack an item of phase by the online algorithm, and was not represented by (prior to this phase). In this case has at least elements which are not in . This holds since by definition of a set that represents a bin, since the cardinality of the symmetric difference between the sets is at least , and since as was shown earlier.
Recall that there are at least items of phase packed by the algorithm into bins not represented by , all of which packed into distinct bins. Every such bin has at least elements of . Since , which holds for all subsets of classes, using the pigeonhole principle, we find that among the elements of there is at least one element that does not belong to the associated sets of at least bins which were used by the online algorithm for packing the items of the th phase. We pick one such element (where is a class), and pack the items of phase in the offline solution in class . This is a feasible offline packing, as the bins of class still have zeroes in component , and the items of phase have zeroes in all components such that the items of phase are packed into bins of class (since ). Now, we can repeat and define the items of phase in the same way (if ).
Furthermore, since was not a member of the sets for at least bins that the algorithm used for packing the items of phase , we conclude that the value of increases by at least while packing the th phase items. Thus, after phases the value of is at least unless the construction was stopped earlier with the cost of the online algorithm being . The cost of the algorithm in the first case is at least .
Recall that the cost of the offline solution is at most . It remains to conclude the lower bound, where the lower bound is not smaller if we can increase the value of and it is maximized if . Thus, we need a method for selecting if the dimension is given.
We will use a value for which the corresponding pair satisfies (where is determined by ), and then the resulting lower bound would be .
First consider the case where is relatively small and we use and thus , and is an integer such that . It is sufficient to require that that is satisfied by letting as for this choice . The resulting lower bound is not smaller than
where the last inequality holds for as for these values of we have that .
Next, consider the case where the dimension is higher and we could use and thus . We pick as the largest integer such that that is, . Letting we will require . This condition is satisfied e.g. for as for this choice of we have
and is integer and thus also is integer. The resulting lower bound is
that holds for large enough values of .
Thus, we conclude the construction of this section by the following theorem.
For every fixed dimension , there is a lower bound of
on the asymptotic competitive ratio of online algorithms for VP. For sufficiently large and fixed values of the lower bound on the asymptotic competitive ratio is
4 A lower bound for medium sized dimensions
Let , be the two positive integers such that . Next we show a lower bound of for the corresponding special case. Note that choosing the values results in a lower bound of so for very large dimension this result is inferior to the general lower bound we considered earlier. However, the hidden constants in the notation are smaller for the current construction leading to better lower bounds for medium sized dimensions.
Let be a large integer such that is an integer. Our sequence of items may have up to items, and we let . We will use the adaptive construction method to generate a sequence of scalar values where is the value associated with the th item, such that all values are smaller than , and furthermore the following condition holds. If an item is large, then its value is at least times larger than the value of a small item. The logical condition that we will use to define small and large items is that a -dimensional item is large if it is packed into an empty bin and otherwise it is small. We stress the property that every item of the construction will have a one-dimensional associated value, and we will explain how this value is used in the definition of the -dimensional item.
During the adaptive construction, after packing the current item, there will be a value . The value of may decrease (but cannot increase) after assigning an item. The value will satisfy the property that the value of every large item that appeared up to (and including) the current iteration is strictly larger than while for any subset of items where contains only small items that appear in the instance (both during the prefix and later on) or large items that appear later on in the input sequence, the total value of is strictly smaller than . This is obtained by letting be the current upper bound on values of items that can still be either small or large at termination, and reducing the length of the interval of possible values in the adaptive construction by a multiplicative factor of after each item. This is done to ensure that all such subsets , whose number of elements will be less than (as this will be a valid upper bound on the number of items in the entire construction), will satisfy the requirement.
Our construction will have phases, and it will be useful to denote by the current value of at the end of phase (i.e., after packing the last item of phase and modifying the current interval according to the rules of the adaptive construction). Furthermore, phase uses the value .
The first and last phase have special properties while the intermediate phases ( phases) are all similar. Each phase lasts until the first point in time in which the algorithm has opened new bins during this phase. Thus, we will ensure that the total cost of the algorithm is . We also maintain an integer value denoting the current component that is being dealt with, and it has a special role in the construction. We will show later that will always be an index of a component (i.e., ), even though it is increased frequently. The value is an index of a component such that items have a very big (and close to ) component of this index. By increasing , we change (and increase) the position of this very big component in the construction. This value is initially set as (while the very first component has a special role during the first phase), and it increases gradually, each time by , and it never decreases, as items are being presented. We will see that the value of never exceeds , and during the presentation of items of intermediate phases it will hold that .
The first phase.
We construct a sequence of items, where the first component of every vector is while every other component equals to the value of the current item. Note that this phase ends after at most items, since any phase ends after the algorithm used new bins, every new bin can contain at most items, and there are no bins of previous phases which can be used.
The intermediate phases.
Every such phase will contain at most items. We keep a counter of the index of the phase, where is initialized to . At the end of phase we set as we described above and we start presenting new items of the th phase.
Each item of these intermediate phases will consist of the following components. All components with indexes smaller than are equal to , the current component with index is set to , and all other components (of larger indexes) are equal to the value of the current item (of the adaptive construction). Recall that a new phase starts whenever the number of new bins during the current phase is , and just before starting a new phase we also increase by (for is not increased but it is initialized). However, there are other events where we decide to increase the value of by . These additional events are stated as follows. Whenever the number of large items (according to the adaptive construction) that were packed while the value of is its current value, is , we increase the value of by . This is done since the number of large items whose th component is very big is the maximum possible number. We will show that an increase in the value of will happen after at most consecutive items for which we used the same value of . This happens either due to the latter rule or due to the end of the phase (since is always increased due to that event). Before presenting the vectors of the last phase, we prove the main correctness claims regarding the intermediate phases that allow our construction to have the required structure and allow us to prove the claimed lower bound on the asymptotic competitive ratio.
The items of phase (where ) cannot be packed into bins that were opened in an earlier phase, that is, bins used first for an item of an earlier phase. Additionally, the value of remains constant without being increased for at most items.
Proof. Each bin that was opened by the algorithm in the first phases has a large item (since by the adaptive construction, every first item of any bin of the algorithm for these phases is large). Every large item has at least one component that is larger than , where those components form a suffix starting with component that is the value of (at the time of packing the item) plus . Since is increased by when a new phase starts, the component indexes corresponding to the current (larger) value of is larger than . Since for the items of phase there is a component equal to for the current value of , for which bins constructed in previous phases have a sum larger than , they cannot be packed into bins of the algorithm containing items of earlier phases. This concludes the first part.
Regarding the second claim, it is only required to consider the items of one phase, since is increased after every phase ends. Assume by contradiction there are items that have a common value of the current component. By the first part, these items are packed into new bins opened during the phase. Since items having the same value of have a th component larger than , they are packed into different bins. Thus, the phase would end before the th item is presented (or it may end earlier or may be increased earlier), a contradiction.
During an intermediate phase, the value of is increased at most times by (including the increase due to the end of the phase).
Proof. There are exactly large items in a phase, since every phase has new bins, and by the construction, the large items are exactly the first items of new bins. Thus by definition the events in which we increase may happen at most times during a phase (and in the last such event, the phase ends as well).
We consider the value of at the beginning of the last phase. By the last lemma, we conclude that just before the moment when phase ends (the last intermediate phase), we have and is increased to a value of at most once that phase ends. This final value (of at most ) for was not used as the value of in the definition of items of any phase (after the very last time that was increased, no items are defined so it was not used to define an item).
The last phase.
In the last phase we present exactly identical items that are defined as follows. In component they are equal to and all other components are . Observe that every bin that the algorithm has opened in one of the earlier phases has one large item whose th component is larger than , and thus the algorithm needs to open new bins for these items of the last phase.
Proving the resulting lower bound.
Since there are phases and the algorithm is forced to open new bins in every phase, we conclude that the cost of the algorithm is exactly . Since could be an arbitrary large integer, in order to prove the lower bound on the asymptotic competitive ratio of the algorithm, it suffices to show that the optimal offline cost is at most . In order to present this proof, we will consider all items of the last phase as small items. We present an offline solution of cost at most . This offline solution will pack all large items into bins, and all small items into a disjoint set of bins, and in total we will use at most bins. First, we consider the large items.
There is an offline solution that packs all large items into at most bins.
Proof. Note that there are phases containing large items (as in the last phase all items are small). Therefore, it suffices to show that it is possible to pack all large items of a common phase into bins and to pack all large items of the first phase into one bin.
Consider the first phase. There are large items, and one can pack all such items into a single bin because in the first phase every component of the items of the phase is at most .
Next, consider the set of large items of phase for . We pack these large items into bins, as follows. We traverse the sublist of these large items sorted by their arrival order (i.e., by the same order they had in the original input) and we pack them one by one into these bins using a round-robin approach. That is, the large item of index for an integer and for will be packed into the bin of index . Here the index of the item is its position along the sublist of large items of phase , and the index of the bin is among the dedicated bins for large items of this phase. Alternatively, this packing can be seen as bins, where every bin has one large item for every value of used in the suitable phase. To see that this is a feasible packing note that in every component and every bin there is at most one item packed into the bin that has this component equals to and all other items packed there have this component equal to their values. Since the total associated value of this set of items is smaller than as they are all items of iterations after the iteration in which we define , these items do not exceed the bound of in every component (on their sum).
Next, we consider packing of the small items into bins.
There is an offline solution that packs all small items into bins.
Proof. We consider the sublist of (only) the small items sorted by their arrival order in the original instance. Once again we use the round-robin approach and we pack these items into bins using round-robin. That is, the th small item (i.e., counting only small items) is packed into the bin of index . It suffices to show that the resulting packing is feasible.
Consider one component in one bin of this packing and we will show that the sum of the component over all items packed into this bin is at most . For the first component, the claim holds as only the items of the first phase have nonzero first component, and since there are less than such (small) items, by averaging, we pack at most first-phase small items into this bin, so their total first component is at most . Next, consider the th component where . In this component, the bin has at most one vector with th component larger than (since there are at most such vectors in the instance and they appear consecutively along the input sequence, so they are assign to distinct bins by the round-robin approach). The other vectors packed into the bin are such that their th component is their associated value or zero, and these are small items, so they all fit into this component (no matter what is the phase in which the item with th component larger than was presented).
Thus, we conclude the following result.
If , then there is no online algorithm for VP whose asymptotic competitive ratio is smaller than .
For large values of , we can use for which and this lower bound on the asymptotic competitive ratio is . However, for small dimensions we could do better. For example for , we could pick and the lower bound on the asymptotic competitive ratio is whereas using the lower bound is .
For small dimensions, namely and
, the next estimation can be used. Lettingand , the lower bound is greater or equal to . It gives a lower bound of , , , , and for the cases of , respectively. We mention several other small values of . For , we can use and to obtain a lower bound of . For , we can use and to obtain a lower bound of . For , we can use and to obtain a lower bound of . Improved bounds for the cases are presented in the next sections.
5 The case
Recall that the known lower bound on the asymptotic competitive ratio for is just slightly above , and this was the best known constant lower bound for any small value of till now. We prove here a lower bound of for the case , and explain how it can be slightly improved.
We will use an adaptive construction as explained earlier. The construction is based on that of .
Let be a large integer, and let be a small constant (in particular, ). The input consists of three parts and we describe the parts one by one.
The first part of the input.
Using an adaptive construction of values, we define a sequence of values in such that any large value is strictly larger by a multiplicative factor larger than from any small value. The binary condition is that the item is packed into an empty bin by the online algorithm.
Thus, an item packed into an empty bin is large, and otherwise the item is small. The number of items will be for a large integer . Letting be the sequence of values, the vector for item is defined as follows. The first component is , and each one of the two other components is equal to . Let be a threshold such that if the th constructed value is small, it holds that and otherwise . The input up to this point is denoted by .
The optimal cost for packing is .
Proof. Since all first components of all items are equal to while the other components are smaller, an optimal solution can pack all items into bins and it cannot pack the items into a smaller number of bins.
Let denote the number of bins used by the algorithm for the first part of the input and by definition this is also the number of large items. Let . Thus, every small values have total value below .
The second part of the input.
For the value of that is based on the action of the algorithm, we define the next part of the input. There are items of each one of the two types: and . So, in total there are items of these types. The input at this time is called , i.e. is the input consisting of the first two parts of the input together.
Two offline packings of .
We define two offline packings, for which the first part of the input is packed in a fixed manner. For each possibility of the third part of the input, we will use one of those offline packings that we present here. Consider the first part of the input (the items of ), and separate small items from large items. Large items are packed such that every bin has of them (where one such bin may have a smaller number of these items). The large items require bins. These are feasible bins because none of the components of the sum of any bin is above , since no component of any item is above . Small items are also packed in each bin, and there are at most such bins since the total number of items for the first part is . The total number of small items is . The first component of the bin has load , but the other components have loads below . Every such bin can also receive one item of each type of the second part. In one packing, we partition the items of the second part into pairs where every pair consists of items of different types. In this offline packing each pair is packed together, these pairs are first packed into bins with small items of the first part, and if there are any unpacked items of the second part, they are packed into new bins (also in pairs). In the second packing, every bin gets just one such item of the second part. For both offline packings, the numbers of bins do not exceed .
The third part of the input.
The third part of the input may contain two alternative sets of items. In the first case, leading to the input , there are items of the type . Every such item is packed into a different bin by any algorithm. In the offline packing, these items are packed first into bins with (at most) small items of the first part (but without large items of the first part and without any items of the second part) and then into new bins. The online algorithm cannot combine such items with any item into the same bin, as we will see.
In the second case, leading to the input , there are items of each of the types: , . No pair of such items can be packed into one bin, but it can join a bin with (at most) small items of the first part and one item of the second part (of the suitable type) but without large items of the first part. It also cannot be packed with an item of the other type of the third part.
This concludes the description of the input construction. Next, we turn our attention to proving the resulting lower bound on the asymptotic competitive ratio for the case .
Proving the resulting lower bound.
Here, we prove the following result.
There is no online algorithm for the case whose asymptotic competitive ratio is smaller than .
Proof. We can assume that , since the case where there is an infinite number of values of for which implies that the asymptotic competitive ratio of the algorithm is at least . Recall that (by Lemma 10). Thus, the number of bins for the offline packing of and the offline packing of do not exceed . By the offline packing of and the packing of the third part. By requiring , the number of bins is at most .
As for the algorithm, all bins created by the algorithm for the first part of the input have large items, whose values are above . Thus, new bins are created for the second part and third part. Any bin can contain at most two items of the second part, and at most one item of the third part.
Let and be the numbers of bins with one and two items, respectively, opened by the algorithm for the second part (when we count the number of items of such bins at the end of the second part). By the numbers of items in the relevant part of the input we have
We recall that the online algorithm cannot pack any items into bins opened during the first phase, because these bins contain a large item of the first phase which has a second and third component at least while packing a second part item it requires at most loading in these coordinates.
For , every item of the third part requires a new bin, so the cost of the algorithm is . For , it is possible to use bins of the second part only if they have a single second part item, so the cost of the algorithm is at least .
Since this construction can be used for an infinite number of values of , we can use the definition of the asymptotic competitive ratio as the of the absolute competitive ratio when the optimal cost is at least , and let grow to infinity. Thus, letting be the competitive ratio, we have
Taking the sum of these inequalities gives and by and ,we have , which implies a lower bound of on the asymptotic competitive ratio.
A very slight improvement over the lower bound which we proved above in Theorem 11 can be obtained as follows, similarly to the known construction for . An alternative second part of the input will contain items whose first component is not zero but some multiple of . The second component will be slightly larger than , where there will be large items and small items (small items are those that are packed by the algorithm into a bin that cannot receive another item), and all these items have second components larger than . There may be a third part of the input (in this alternative input), similarly to the construction of . We omit the details as the idea is similar and the improvement is very small. We note that this value of is a valid lower bound for the cases as well. For the case we could get the same lower bound by another method in Section 4 as well, where we proved significantly larger values for larger dimensions.
6 The case
We consider this special case as well, in order to demonstrate that the asymptotic competitive ratio grows relatively fast with the dimension. We picked the value of as for this dimension we are able to exhibit new properties of instances leading to improved lower bounds. Once again the lower bound construction consists of three parts.
The first part of the input.
The first part of the construction is identical to that of the case , including the property that the values of and are the same, with the only change that the components equal to are not just the second and third components, but all components with indexes are equal to . The first component is still , while the th component is equal to zero. The values and are defined as in the first part of the construction for the case .
The second part of the input.
The second part of the input consists of items consisting of groups each of which has vectors, where every vectors of a common group are identical. All these vectors have th components equal to and first components equal to zero. The other components are equal to either or to , where every item has exactly one component equal to , and we will call it the large component of the item. We will have the items of group (for ) having component equal to while all other components (excluding the th component) are zero.
Analyzing the packing of the algorithm at the end of the second part.
Before describing the third part of the input, we introduce some notation and properties of the packing of the algorithm at the end of the second part of the input. The items of the second part are defined so that no bin can have more than three such items by the constraint on the th component, and all (at most three) items of one bin have distinct large components since . We will distinguish the cases where a bin contains three, two, or just one item of the second part of the input, introducing notation for their corresponding bin numbers.
For , where , let be the number of bins with (exactly) three items of the second part of the input, whose large components are , , and . There are such variables. For , where , let be the number of bins with (exactly) two items of the second part of the input, whose large components are and . There are such variables. For , let be the number of bins with (exactly) one item of the second part of the input, whose large component is . There are six such variables. Since every bin opened by the algorithm for the first part of the input has a sum of components of items above in components , all these bins of the algorithm are new.
The number of bins opened by the algorithm for the first part of the input is denoted by and it satisfies
The sum of variables of the form is denoted by , the sum of variables of the form is denoted by , and the sum of variables of the form is denoted by . That is, , , and . By counting the number of items of the second part, we have
The third part of the input.
The third part has one of ten possible sets of items, of similar structures. These items have six non-zero components, which are components . Every item has three components whose values are , and three components whose values are . No two such items can be packed into the same bin since the sum of such a component for two items is either or . For a triple where are fixed component indexes, and , the input consists of items whose components are equal to and the components are equal to , and items whose components are equal to and the components are equal to . This completes the construction of the input. Next, we prove the resulting lower bound.
Proving the resulting lower bound.
Recall the decision variables whose values are determined by the algorithm but they satisfies the conditions and established above. We first upper bound the optimal offline cost after the third part of the input and then present a lower bound on the maximum cost of the algorithm on these inputs that can be constructed in the third part of the input. As in the proof for we can assume .
For each of the ten inputs that can be created at the end of the third part, there is an offline solution whose cost is at most .
Proof. Fix one particular input at the end of the third part, that is, we are given the pair used by the adversary for this fixed input. An offline solution packs the items as follows. There are bins with large items of the first part each, and bins, where each such bin has at most small items of the first part. Out of the last bins, there are bins with three items of the second part whose large components are and one item of the third part for which these components are equal to , and bins with three items of the second part whose large components are in the set , and one item of the third part for which these components are equal to . These bins are feasible because of the item sizes of the input parts. Thus, the optimal cost never exceeds .
The algorithm can combine into a common bin some items of the third part with items of the second part but it cannot use bins that were used for items of the first part for packing items of the second or third parts. We describe only bins without any items of the first part because any bin of the algorithm containing an item of the first part cannot receive any additional items. We discuss such bins with two or three items of the second part (since bins with just one item can always receive additional items). For a set , there may be bins with two items of the second part, where one of the items has a large component in the set and the other one has a large component in the set . In addition, there may be bins with three items of the second part, where the set of large components is none of the sets and (comparing them as sets and not as ordered tuples).
By Lemma 12, for large values of we find for the asymptotic competitive ratio that
We introduce two new variables where is the number of bins of the algorithm with two items of the second part that cannot receive an item of the third part, and is the number of bins of the algorithm with three items of the second part that cannot receive an item of the third part (for the choice of third part, that is, we fix the third part temporarily). Then, by considering this input using the fact that the third part of the input requires packing items into at least bins and we cannot use of the bins which were opened for the first or second parts, we conclude that
We take the sum of the last inequality for all ten options of , , where the right hand side is , and the multiplier of on the left hand side is . Since we consider all options for the third part of the input, the values and can have different values, and more precisely, each one has up to ten different values.
We count the multiplier of each variable as follows. Variables of the form are included in all variables except for the option where are components of equal values, (the algorithm chose exactly the same subset as the one chosen for the third part of the input) which is just one case of the third part. Thus, the multiplier of is . Variables of the form are included in all variables except for cases where and are components of equal values, which is the case if or . Out of the variables, there are nine such options that are included (in the sense that the bins cannot be used for items of the third part of the input) and six that are not included. Thus, every variable is included in six of the ten partitions, and in this sum of constraints every variable has a multiplier of . We get
Using and , we find by subtraction that or alternatively
By subtracting the last inequality from (1), we have . Since and hold, we establish that and therefore as we summarize in the following theorem.
There is no online algorithm for the case whose asymptotic competitive ratio is smaller than .
-  Y. Azar, I. R. Cohen, A. Fiat, and A. Roytman. Packing small vectors. In Proc. of the 27th Annual ACM-SIAM Symposium on Discrete Algorithms, (SODA’16), pages 1511–1525, 2016.
Y. Azar, I. R. Cohen, S. Kamara, and F. B. Shepherd.
Tight bounds for online vector bin packing.
Proc. of the 45th ACM Symposium on Theory of Computing (STOC’13), pages 961–970, 2013.
-  Y. Azar, I. R. Cohen, and A. Roytman. Online lower bounds via duality. In Proc. of the 28th Annual ACM-SIAM Symposium on Discrete Algorithms, (SODA’17), pages 1038–1050, 2017.
-  L. Babel, B. Chen, H. Kellerer, and V. Kotov. Algorithms for on-line bin-packing problems with cardinality constraints. Discrete Applied Mathematics, 143(1-3):238–251, 2004.
-  J. Balogh, J. Békési, Gy. Dósa, L. Epstein, and A. Levin, A new and improved algorithm for online bin packing. The Computing Res. Rep. (CoRR), http://arxiv.org/abs/1707.01728, 2017. Also in Proc. ESA’18, 5:1-5:14.
-  J. Balogh, J. Békési, Gy. Dósa, L. Epstein, and A. Levin. A New Lower Bound for Classic Online Bin Packing. In Proc. of the 17th International Workshop on Approximation and Online Algorithms (WAOA’19), pages 18–28, 2019.
-  J. Balogh, J. Békési, Gy. Dósa, L. Epstein, and A. Levin. Online bin packing with cardinality constraints resolved. Journal of Computer and System Sciences, 112: 34–49, 2020.
-  J. Balogh, J. Békési, Gy. Dósa, J. Sgall, and R. van Stee. The optimal absolute ratio for online bin packing. Journal of Computer and System Sciences, 102: 1–17, 2019.
-  N. Bansal, A. Caprara, and M. Sviridenko. A new approximation method for set covering problems, with applications to multidimensional bin packing. SIAM J. Comput., 39(4):1256–1278, 2009.
-  N. Bansal, M. Eliás, and A. Khan. Improved approximation for vector bin packing. In Proc. of the 27th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA’16), pages 1561–1579, 2016.
-  J. Békési, Gy. Dósa, and L. Epstein. Bounds for online bin packing with cardinality constraints. Information and Computation 249:190–204, 2016.
-  D. Blitz. Lower bounds on the asymptotic worst-case ratios of on-line bin packing algorithms. M.Sc. thesis, University of Rotterdam, number 114682, 1996.
-  D. Blitz, A. van Vliet, and G. J. Woeginger. Lower bounds on the asymptotic worst-case ratio of online bin packing algorithms. Unpublished manuscript, 1996.
-  A. Caprara, H. Kellerer, and U. Pferschy. Approximation schemes for ordered vector packing problems. Nav. Res. Logistics, 50(1):58–69, 2003.
-  C. Chekuri and S. Khanna. On multidimensional packing problems. SIAM Journal on Computing, 33(4):837–851, 2004.
-  L. Epstein. Online bin packing with cardinality constraints. SIAM J. on Discrete Mathematics, 20(4):1015–1030, 2006.
-  L. Epstein and A. Levin. AFPTAS results for common variants of bin packing: A new method for handling the small items. SIAM J. on Optimization, 20(6):3121–3145, 2010.
-  W. Fernandez de la Vega and G. S. Lueker. Bin packing can be solved within in linear time. Combinatorica, 1(4):349–355, 1981.
-  G. Galambos, H. Kellerer, and G. J. Woeginger. A lower bound for online vector packing algorithms. Acta Cybernetica, 10:23–34, 1994.
-  M. R. Garey, R. L. Graham, D. S. Johnson, and A. C.-C. Yao. Resource constrained scheduling as generalized bin packing. Journal of Combinatorial Theory Series A, 21(3):257–298, 1976.
-  M. M. Halldórsson, M. Szegedy. Lower Bounds for On-Line Graph Coloring. Theoretical Computer Science, 130(1): 163–174, 1994.
-  D. S. Johnson. Fast algorithms for bin packing. Journal of Computer and System Sciences, 8:272–314, 1974.
-  D. S. Johnson, A. Demers, J. D. Ullman, M. R. Garey, and R. L. Graham. Worst-case performance bounds for simple one-dimensional packing algorithms. SIAM Journal on Computing, 3(4):299–325, 1974.
-  N. Karmarkar and R. M. Karp. An efficient approximation scheme for the one-dimensional bin-packing problem. In Proc. of the 23rd Annual Symposium on Foundations of Computer Science (FOCS’82), 312–320, 1982.
-  L. T. Kou and G. Markowsky. Multidimensional bin packing algorithms. IBM Journal of Research and Development, 21(5):443–448, 1977.