Online bin packing with cardinality constraints resolved

Cardinality constrained bin packing or bin packing with cardinality constraints is a basic bin packing problem. In the online version with the parameter k \geq 2, items having sizes in (0,1] associated with them are presented one by one to be packed into unit capacity bins, such that the capacities of bins are not exceeded, and no bin receives more than k items. We resolve the online problem in the sense that we prove a lower bound of 2 on the overall asymptotic competitive ratio. This closes this long standing open problem, since an algorithm of an absolute competitive ratio 2 is known. Additionally, we significantly improve the known lower bounds on the asymptotic competitive ratio for every specific value of k. The novelty of our constructions is based on full adaptivity that creates large gaps between item sizes. Thus, our lower bound inputs do not follow the common practice for online bin packing problems of having a known in advance input consisting of batches for which the algorithm needs to be competitive on every prefix of the input.


Introduction
Bin packing with cardinality constraints (CCBP, also called cardinality constrained bin packing) is a well-known variant of bin packing [16,17,15,8,9,10]. In this problem, a parameter k is given. Items of indices 1, 2, . . . , n, where item i has a size s i ∈ (0, 1] are to be split into subsets called bins, such that the total size of items packed into each bin is at most 1, and no bin has more than k items. In the standard bin packing problem, only the first condition is required. CCBP is a special case of vector packing (VP) [13]. In VP with dimension d ≥ 2, a set of items, where every item is a non-zero d-dimensional vector whose components are rational numbers in [0,1], are to be split into subsets (called bins in this case as well) such that the vector sum of every subset does not exceed 1 in any component. Given an input for CCBP, an input for VP is created as follows. For every item, let the first component be s i , the second component is 1 k , and the remaining components are equal to zero (or to 1 k ). In this paper we study online algorithms, which 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. By the definition of CCBP, an item i can be packed into a non-empty bin B if the packing is feasible both with respect to the total size of items already packed into that bin and with respect to the number of packed items, i.e., the bin contains items of total size at most 1 − s i and it contains at most k − 1 items. An optimal offline algorithm, which uses a minimum number of bins for packing the items, is denoted by OP T . For an input L and algorithm A, we let A(L) denote the number of bins that A uses to pack L. We also use OP T (L) to denote the number of bins that OP T uses for a given input L. The absolute competitive ratio of an algorithm A is the supremum ratio over all inputs L between the number of its bins A(L) and the number of the bins of OP T , OP T (L). The asymptotic approximation ratio is the limit of absolute approximation ratios R K when K tends to infinity and R K takes into account only inputs for which OP T uses at least K bins, that is the asymptotic competitive ratio of A is The term competitive ratio is used for online algorithms instead of approximation ratio and it is equivalent. In this paper we mostly deal with the asymptotic competitive ratio, and also refer to it by the term competitive ratio. When we discuss the absolute competitive ratio, we use this last term explicitly.
In this paper, we resolve the long standing open problem of online CCBP, in the sense that we find the best overall asymptotic and absolute competitive ratios. An algorithm with an asymptotic competitive ratios of 2 has been designed by Babel et al. [3], and a similar algorithm was shown to have an absolute competitive ratio of 2 [5]. However, prior to this work, all lower bounds were strictly smaller than the best lower bounds for standard bin packing [21,4]. With the exception of the case k = 2 for which simple algorithms have competitive ratios of 1.5 [16,9], and a more sophisticated algorithm has a competitive ratio of at most 1.44721 [3], all lower bounds on the competitive ratio were implied by partial inputs of inputs used to prove lower bounds for standard bin packing [22,21,4] (such lower bounds can be used for k ≥ 1 δ when all items have sizes no smaller than δ, for a fixed value δ > 0), and modifications of such inputs [3,11,5]. That is, all lower bounds had the form where a number of lists may be presented, each list has a large number of items of a certain size (the sequence of sizes of the different list is increasing, and the numbers of items in the lists are not necessarily equal). The unknown factor is the number of presented lists, that is, the input can stop after any of the lists. See Table 1 for values of previously known lower bounds.
In this work, we take a completely different approach for proving lower bounds, where many of the item sizes are based on the complete and precise action of the algorithm up to the time it is presented. While a similar approach was used for the very limited special case of k = 2 in the past [6,3,11], it was unclear how and if it could be used for k > 2. In a nutshell, in these lower bound sequences for k = 2, sub-inputs were constructed such that items packed in certain ways (for example, as the second item of a bin) had much larger sizes than items of the same sub-input packed in other ways. Here, we generalize the approach for larger values of k by defining careful constructions where sufficiently large multiplicative gaps are created. This requires much more delicate procedures where item sizes are defined.
Additionally, we improve the lower bounds for all values of k, and in particular, prove lower bounds above the best known lower bound on the competitive ratio for standard online bin packing, 1.54037 [4] for k ≥ 3. Already for k = 3 our lower bound is above 1.55, and already for k = 4, our lower bound is above the competitive ratio of many algorithms for standard online bin packing (see for example [19,20]).
Our result provides, in particular, a lower bound of 2 for the asymptotic competitive ratio of vector packing in two dimensions. The previously known lower bounds for vector packing are as follows. The best results for constant dimensions are fairly low, and tending to 2 as the dimension d grows to infinity [12,7,6], while a lower bound of Ω(d 1−ε ) was given by Azar et al. [2] for the case where both d and the optimal cost are functions of a common parameter n that grow to infinity when n grows to infinity, and thus this result does not give any lower bound on the competitive ratio for constant values of d (see also [1] for results on vectors with small components). In particular, the best lower bound for d = 2 prior to this work was 1.67117 [12,7,6]. An upper bound of d + 0.7 on the competitive ratio is known [13].
Note that the offline CCBP problem is NP-hard in the strong sense, and approximation schemes are known for it [8,10]. We note that for online CCBP, it is sometimes the case that the competitive ratio for CCBP is larger by 1 with comparison to that of standard bin packing [16,14,18,9]. Interestingly, this is not the case here.
Paper outline. We discuss general properties in Section 2, and we define procedures for constructing sub-inputs in Section 3. Our main result, an overall lower bound of 2 on the competitive ratio of any online algorithm for CCBP is proved in Section 4, and improved lower bounds for fixed values of k are given in Section 5.

Preliminaries
The analysis of the lower bounds on the asymptotic competitive ratio of online algorithms will be based on the following lemma that basically allows us to disregard a constant number of bins in the costs of the optimal solution and the solution returned by the algorithm.
Lemma 1 Consider an algorithm ALG, such that the asymptotic competitive ratio of the algorithm ALG is at most R, where R ≥ 1 is a fixed value, and let f (n) denote a positive function such that f (n) = o(n) and for any input, ALG(I) ≤ R · OP T (I) + f (OP T (I)). Let C a ≥ 0, C b ≥ 0 be constants. Assume that for a given integer N 0 , for any integer n ≥ N 0 there is an input I n for which OP T (I n ) = Ω(n), then we have Proof. We have In what follows, we will use Lemma 1 as follows. We construct inputs whose size depends on a parameter N , so that the costs of optimal solutions increase with the input size. We will compare the cost of the algorithm plus a suitable non-negative constant to the optimal cost minus a suitable non-negative constant by considering their ratio.

Constructions of sub-inputs
In this section we introduce the core of our lower bound constructions. In such constructions, we adaptively present inputs that are based on the behavior of the algorithm. More specifically, we define several procedures that construct sub-inputs according to certain conditions. Similarly to [3,11,6] (and other work on online problems), a new input item is presented at each time, where its size is based on the action of the algorithm on previous items. For example, if the previous item was packed into an empty bin, the size of the next item is different from the size that would be used if the previous item is added to a non-empty bin. In order to ensure that the properties are satisfied, we will define invariants, and we will prove the specific properties that we need in the sequel via induction.
In the first procedure, the most important property is that there will be a gap between two types of items constructed by applying the procedure, in the sense that the procedure creates items that will be called small and items that will be called large, any large item is larger than any small item, and there is a requirement on the size ratio that will be satisfied (a multiplicative gap between the size of the smallest large item and the largest small item). Such constructions differ from previous work [3,11,6] where only an additive gap was created. The gap was always positive, but it could be arbitrarily small. In particular, one limitation was that it was unknown how such an approach could be used for k > 2.
We will also use this method to construct sub-inputs with large items, such that there is a multiplicative gap in the differences between 1 and the items sizes. This new method will allow us to exploit the major differences in sizes of items of different kinds to provide a tight overall result and new and significantly improved lower bounds on the asymptotic competitive ratio for fixed values of k.

Procedure SMALL
In this first procedure called SMALL, a rational value 0 < ε ≤ 1, and an integer upper bound N on the number of items to be presented are given. The goal is to present (at most) N items of sizes in (0, ε], such that every item will be seen as either a small item or a large item, and such that any large item is more than k times larger than any small item. In fact, a stronger requirement on the item sizes will hold. Moreover, all item sizes will be rational. Given two logical conditions, C 1 and C 2 specified for each construction (such that for every packed item, exactly one of them holds), a new item will be defined as small if C 1 holds and it will be defined as large if C 2 holds. There is a third condition C 3 that is based on the packing of the prefix of items introduced so far, and the sub-input is stopped if C 3 holds.
Let N be the upper bound on the number of items that will be created by the procedure. Let N ′ ≤ N be the number of items (where N is known in advance while N ′ is not necessarily known in advance and it becomes known when C 3 holds for the first time). The item sizes a 1 , a 2 , . . . , a N ′ will be defined based on another sequence The values x i will be integral in order to ensure that the values a i will be rational. There will also be two sequences of values τ 1 , . . . , τ N ′ and ρ 1 , . . . , ρ N ′ , representing thresholds on item sizes of further items.
Let τ 0 = 2 N +2 , ρ 0 = 2 N +3 , and i = 1. The process is defined as follows for any given value of Intuitively, the process is as follows. The interval (τ i , ρ i ) contains the x j values of all further items (with j > i), and for j ≤ i, all items satisfying C 1 have x j values in [ρ i , ρ 0 ) and all items satisfying C 2 have x j values in (τ 0 , τ i ]. In each iteration i, the new values τ i , ρ i are defined such that these requirements are satisfied. In particular, the x i values of any item satisfying C 1 are larger than those of items satisfying C 2 . Next, we establish the invariants of this procedure.
Proof. We start with showing that the x i values as well as ρ i and τ i are integral and ρ i − τ i = 2 N +2−i . We prove this by induction. Indeed ρ 0 = 2 N +3 that is integral, τ 0 = 2 N +2 that is an integer as well. Furthermore, ρ 0 − τ 0 = 2 N +2 , and x 1 = 3 · 2 N +1 that is an integer, and no matter if the first item satisfies C 1 or C 2 , we have that both ρ 1 and τ 1 are integers, and ρ 1 − τ 1 = 2 N +1 . Thus, the cases i = 0 and i = 1 for the induction claim hold. Assume that Then, . In both cases, ρ i − τ i = 2 N +2−i and both τ i and ρ i are integers. Since, in particular, for any i, ρ i > τ i holds and x i+1 is their average, we find τ i < x i+1 < ρ i . Thus, ρ i ≤ ρ i−1 and τ i ≥ τ i−1 holds for any i.
Finally, since in the case that item i satisfies C 1 , we let ρ i = x i , and in the case that item i satisfies C 2 , we let . For any item i 1 satisfying C 1 and any Proof. The first claim holds by definition. Since we have Note that it is possible that the constructed input is such that there are only items satisfying C 1 or only items satisfying C 2 .

Procedure LARGE
The second type of input is such that all items have sizes in (1 − ε, 1) for a given value ε > 0. The construction is the same as before, but the size of the ith item is b i = 1 − a i . The terms "small" and "large" refer to difference between the size of the item and 1.

Corollary 4 All item sizes
The sizes of any small item i s and any large item

Procedure SMALLandLARGE
We will also use a procedure where the conditions C 1 and C 2 are not fixed, and they are based on additional properties of the packing and the input that has been presented so far. Moreover, in this case the size of each item is based on a i , but it is fixed for each item separately (it will be either a i or 1 − a i ). In this construction the sub-input will be decomposed into parts where for an item of an odd indexed part the size of the item will be 1 − a i , whereas for an item of an even indexed part the size of the item will be a i . The definitions of C 1 and C 2 will also depend on the parity of the index of the part containing the item. This procedure is called SMALLandLARGE.

A lower bound of 2
Let N be a large integer. Apply procedure SMALL with ε = 1 for the construction of N items (i.e., condition C 3 never happens). The condition C 2 is that the item is packed as the first item of some bin (into an empty bin), and the condition C 1 is that the item is packed into a non-empty bin. The item sizes are no larger than 1 k 4 . The multiplicative gap between the smallest large item and the largest small item is larger than k. The N items presented so far will be called the first phase items. Let δ > 0 denote the largest size of any first phase item packed not as a first item of a bin (the largest small item). Let α = k · δ. Any first phase item that is packed as the first item of a bin (a large item) has size strictly above α. Let ∆ < 1 k 3 be the largest size of any first phase item. Obviously, 1 − k∆ > 1 − 1 k 2 > 1 2 . For the first phase items, let X k denote the number of bins packed by the algorithm that contain k items, and let Y denote the number of other bins (such that there are X k + Y bins in total after N items have been presented).
The first phase items are followed by another set of items called the second phase items. This set of items is selected out of two possible options. The first option is that ⌈ N k−1 ⌉ items of size 1 − k∆ arrive, and the second option is that ⌈ N −X k −Y k−1 ⌉ items of size 1 − α = 1 − kδ arrive. In both cases it is possible to create a solution offline such that each bin (except for possibly two bins) has k items. In the first case, an offline solution has ⌈ N k−1 ⌉ bins, each with one item of size 1 − k∆ and an arbitrary subset of k − 1 first phase items (the last bin may have a smaller number of such items). Such a solution is obviously optimal. In the second case, an offline solution has ⌈ N −X k −Y k−1 ⌉ bins, each with one item of size 1 − kδ and k − 1 small first phase items, and ⌈ X k +Y k ⌉ bins with k large first phase items (for each one of these two bin types, the last bin may have a smaller number of such items). Indeed the last solution is an optimal solution though we will only use that it is a feasible solution.
In the first case, the algorithm cannot use the bins that already have k items for packing second phase items, and its cost is at least In the second case, the algorithm cannot use any of its bins to pack any second phase item, as each bin has a large first phase item of size above α, so its cost is We call the two inputs (of the two cases) I 1 and I 2 . Obviously, since the input consists of more than N items, OP T (I 1 ) = Ω( N k ) and OP T (I 2 ) = Ω( N k ) hold. Letting N = kn provides an input I n as required. By Lemma 1, we will analyze modified competitive ratios of the form ALG(I)+Ca for fixed constants C a and C b .
For the input I 1 , OP T ( First, we analyze the competitive ratio r for input I 2 and show that it tends to 2 as k grows to infinity. Let Z = X k + Y . We have OP T ( Since Z ≥ N k and the last lower bound on r is a ratio between an increasing function of Z and a decreasing function of Z, we conclude that by substituting N k instead of Z in the last bound, we achieve a valid lower bound on r. Thus, we have r ≥ N (k−2)+kN kN − N k = 2−2/k 1−1/(k 2 ) = 2k k+1 and the last bound tends to 2 when k grows to infinity. By Lemma 1, the overall (asymptotic) competitive ratio is at least 2. Since there is a 2-competitive algorithm for any value of k [3] (even for the absolute competitive ratio [5]), we establish the following.
Theorem 5 The overall asymptotic and absolute competitive ratios for bin packing with cardinality constraints are equal to 2.
To obtain a better lower bound on the asymptotic competitive ratio r for a fixed value of k ≥ 3, we use I 1 as well. By r ≥ ALG(I 1 ) OP T (I 1 )−1 ≥ X k +N/(k−1) we have (k − 1)X k ≤ (r − 1) · N . By counting arguments, N ≤ kX k + (k − 1)Y holds, and we get As we saw earlier, by using I 2 we have r ≥ Z(k 2 −2k)+kN kN −Z , which is equivalent to Combining the lower bound and upper bound on Z results in Since k 3 − k 2 − 2k ≥ 0 holds for k ≥ 2 and 2k 3 − 4k 2 + k > 0 holds for k ≥ 2, it is sufficient to find the (unique) positive root which is equal to The last expression is a lower bound on r and thus the following holds.
Theorem 6 For any k ≥ 3, the asymptotic competitive ratio for bin packing with cardinality constraints is at least The last lower bound is equal to approximately 1.54983 for k = 3, 1.63330 for k = 4, 1.69047 for k = 5, 1.73214 for k = 6, 1.76388 for k = 7, 1.78888 for k = 8, 1.80909 for k = 9, and 1.82575 for k = 10. For k = 2 the resulting lower bound is √ 2 and the construction (for the case k = 2) is indeed similar to that of [6,3].

Better lower bounds for some small values of k
In this section we prove the next theorem that improves the resulting bounds of Theorem 6 for these values of k.

Theorem 7
The following values are lower bounds on the asymptotic competitive ratio. • approximately 1.79634 for k = 8, • approximately 1.81563 for k = 9, • and approximately 1.83148 for k = 10.

k = 3
Given a positive integer N , let ε = 3 −2 2N+4 (where ε < 1 1000 ). Use SMALL to present exactly N items, such that C 1 is defined as the condition that the new item is packed into a bin that already has at least one item and C 2 is the condition that the new item is packed into an empty bin. Recall that all item sizes are no larger than ε. This will be called the first phase of the input and its items will be called first phase items.
Let u 1 be the size of the largest small item and let u 2 be the size of the smallest large item, where u 2 > k · u 1 . Let X ℓ denote the number of bins with ℓ items packed by the algorithm in the first phase (for 1 ≤ ℓ ≤ 3). If the input is stopped at this time, we call the input J 1 . As OP T (J 1 ) = ⌈ N 3 ⌉, we have OP T (J 1 ) − 1 ≤ N 3 and ALG(J 1 ) = X 1 + X 2 + X 3 . Thus, for the competitive ratio r of the set of inputs we define for N , X 1 + X 2 + X 3 ≤ r · N 3 , while X ℓ ≥ 0 holds for ℓ = 1, 2, 3, and by There are three possible continuations to the input, resulting in inputs J 2 , J 3 , and J 4 . The second phase of J 2 consists of ⌈ N 2 ⌉ (second phase) items, each of size 1 − 2ε > 1 2 . Since any first phase item has size of at most ε, and any second phase item requires a separate bin (where it can be packed with two first phase items possibly with one in the last such bin, if N is odd), we have OP T (J 2 ) − 1 ≤ N 2 . The algorithm cannot pack any additional item in a bin containing three items, The second phase of J 3 consists of ⌈ N −X 1 −X 2 −X 3 2 ⌉ (second phase) items, each of size 1−2·u 1 > 1 2 . One feasible solution would be to pack ⌈ X 1 +X 2 +X 3 3 ⌉ bins containing (at most) three large first phase items, and ⌈ N −X 1 −X 2 −X 3 2 ⌉ bins containing one second phase item and (at most) two small first phase items. This solution is valid since any three first phase items can be packed into a bin (and the number of large first phase items is exactly X 1 + X 2 + X 3 ), and additionally, any two small first phase items have total size of at most 2 · u 1 . Thus, OP T ( . The algorithm has one large first phase item (of size above 3u 1 ) packed into each bin used for first phase items. Thus, it packs each second phase item into a new bin. We get ), or equivalently 6X 1 +9X 2 +12X 3 ≤ r·(2X 1 +5X 2 +8X 3 ). Next, to define J 4 , let ε ′ = 1, and use LARGE to define the second phase consisting of second phase items as follows. The number of items will be at most 2N , and the size of each item will be in (1 − 3 −2 2N+2 , 1 − 3 −2 2N+3 ). The size of each item is above 1 2 , and it can be packed with any one or two first phase items. Condition C 1 is that the item is packed into a new bin, C 2 is that the item is not packed into a new bin, and C 3 is that the number of items satisfying C 1 is exactly ⌈ N 2 ⌉. Since X 1 + X 2 + X 3 ≤ X 1 + 2X 2 + 3X 3 = N , the total number of second phase items is at most X 1 + X 2 + ⌈ N 2 ⌉ ≤ 2N , so the upper bound on the number of items is sufficiently large and C 3 happens before reaching the bound of 2N . Let d denote the number of second phase items introduced by the algorithm that satisfied C 2 . Since all second phase items have sizes above 1 2 , and a bin that already contains three items cannot receive additional items, we find d ≤ X 1 + X 2 . Let 0 < ζ 1 < ζ 2 < 1 100 where ζ 2 > 3 · ζ 1 be such that every second phase item that satisfied C 1 has size no smaller than 1 − ζ 1 and every item satisfying C 2 has size no larger than 1 − ζ 2 . The third phase consists of 2d (third phase) items, each of size ζ 2 2 (where ζ 2 2 > ζ 1 ). An optimal solution packs the items as follows. Each second phase item satisfying C 2 is packed with two third phase items.
Each second phase item satisfying C 1 (recall that there are ⌈ N 2 ⌉ such items) is packed with two first phase items (there is at most one bin with one first phase item). The solution is feasible as the size of any second phase item is in (1 − 3 −2 2N+2 , 1 − 3 −2 2N+3 ), any two first phase items have a total size of at most 2 · 3 −2 2N+4 < 3 −2 2N+3 , and those second phase items packed with third phase items have sizes no larger than 1 − ζ 2 . This solution is optimal since its cost is equal to the number of second phase items, and their sizes are above 1 2 Note that the number of items in J 4 is at least 3 · (d + N 2 ). The algorithm packs every item of the second phase satisfying C 1 into a separate bin that will not receive additional items (and there are at least N 2 such bins). When such an item arrives, it is packed into a new bin, and its size is above 1 2 and at least 1 − ζ 1 , while any additional second phase item has a size above 1 2 , and any third phase item has a size above ζ 1 . Other items can be packed in triples in the best case (and there are 3d + N such items). Therefore, ALG(J 3 ) ≥ N +3d 3 + N 2 = d + 5N 6 . We find Solving the mathematical (quadratic) program (MP) for minimizing r subject to the above constraints gives r ≥ 1.55642.

k ≥ 5
Here, we follow the construction of Section 4 of introducing either I 1 or I 2 , but we add a third option as follows. Let X k−1 denote the number of bins packed with k − 1 items after the first phase, and let Y ′ be the number of bins packed with at most k − 2 items (X k will still denote the number of bins packed with exactly k items after the first phase). Thus, Y = X k−1 + Y ′ is the number of bins that can accommodate an additional item. We have N ≤ kX k + (k − 1)X k−1 + (k − 2)Y ′ . Input I 3 is similar to I 2 in the sense that its first two phases are the same, but it also has a third phase in which λ 3 = 2⌈ ⌉ (third phase) items, each of size 0.35, are presented. The sizes of the first phase items are such that every second phase item has a size above 0.65, and every k − 2 first phase items have a total size below 0.3.
Bins of the solution returned by the algorithm with second phase items are separate bins containing one item each at termination. Bins with k items (packed with first phase items) cannot receive additional items. A bin with k − 1 first phase items can receive one third phase item, and a bin with k − 2 or less first phase items can receive at most two third phase items, due to the sizes of third phase items (which are above 1 3 ). Thus, at most X k−1 + 2Y ′ third phase items can be added to non-empty bins, and the remaining max{0, λ 3 − X k−1 − 2Y ′ } items require new bins.
Case 1: Assume that λ 3 ≤ X k−1 + 2Y ′ . In this case, the items of the third phase are not presented. For this case we use a mathematical program with the objective of minimizing r with non-negativity constraints of all variables, the condition defining this case, and the constraints ALG(I 1 ) ≤ r · (OP T (I 1 ) − 1) and ALG(I 2 ) ≤ r · (OP T (I 2 ) − 2). Letting ⌉, the last two constraints are X k + λ 1 ≤ r · N +λ 1 k and X k + Y + λ 2 ≤ r · N +λ 2 k (in the mathematical program we will relax the equality constraints defining λ 1 , λ 2 , λ 3 into valid inequality constraints). Thus, the constraints are the non-negativity constraints X k−1 , X k , Y ′ , Y, λ 1 , λ 2 , λ 3 ≥ 0, the constraints defining the auxiliary variables , the constraint defining this case λ 3 ≤ X k−1 +2Y ′ , and the last two constraints saying that the algorithm is r-competitive for the two inputs I 1 and I 2 , that is, X k + λ 1 ≤ r · N +λ 1 k and X k + Y + λ 2 ≤ r · N +λ 2 k .
Case 2: For the other case, i.e., λ 3 ≥ X k−1 + 2Y ′ we use a similar mathematical program with all these constraints, with the change that the constraint for λ 3 is λ 3 ≥ X k−1 + 2Y ′ (instead of λ 3 ≤ X k−1 + 2Y ′ in the mathematical program for case 1), and that a constraint for I 3 is added, as we get another constraint from ALG(I 3 ) ≤ r · (OP T (I 3 ) − 2).
The new constraint for I 3 is based on the following reasoning. The offline solution we consider packs the small first phase items and the second phase items as before, while every k − 2 large first phase items are packed with two third phase items (one bin may contain a smaller number of large first phase items). Thus, OP T (I 3 ) − 2 ≤ N +λ 2 +λ 3 k . The algorithm has X k + X k−1 + Y ′ bins created for the first phase items, λ 2 bins created for the second phase items, and at least ⌈ ⌉ bins for the third phase items (which could not be packed into non-empty bins, as only X k−1 + 2Y ′ third phase items can be packed there, and the remaining third phase items can be packed in pairs in the best case). Thus, Thus, the constraint that we add to the mathematical program corresponding to the input I 3 is The lower bound on r results from the minimum of the solutions of the two mathematical programs stated above. This gives the following lower bounds on the competitive ratio: approximately 1.69776 for k = 5, 1.74093 for k = 6, 1.77223 for k = 7, 1.79634 for k = 8, 1.81563 for k = 9, and 1.83148 for k = 10.
Remark 8 Another way to define the third phase is to present items of sizes slightly above 1 4 (3⌈ Y +X k k−3 ⌉ such items) instead of items of sizes slightly above 1 3 . Analyzing this additional scenario results in slightly better results for k = 8, 9, 10 (more specifically, a lower bound of approximately 1.79758 on the competitive ratio for k = 8, 1.81812 for k = 9, and 1.83442 for k = 10). Since the improvement is not significant we omit the details.

k = 2
In this section we prove an improved lower bound of 10 7 ≈ 1.42857 for k = 2. In previous constructions procedures of the type presented in Section 3 were used. In [6,3], items are presented in just two phases, that is, only one such construction is used. In [11], there are additional phases, but they are different from what we present below in the sense that their number is fixed in advance. Our construction allows a shorter analysis avoiding linear programs.
Given a positive integer N , let ε = 2 −2 5N+4 (where ε < 1 1000 ). Use SMALL to present exactly N items, such that C 1 is defined as the condition that the new item is packed into a bin that already has an item and C 2 is the condition that the new item is packed into an empty bin. Recall that all item sizes are no larger than ε. This will be called the first phase of the input and its items will be called first phase items.
Let u 1 be the size of the largest small item and let u 2 be the size of the smallest large item, where u 2 > u 1 . Let u = u 1 +u 2 2 . First phase items that satisfied C 1 will be called t − items, and first phase items that satisfied C 2 will be called t + -items. Any t − -item has size of at most u 1 < u and any t + -item has size of at least u 2 > u. Let X ℓ denote the number of bins with ℓ items packed by the algorithm in the first phase (for ℓ = 1, 2). The input continues with X 2 (second phase) items, each of size 1 − u (where 1 − u > 1 2 ). Since every bin of the algorithm has a t + -item, the algorithm will pack every item of size 1 − u into a separate new bin. If the input is stopped at this time, we call the input J 1 . For an offline solution, it is possible to pack every t − -item into a bin together with an item of size 1 − u, and t + -items are packed in pairs into bins (one bin may contain only one such item). Thus, We also have ALG(J 1 ) = X 1 + 2X 2 . Thus, for the competitive ratio r of the set of inputs we define for N , Due to the number of items introduced so far, X 1 + 2X 2 = N , so we get 2N ≤ r · (N + X 2 ). If for an infinite number of values N , it holds that X 2 ≤ 2N 5 , we find 2N ≤ r · (N + X 2 ) ≤ r · 1.4N , proving r ≥ 2 1.4 = 10 7 . Thus, we focus on the case X 2 ≥ 2N 5 (and therefore X 1 = N − 2X 2 ≤ N 5 ). The third phase will consist of at most 2N + 1 parts. The total number of items that will be presented (during all parts of this phase) is at most 5N , and they will be presented using procedure SMALLandLARGE. The procedure is applied once with ε ′ = 1. For any i such that a i will be defined, we will have ε < 2 −2 5N+3 < a i < 2 −2 5N+2 < 1 2 , while any first phase item has size at most ε. Thus, an item of size 1 − a i and a first phase item have a total size of at most ε + 1 − a i < 1.
The conditions C 1 and C 2 are as follows. In parts of the phase of even indices, C 1 is defined as the condition that the new item is packed into a bin that already has an item and C 2 is the condition that the new item is packed into an empty bin. In parts of the phase of odd indices, C 2 is defined as the condition that the new item is packed into a bin that already has an item and C 1 is the condition that the new item is packed into an empty bin. Moreover, if an item of index i (in the phase) is presented in part t of the phase, its size is µ i = a i if t is even and its size is µ i = 1 − a i if t is odd. Note that any item of an odd indexed part of the phase has size above 1 2 , and any item of an even indexed part has size below 1 2 . We will call the items of even indexed parts that satisfied C 1 : s − -items, and we call the items of even indexed parts that satisfied C 2 : s + -items. We will call the items of odd indexed parts that satisfied C 2 : b − -items, and we call the items of odd indexed parts that satisfied C 1 : b + -items. For a part of index z, let ν z denote the required number of b + -items of this part, if z is odd, and let ν z denote the required number of s + -items of this part, if z is even. Let ν ′ z denote the number b − -items of part z, if z is odd, and let ν ′ z denote the number of s − -items of this part, if z is even. The values ν ′ z result from the action of the algorithm in part z, while the values ν z are defined based on its action in earlier phases and earlier parts as follows. For any z, let ν z = X 2 , if z = 1, and otherwise ν z = ν ′ z−1 . If ν z = 0, no items are presented, and the input was stopped already.
Part z lasts until there are ν z items that are b + -items, if z is odd, or until there are ν z items that are s + -items, if z is even. Note that these are exactly the items that are packed into new bins. If at some time the number of third phase items reaches the value 5N , the input is stopped. We will later show that this never happens, and ν z items that are either b + -items or s + -items are presented as required. The value ν ′ z is defined to be the number of other items presented during this part, which are exactly the items that are packed by the algorithm as second items into non-empty bins. If ν ′ z = 0, the input is stopped, and otherwise, the construction continues to the next part. We will also show that the input is stopped after at most 2N + 1 parts.
For the input J 2 , consisting of all three phases, we use the following variables. Let x = 2X 2 and y = X 1 . Given the output of the algorithm, let z denote the number of bins where the first item is a third phase item (by definition, this item is a b + -item or a s + -item). Out of these bins, let z 1 be the number of bins with one b + -item, let z 2 be the number of bins with two items (these must be an s + -item and an s − -item), and let z 3 be the number of bins with one s + -item. Out of the bins with a t + -item that do not have a t − -item, let y 1 denote the number of bins that have a b − -item, let y 2 denote the number of bins that have an s − -item, and let y 3 be the number of bins that do not have another item.
By the action of SMALLandLARGE, the value a i is larger than any value a j where j < i, if the item corresponding to a j is an s − -item or a b + -item, and a i < a j , if the item corresponding to a j is an s + -item or a b − -item. Therefore, we find that any b + -item can be packed with any t + -item or with any s − -item of an earlier part of phase 3, and any b − -item can be packed with any s + -item of a later part. However, a b + -item cannot be packed with a s − -item of a later part. Moreover, a b − -item of part z cannot be packed with any s + -item of an earlier part. Thus, b − -items can be packed only into bins already containing t + -items (they also cannot be added to bins containing an item of size above 1 2 and they cannot be packed into empty bins since in such a case the item is defined to be a b + -item). Therefore, the total number of b − -items in all parts cannot exceed y ≤ N .
We show that the third phase can indeed be constructed. First, we show that the process can be completed assuming that the upper bound on the number of items is sufficiently large. Since for part z, the required ν z items are items that are packed into new bins, and since at each time the number of non-empty bins is finite, these items will be presented eventually. There can be at most N parts of odd indices in which at least one b − -item is presented. Thus, the construction must end after N + 1 parts of odd indices, if it is not stopped earlier, and the number of parts is at most 2N + 1.
The number of t + -items is X 1 + X 2 = x 2 + y. The number of t − -items is X 2 = x 2 . The number of second phase items is x 2 . The number of b + -items is equal to the number of t + -items plus the number of s − -items, and it is equal to z 1 = ( x 2 + y) + y 2 + z 2 . The number of b − -items is equal to the number of s + -items, and it is equal to y 1 = z 2 + z 3 . Thus, the total number of items in phase 3 is at most y 1 + z 1 + (z 2 + z 3 ) + (y 2 + z 2 ) = 2y 1 + z 1 + y 2 + z 2 = 2y 1 + x 2 + y + y 2 + z 2 + y 2 + z 2 ≤ 3y + x 2 + 2(y 1 − z 3 ) ≤ 5y + x 2 ≤ 5N .
It is possible to create an offline solution of cost x 2 + y 1 + z 1 due to the following. Any t − -item can be packed with any second phase item, and packing such pairs creates X 1 = x 2 bins. Each t + -item is packed with a b + -item of the first part of the third phase (the numbers of such items are equal to ν 1 ), each s − -item of part z is packed with a b + -item of part z + 1 (the number of such items are ν ′ z = ν z+1 ) and each b − -item of part z is packed with a s + -item of part z + 1 (the number of such items are ν ′ z = ν z+1 ). Thus, the number of additional bins is exactly the number of b + -items and b − -items, which is y 1 + z 1 . Thus, OP T (J 2 ) ≤ x 2 + y 1 + z 1 . As for the algorithm, it can never use bins with b + -items to pack other items (note that these items are packed first into bins, by definition), so there are no additional bins except for the eight types described above. Thus ALG(J 2 ) = x + y + z.

Conclusion
As explained in the introduction, our results imply, in particular a lower bound of 2 on the competitive ratio for vector packing in two or more dimensions. We can slightly improve this result showing lower bounds above 2 for vector packing with constant dimensions (already for two dimensions).