Online Bin Covering with Limited Migration

TL;DR

This paper investigates the bin covering problem in semi-online models allowing limited decision revocations, developing algorithms with near-optimal migration and competitive ratios for static and dynamic scenarios.

Contribution

It introduces the first comprehensive study of bin covering with migration, providing algorithms and bounds for both static and dynamic cases, and resolving its competitiveness.

Findings

Algorithms with nearly optimal migration factors.

Lower bounds matching the algorithms' performance.

Resolution of the problem's competitiveness with migration.

Abstract

Semi-online models where decisions may be revoked in a limited way have been studied extensively in the last years. This is motivated by the fact that the pure online model is often too restrictive to model real-world applications, where some changes might be allowed. A well-studied measure of the amount of decisions that can be revoked is the migration factor $\beta$: When an object $o$ of size $s(o)$ arrives, the decisions for objects of total size at most $\beta\cdot s(o)$ may be revoked. Usually $\beta$ should be a constant. This means that a small object only leads to small changes. This measure has been successfully investigated for different, classic problems such as bin packing or makespan minimization. The dual of makespan minimization - the Santa Claus or machine covering problem - has also been studied, whereas the dual of bin packing - the bin covering problem - has not been looked at from such a perspective. In this work, we extensively study the bin covering problem with migration in different scenarios. We develop algorithms both for the static case - where only insertions are allowed - and for the dynamic case, where items may also depart. We also develop lower bounds for these scenarios both for amortized migration and for worst-case migration showing that our algorithms have nearly optimal migration factor and asymptotic competitive ratio (up to an arbitrary small $\eps$). We therefore resolve the competitiveness of the bin covering problem with migration.

Tables

Amortization	Departures	Lower Bound	Competitive Ratio	Migration
\faRemove	\faRemove	$3/2$	$3/2+\epsilon$	$𝒪\left(1/\epsilon \right)$
\faRemove	\faCheck	$3/2$	$3/2+\epsilon$	$𝒪\left(\frac{{\log }^2\left(1/\epsilon \right)}{{\epsilon }^5}\right)$
\faCheck	\faRemove	$1$	$1+\epsilon$	$𝒪\left(1/\epsilon \right)$
\faCheck	\faCheck	$3/2$	$3/2+\epsilon$	$𝒪\left(\frac{{\log }^2\left(1/\epsilon \right)}{{\epsilon }^5}\right)$

Equations

$$\mathtt{Bins}=\mathtt{BB}\dot{\cup }\mathtt{BM}\dot{\cup }\mathtt{BS}\dot{\cup }\mathtt{M}\dot{\cup }\mathtt{S},$$

$$s(I)<2|\mathtt{BB}|+(1+\epsilon )|\mathtt{BS}|+1.5|\mathtt{BM}|+1.5|\mathtt{MC}|+(1+\epsilon )|\mathtt{SC}|+2$$

$$\mathrm{opt}(I)<(1.5+\epsilon )(|\mathtt{BB}|+|\mathtt{BSC}|+|\mathtt{BM}|+|\mathtt{MC}|+|\mathtt{SC}|)+2.5<(1.5+\epsilon )\mathrm{alg}(I)+3.$$

$$\mathrm{opt}(I)\le s(I)<1.5|\mathtt{BM}|+1.5|\mathtt{MC}|+2=1.5\mathrm{alg}(I)+2.$$

$$2k_2+k_1=|X\cup Y|=(2|\mathtt{BB}|+|\mathtt{BS}|+|\mathtt{BM}|)+(|\mathtt{BM}|+|\mathtt{BSC}|).$$

$$(1-\xi )k_1+k_0\le s(Z).$$

$$s(Z)\le (1-\xi )(|\mathtt{BM}|+|\mathtt{BSC}|+2).$$

$$2\mathrm{opt}(I)$$

$$\le (2k_2+k_1)+(k_1+(1-\xi {)}^{-1}{k}_0)$$

$$\le (2|\mathtt{BB}|+|\mathtt{BS}|+|\mathtt{BM}|+|\mathtt{BM}|+|\mathtt{BSC}|)+(|\mathtt{BM}|+|\mathtt{BSC}|+2)$$

$$\le 3|\mathtt{BB}|+3|\mathtt{BM}|+2|\mathtt{BSC}|+3$$

$$\le 3\mathrm{alg}(I)+3.$$

$$\mathcal{O}(1/\epsilon ((1-s(B_k))+{\psi }_k/\epsilon ))=\mathcal{O}(1/\epsilon ((1-s(B))+(G+1)\psi /\epsilon )),$$

$$\mathcal{O}(G\times 4^G\times 1/\epsilon ((1-s(B))+G\psi /\epsilon ))$$

$$=\mathcal{O}((1/{\epsilon }^3)\cdot \log (1/\epsilon )((1-s(B))+(1/\epsilon )\cdot \log (1/\epsilon )\psi ))$$

$$\le \mathcal{O}((1/{\epsilon }^4)\cdot {\log }^2(1/\epsilon )[(1-s(B))+\psi ]).$$

$$s(I)$$

$$<2|\mathtt{BB}|+(1+\epsilon )|\mathtt{BSC}|+s(\mathtt{GB})+1.5|\mathtt{BM}|+1.5|\mathtt{MC}|+1+(1+\epsilon )|\mathtt{SC}|+s(\mathtt{S}\setminus \mathtt{SC}).$$

$$\mathrm{opt}(I)$$

$$\le (1.5+\epsilon )(|\mathtt{BB}|+|\mathtt{BSC}|+|\mathtt{BM}|+|\mathtt{MC}|+|\mathtt{SC}|)+\log (1/\epsilon )+5$$

$$=(1.5+\epsilon )\mathrm{alg}(I)+\log (1/\epsilon )+5.$$

$$\mathrm{opt}(I)\le s(I)<1.5|\mathtt{BM}|+1.5|\mathtt{MC}|+2=1.5\mathrm{alg}(I)+2.$$

$$2k_{2}+k_{1}=|X\cup Y|\overset{\text{\ref{DInvariant:parallel_chain_structure}}}{\leq}(2|\mathtt{BB}|+|\mathtt{BS}|+|\mathtt{BM}|)+(|\mathtt{BM}|+|\mathtt{BSC}|+\varepsilon|\mathtt{BSC}|+G).$$

$$s(Z)$$

$$\le (1-\xi )(|\mathtt{BM}|+|\mathtt{BSC}|+|{\mathtt{Gr}}_{g^{\ast }}|+\epsilon |\mathtt{BSC}|+G)+(1-s_{\max }(\mathtt{BS}))$$

$$\le (1-\xi )(|\mathtt{BM}|+(1+\epsilon )|\mathtt{BSC}|+\lceil \epsilon |\mathtt{BS}|\rceil +\sum _{g^{\prime }=1}^{g^{\ast }-1}|{\mathtt{Gr}}_{g^{\prime }}|+G+1)$$

$$\le (1-\xi )(|\mathtt{BM}|+(1+\epsilon )|\mathtt{BSC}|+\lceil \epsilon |\mathtt{BS}|\rceil +|\mathtt{BSC}|+G+1)$$

$$\le (1-\xi )(|\mathtt{BM}|+(2+\epsilon )|\mathtt{BSC}|+\epsilon |\mathtt{BS}|+G+2).$$

$$2\mathrm{opt}(I)$$

$$\le (2k_2+k_1)+(k_1+(1-\xi {)}^{-1}{k}_0)$$

$$\le (2|\mathtt{BB}|+|\mathtt{BS}|+|\mathtt{BM}|)+(|\mathtt{BM}|+|\mathtt{BSC}|+\epsilon |\mathtt{BSC}|+G)$$

$$+(|\mathtt{BM}|+(2+\epsilon )|\mathtt{BSC}|+\epsilon |\mathtt{BS}|+G+2)$$

$$=2|\mathtt{BB}|+(1+\epsilon )|\mathtt{BS}|+3|\mathtt{BM}|+(3+2\epsilon )|\mathtt{BSC}|+2G+2$$

$$\stackrel{\text{refDInvariant:BB=BS}}{\le }2|\mathtt{BB}|+(1+\epsilon )(|\mathtt{BB}|+1)+3|\mathtt{BM}|+(3+2\epsilon )|\mathtt{BSC}|+2G+2$$

$$\stackrel{\text{refDInvariants:Groupstructure}}{\le }(3+\epsilon )|\mathtt{BB}|+3|\mathtt{BM}|+(3+2\epsilon )|\mathtt{BSC}|+2\log (1/\epsilon )+8$$

$$\le (3+2\epsilon )\mathrm{alg}(I)+2\log (1/\epsilon )+8.\text{qed}$$

$$3N\epsilon \le 3N/(9\beta N+2)<3N/(9\beta N)=1/(3\beta )\le (1-2\epsilon )/\beta .$$

$$(3/2)\cdot \mathrm{alg}(I_j^{(N)})\le (3/2-\delta )\cdot \mathrm{alg}(I_j^{(N)})+c.$$

$$\mathrm{opt}(I)\le (1+\epsilon ){\mathrm{alg}}_{\mathrm{off}}(I,\epsilon )+\frac{\mu }{{\epsilon }^3}$$

$${\mathrm{alg}}_{\mathrm{off}}(I_{\tau },\epsilon )<(1+\epsilon ){\mathrm{alg}}_{\mathrm{off}}(I_{t_i},\epsilon ).$$

Full text

This is motivated by the fact that the pure online model is often too restrictive to model real-world applications, where some changes might be allowed. A well-studied measure of the amount of decisions that can be revoked is the migration factor $\beta$: When an object $o$ of size $s(o)$ arrives, the decisions for objects of total size at most $\beta\cdot s(o)$ may be revoked. Usually $\beta$ should be a constant. This means that a small object only leads to small changes. This measure has been successfully investigated for different, classic problems such as bin packing or makespan minimization. The dual of makespan minimization – the Santa Claus or machine covering problem – has also been studied, whereas the dual of bin packing – the bin covering problem – has not been looked at from such a perspective.

In this work, we extensively study the bin covering problem with migration in different scenarios. We develop algorithms both for the static case – where only insertions are allowed – and for the dynamic case, where items may also depart. We also develop lower bounds for these scenarios both for amortized migration and for worst-case migration showing that our algorithms have nearly optimal migration factor and asymptotic competitive ratio (up to an arbitrary small $\varepsilon$). We therefore resolve the competitiveness of the bin covering problem with migration.

1 Introduction

Online algorithms aim to maintain a competitive solution without knowing future parts of the input. The competitive ratio of such an algorithm (for a maximization problem) is thus defined as the worst-case ratio between the value of an optimal solution produced by an offline algorithm knowing the complete input and the value of the solution produced by the online algorithm. Furthermore, once a decision is made by these algorithms, this decision is fixed and irreversible. While a surprisingly large number of problems do have such algorithms, the complete irreversibility requirement is often too strict, leading to high competitive ratios. Furthermore, if the departure of objects from the instance is also allowed, irreversible online algorithms are rarely able to be competitive at all. From a practical point of view, this is quite alarming, as the departure of objects is part of many applications. We call such a problem dynamic and the version with only insertions static.

A number of different scenarios to loosen the strict requirement of irreversibility – called semi-online scenarios – have been developed over time in order to find algorithms that achieve good competitive ratios for some of the scenarios bounded reversibility. In the last few years, the concept of the migration factor has been studied intensively [4, 11, 12, 13, 14, 17, 20, 22, 23]. Roughly speaking, a migration factor of $\beta$ allows to reverse a total size of $\beta\cdot s(o)$ decisions, where $s(o)$ denotes the size of the newly arrived object $o$. For a packing problem, this means that the algorithm is allowed to repack objects with a total size of $\beta\cdot s(o)$. This notion of reversibility is very natural, as it guarantees that a small object can only lead to small changes in the solution structure. Furthermore, algorithms with bounded migration factor often show a very clear-cut tradeoff between their migration and the competitive ratio: Many algorithms in this setting have a bounded migration factor which can be defined as a function $f(\varepsilon)$ (growing with $\frac{1}{\varepsilon}$) and a small competitive ratio $g(\varepsilon)$ (growing with $\varepsilon$), where the functions $f$ and $g$ can be defined for all $\varepsilon>0$ [4, 11, 14, 17, 20, 22, 23]. Such algorithms are called robust, as the amount of reversibility allowed only depends on the solution guarantee that one wants to achieve. Such robust algorithms thus serve as evidence for the possibility for sensitivity analysis in approximated settings.

Many different problems have been studied in online and semi-online scenarios, but two problems that have been considered in nearly every scenario are classic scheduling problems: The bin packing problem and the makespan minimization problem. Both of these problems have been studied intensively in the migration model [4, 11, 13, 14, 20, 22, 23]. Both of these problems also have corresponding dual maximization variants. The dual version of the makespan minimization problem, often called the Santa Claus or machine covering problem, has also been studied with migration [17, 23]. In contrast, the dual version of bin packing, called bin covering has not yet been studied in this model. The aim of this paper is to remedy this situation by taking a look at this classic scheduling problem in the migration model.

Formal Problem Statement

In the bin covering problem, a set of items $\Gamma$ with sizes $s\colon\Gamma\to(0,1]$ is used to cover as many unit sized bins as possible, that is, $\Gamma$ has to be partitioned maximizing the number of partitions with summed up item size of at least one. An instance of the problem will usually be denoted as $I$ and is given as a sequence of entries $(i,s(i))$ where $i$ is the identifier of the item and $s(i)$ is the size of the item. A solution to such an instance $I$ with items $\Gamma$ is a partition $P\colon\Gamma\to\mathbb{N}$ and a set $B=P^{-1}(k)$ with $B\neq\emptyset$ is called a bin and we say that the items in $B$ are packed into the $k$-th bin. For a subset $I^{\prime}\subseteq I$, let $s(I^{\prime})=\sum_{i\in I^{\prime}}s(i)$. A bin $B$ is covered if $s(B)\geq 1$, where $s(B)$ is called the load of $B$ or its size, and the goal is to maximize the number of such covered bins. The optimal (maximum) number of covered bins of instance $I$ is denoted as $\operatorname{\text{{opt}}}(I)$.

We also use the following notations throughout our work: The smallest size of an item in bin $B$ is defined as $s_{\min}(B):=\min_{i\in B}\{s(i)\}$ and the largest size is defined as $s_{\max}(B):=\max_{i\in B}\{s(i)\}$. If $\mathcal{B}$ is a set of bins, we also define its total size $s(\mathcal{B}):=\sum_{B\in\mathcal{B}}s(B)$, its minimal size $s_{\min}(\mathcal{B}):=\min_{B\in\mathcal{B}}s_{\min}(B)$, and its maximal size $s_{\max}(\mathcal{B}):=\max_{B\in\mathcal{B}}s_{\max}(B)$. Furthermore, we define $s_{\min}(\emptyset)=+\infty$ and $s_{\max}(\emptyset)=0$.

We consider variants of static and dynamic online bin covering in which algorithms are allowed to reassign a bounded amount of previously assigned items. In particular, an algorithm has a migration factor of $\beta$, if the total size of items that it reassigns upon arrival or departure of an item of size $s$ is bounded by $\beta s$. Moreover, it has an amortized migration factor of $\beta$, if at any time the total size of items that have been reassigned by the algorithm in total is bounded by $\beta S$, where $S$ is the total size of all items that arrived before. Intuitively, an item of size $s$ creates a migration potential of size $\beta s$ upon arrival, and this potential may be used by an algorithm to reassign items right away (non-amortized) or anytime from then on (amortized). Note that if an algorithm has a non-amortized migration factor of $\beta$, then it also has an amortized migration factor of at most $\beta$. Thus, we study four variants in this work.

Offline bin covering is $\mathrm{NP}$-hard and therefore there is little hope for a polynomial time algorithm solving the problem to optimality, and in the online setting there is no algorithm that can maintain an optimal solution regardless of its running time. We prove that this non-existence of algorithms that maintain an optimal solution holds also for (static or dynamic) algorithms with bounded amortized migration factor (and thus also for algorithms with bounded non-amortized migration factor).

Hence, algorithms satisfying some performance guarantee are studied. In particular an offline algorithm $\operatorname{\text{{alg}}}$ for a maximization problem has an asymptotic performance guarantee of $\alpha\geq 1$, if $\operatorname{\text{{opt}}}(I)\leq\alpha\cdot\operatorname{\text{{alg}}}(I)+c$, where $\operatorname{\text{{opt}}}(I)$ and $\operatorname{\text{{alg}}}(I)$ are the objective values of an optimal solution or the one produced by $\operatorname{\text{{alg}}}$ respectively for some instance $I$, and $c$ is an input independent constant. If $c=0$ holds, $\alpha$ is called absolute rather than asymptotic. An online algorithm has a (asymptotic or absolute) competitive ratio of $\alpha$, if after each arrival or departure an (asymptotic or absolute) performance guarantee of $\alpha$ for the instance of the present items holds. Note that we use the convention of competitive ratios larger than $1$ for maximization problems. For minimization problems similar definitions are used but they use the required inequality $\operatorname{\text{{alg}}}(I)\leq\alpha\cdot\operatorname{\text{{opt}}}(I)+c$. As we study asymptotic competitive ratios in this paper, we will sometimes omit the word asymptotic (and we always use the word absolute for absolute competitive ratios).

In what follows we assume $s\colon\Gamma\to(0,1)$, i. e., that there are no items of size $1$. This is justified by the following. For any algorithm it is possible to add a rule that such an item will always be packed into its own bin, which will be covered. Without loss of generality, we can consider an optimal solution that applies this rule as well. This does not affect the (asymptotic or absolute) competitive ratio.

Known Results for Bin Covering

The offline bin covering problem was first studied by Assmann et al. [1]. It was shown that a simple greedy strategy achieves approximation ratio $2$. For the online version of the bin covering problem, Csirik and Totik showed in [7] that this simple greedy algorithm also works in the online setting and that the competitive ratio of $2$ reached by this algorithm is the best possible. Csirik, Johnson, and Kenyon presented an asymptotic polynomial time approximation scheme (APTAS) with approximation ratio $1+\varepsilon$ in [6]. This was improved to an asymptotic fully polynomial time approximation scheme (AFPTAS) by Jansen and Solis-Oba in [21]. Many different variants of this problem have also been investigated: If a certain number of classes needs to be part of each bin [10, 16]; if items are drawn probabilistically [15, 16]; if bins have different sizes [8, 24]; if the competitiveness is not measured with regard to an optimal offline algorithm [5, 9]. More variants are discussed for example in [18] and lower bounds for several variants are studied in [2]. The dynamic variant was not studied in the online scenario since there is no algorithm with a finite competitive ratio. Specifically, if all items are very small, it can happen that items depart in a way that no bin remains covered, while an optimal solution could pack items differently such that all items depart from a small number of bins, and in this way it will still cover many bins.

Our Results

We present competitive algorithms using both amortized migration and non-amortized migration and develop nearly matching lower bounds (up to an arbitrary small additive term of $\varepsilon$). These bounds show the optimality of all of our algorithms for both the static and the dynamic version of the bin covering problem. The main technical contribution of our work is an algorithm with competitive ratio $3/2+\varepsilon$ and non-amortized migration of $\mathcal{O}(\frac{\log^{2}(1/\varepsilon)}{\varepsilon^{5}})$ for the dynamic bin covering problem where items arrive and depart. A major obstacle in the design of competitive algorithms for dynamic problems is the impossibility of moving large items on the arrival or departure of small items. We overcome this obstacle by developing a delicate technique to combine the packing of large and small items. The main results of this work are summarized in the following table. Note that the lower bound of $1$ in the third row indicates that there is no online algorithm that maintains an optimal solution with amortized migration factor $\mathcal{O}(1)$. All of our algorithms run in polynomial time. Curiously, we achieve a polynomial migration factor, while most known migration factors are exponential (e.g., for the makespan minimization problem [22]) with the exception of bin packing  [19].

Thus, we show how to overcome the shortcoming of online algorithms in the dynamic setting by using migration and get a constant competitive ratio in the most general setting. Surprisingly, the constant is even smaller than the best possible competitive ratio for pure online algorithms in the static case for which the competitive ratio is $2$, while our bound is $\frac{3}{2}+\varepsilon$ for any $\varepsilon>0$.

Related Results

Makespan Minimization and Santa Claus:

The migration factor model was introduced by Sanders, Sivadasan, and Skutella in [22]. The paper investigated several algorithms for the makespan minimization problem and also presents an approximation scheme with absolute competitive ratio $1+\varepsilon$ and non-amortized migration factor $2^{O((1/\varepsilon)\cdot\log^{2}(1/\varepsilon))}$. Skutella and Verschae [23] studied a dynamic setting with amortized migration, where jobs may also depart from the instance. They achieved the same absolute competitive ratio, but their algorithm needs an amortized migration of $2^{O((1/\varepsilon)\cdot\log^{2}(1/\varepsilon))}$. Their algorithm also works for the Santa Claus (or machine covering) problem, for which they show that even in the static setting no algorithm has absolute competitive ratio $1+\varepsilon$ and a bounded migration factor. If one aims for a polynomial migration factor for the Santa Claus problem, Gálvez, Soto, and Verschae presented an online variant of the LPT (least processing time) algorithm achieving an absolute competitive ratio of $4/3+\varepsilon$ with non-amortized migration factor $O((1/\varepsilon^{3})\cdot\log(1/\varepsilon))$ [17].

For the makespan minimization problem, if jobs can be preempted, Epstein and Levin showed in [13] that an optimal algorithm with a non-amortized migration factor of $1-1/m$ is achievable and the best possible.

Bin Packing:

Epstein and Levin presented an approximation scheme with the same ratio $1+\varepsilon$ and the same non-amortized migration factor $2^{O((1/\varepsilon)\cdot\log^{2}(1/\varepsilon))}$ as in the makespan minimization for the bin packing problem in [11]. This result was improved by Jansen and Klein in [19], who drastically reduced the migration factor to $O(1/\varepsilon^{4})$. Berndt, Jansen, and Klein used a similar approach to also handle the dynamic bin packing problem, where items may also depart over time [4]. They also showed that a non-amortized migration factor of $\Omega(1/\varepsilon)$ is needed for this. A generalized model, where an item $i$ has arbitrary movement costs $c_{i}$ – not necessarily linked to the size of an item – was studied by Feldkord et al. [14]. They showed that for $\alpha\approx 1{.}387$ and every $\varepsilon>0$, a competitive ratio of $\alpha+\varepsilon$ is achievable with migration $O(1/\varepsilon^{2})$, but no algorithm with migration $o(n)$ and ratio $\alpha-\varepsilon$ exists. By strengthening the lower bound of [4], they also showed that an amortized migration factor of $\Omega(1/\varepsilon)$ is needed for the standard migration model – where the movement costs $c_{i}$ are equal to the items sizes $s_{i}$ – if one wants to achieve a competitive ratio of $1+\varepsilon$. A generalization of bin packing, where $d$-dimensional cubic items are packed into as few unit size cubes was studied by Epstein and Levin [12].

2 Non-amortized Migration in the Static Case

We begin our study by analyzing the static case with non-amortized migration. We will first present a lower bound showing that no algorithm with constant non-amortized migration factor can have a competitive ratio below $3/2$. Then, we present an algorithm that achieves for all $\varepsilon>0$ a competitive ratio of $3/2+\varepsilon$ with non-amortized migration factor $O(1/\varepsilon)$.

2.1 Lower Bound

We start with a simple lower bound on the asymptotic competitive ratio of all algorithms with constant non-amortized migration factor. This lower bound can also be proved for a different definition of the asymptotic competitive ratio $\alpha$, where we require $\operatorname{\text{{opt}}}(I)\leq\alpha\cdot\operatorname{\text{{alg}}}(I)+o(\operatorname{\text{{opt}}}(I))$.

Proposition 1**.**

There is no algorithm for static online bin covering with a constant non-amortized migration factor and an asymptotic competitive ratio smaller than $3/2$.

Proof.

Let $N$ be an integer and $\operatorname{\text{{alg}}}$ an algorithm for online bin covering with a non-amortized migration factor of $\beta$. Furthermore, let $R$ be the asymptotic competitive ratio of $\operatorname{\text{{alg}}}$, i. e., we have $\operatorname{\text{{opt}}}(I)\leq R\cdot\operatorname{\text{{alg}}}(I)+c$ for some constant value $c$. We construct an instance that is divided into two phases, in each of which of equal size items arrive. The instance corresponding to the first phase is called $I_{1}$ and the one corresponding to both phases $I_{2}$. The optimal (offline) objective value of $I_{1}$ and $I_{2}$ will be a multiple of $N$ and we will show that the ratio between this value and the objective value that is achieved by $\operatorname{\text{{alg}}}$ is at least $3/2$ either for $I_{1}$ or for $I_{2}$.

In both phases $6N$ items arrive, in the first they have size $1-\varepsilon$ and in the second one size $\varepsilon$. We choose the parameter $\varepsilon$ such that the items from the second phase do not fill a whole bin and such that they cannot be used to migrate items from the first, more precisely, let $\varepsilon=\min\{(2\beta+2)^{-1},(12N)^{-1}\}$. Note that the optimal objective value for $I_{1}$ and $I_{2}$ is $3N$ and $6N$ respectively. See Fig. 1 for feasible packings with these objective values. The optimality follows as each covered bin must have at least two items since the sizes of the items are strictly smaller than $1$. As each of the $\operatorname{\text{{alg}}}(I_{1})$ covered bins has to contain at least $2$ items from the first phase, there are at most $6N-2\operatorname{\text{{alg}}}(I_{1})$ bins each of which with exactly one item of the first phase. Furthermore, items from the first phase cannot be migrated during the second, as $\varepsilon\cdot\beta\leq(2\beta+2)^{-1}\cdot\beta<1/2<11/12\leq 1-\varepsilon$.

Hence, we have $\operatorname{\text{{alg}}}(I_{2})\leq\operatorname{\text{{alg}}}(I_{1})+(6N-2\operatorname{\text{{alg}}}(I_{1}))=6N-\operatorname{\text{{alg}}}(I_{1})$. We thus have $\operatorname{\text{{alg}}}(I_{1})+\operatorname{\text{{alg}}}(I_{2})\leq 6N$. As the asymptotic competitive ratio of $\operatorname{\text{{alg}}}$ is $R$, we can also conclude that $3N=\operatorname{\text{{opt}}}(I_{1})\leq R\cdot\operatorname{\text{{alg}}}(I_{1})+c$ and $6N=\operatorname{\text{{opt}}}(I_{2})\leq R\cdot\operatorname{\text{{alg}}}(I_{2})+c$. Summing these two inequalities gives $9N\leq R(\operatorname{\text{{alg}}}(I_{1})+\operatorname{\text{{alg}}}(I_{2}))+2c$. As $\operatorname{\text{{alg}}}(I_{1})+\operatorname{\text{{alg}}}(I_{2})\leq 6N$, we have $9N\leq 6RN+2c$ and thus $R\geq 3/2-(2c)/(6N)$. Letting $N$ grow to infinity thus yields $R\geq 3/2$.

∎

2.2 Upper Bound

We will now give our algorithm $\operatorname{\text{{alg}}}$ for this scenario. In addition to the instance $I$, a parameter $\varepsilon>0$ is also given that regulates the asymptotic competitive ratio and the used migration. The assumption $\varepsilon\leq 0.5$ is justified as for $\varepsilon\geq 0.5$, the result follows by the online algorithm with an asymptotic competitive ratio of $2$ presented in [7], or by using the algorithm below with $\varepsilon=\frac{1}{2}$.

Theorem 2**.**

For each $\varepsilon\in(0,0.5]$, there is an algorithm $\operatorname{\text{{alg}}}$ for static online bin covering with polynomial running time, an asymptotic competitive ratio of $1.5+\varepsilon$ with an additive constant of $3$, and a non-amortized migration factor of $\mathcal{O}(1/\varepsilon)$.

The algorithm distinguishes between big, medium and small items. For each item, it calls a corresponding insertion procedure based on this classification into three classes. An item $i$ is called big if $s(i)\in(0.5,1]$, medium if $s(i)\in(\varepsilon,0.5]$, and small otherwise. For a bin $B$, let $\operatorname{small}(B)$ be the set of small items of $B$. We define $\operatorname{medium}(B)$ and $\operatorname{big}(B)$ accordingly and also extend these notions to sets of bins $\mathcal{B}$. Furthermore, we call a covered bin barely covered, if removing the biggest item of the smallest class of items, i. e., big, medium or small, contained in the bin, results in the bin not being covered anymore. For instance, consider a bin containing four items with sizes $0.65$, $0.3$, $\varepsilon$ and $0.25\varepsilon$, for $\varepsilon\geq 0.04$. This bin contains items of all three classes if $\varepsilon<0.3$. In this case, the biggest item of the smallest class has size $\varepsilon$, and if $\varepsilon=0.1$, the bin is indeed barely covered. However, if $\varepsilon=0.22$, the bin is not barely covered. If $\varepsilon=0.3$, the bin only has items of two classes, and it is not barely covered, since removing one item of size $0.3$ results in a total size above $1$. Note that showing that removing an arbitrary item of the smallest class of items for a given covered bin results in an uncovered bin is sufficient for showing that it is barely covered.

Let $B$ be a barely covered bin. If $B$ contains at most one big item, its load is bounded from above by $1.5$, and if $B$ additionally contains no medium item the bound is reduced to $1+\varepsilon$. This holds due to the following. Since the big item has size below $1$, the bin contains at least one medium or small item. If the bin has no small items, removing the largest medium item reduces the load to below $1$, and together with the medium item the load is below $1.5$. If it has a small item, a similar calculation shows that the load is below $1+\varepsilon$.

The last two types of bins are benign in the sense that they allow analysis using arguments that are based on sizes. This is not the case for bins containing two big items. Such bins could have a size arbitrarily close to $2$ (even if they have no other items). Bins of this type are needed for instances with many big items (for an example we refer to the construction of the lower bound in Proposition 1). However, they cause problems not only because they are wastefully packed, but also because they exclusively contain big items that should only be moved if suitably large items arrive in order to bound migration. The basic idea of the algorithm is to balance the number of bins containing two big items and the number of bins containing one big item and no medium items. The two numbers will be roughly the same, which is obtained using migration on arrivals of big and medium items. As described in the previous paragraph, the guarantees of these bins that are based on loads cancel each other out in the sense that an average load not exceeding $1.5+\varepsilon/2$ can be achieved. In order to keep the number of bins with two big items in check, our algorithm will only produces very few bin types and we will maintain several invariants. This structured approach allows us also to bound the migration needed. We elaborate on the details of the algorithm.

Bin Types and Invariants.

We distinguish different types of bins packed by the algorithm. See Fig. 2 for an overview of covered bins (only).

The bins are partitioned into bins containing two big items (and no other items) $\mathtt{BB}$; barely covered bins containing one big item and some medium items $\mathtt{BM}$; barely covered bins containing one big item and some small items $\mathtt{BSC}$; bins that are not covered (partially covered) and contain one big item and no medium items (but it could contain small items) $\mathtt{BSP}$; and bins that are at most barely covered (they are barely-covered, or not covered) and exclusively contain small or medium items $\mathtt{S}$ or $\mathtt{M}$ respectively. Furthermore, let $\mathtt{MC}\subseteq\mathtt{M}$ and $\mathtt{SC}\subseteq\mathtt{S}$ be the corresponding subsets of barely covered bins (while $M\setminus MC$ and $S\setminus SC$ are sets of bins that are not covered). We denote the (disjoint) union of $\mathtt{BSC}$ and $\mathtt{BSP}$ as $\mathtt{BS}$. The set of bins packed by the algorithm (covered or not covered) is denoted as $\mathtt{Bins}$. All bins covered by the algorithm are in fact barely covered, and no bin (covered or not) contains items of all three classes. Among bins that are not covered, there are no bins containing a big item and a non-empty set of medium items.

We will now introduce the invariants needed. We first give a formal definition and will sometimes follow this by a mnemonic in italics to help the reader in remembering the purpose of this invariant. The first invariant the algorithm ensures that this bin structure is maintained and the second invariant was already indicated above ($A\ \dot{\cup}\ B$ denotes the disjoint union of $A$ and $B$):

1. I1

The solution has the proposed bin type structure, i. e.,

[TABLE]

and $\mathtt{BS}=\mathtt{BSC}\ \dot{\cup}\ \mathtt{BSP}$. 2. I2

The sets $\mathtt{BB}$ and $\mathtt{BS}$ are balanced in size, i. e., \big{|}|\mathtt{BB}|-|\mathtt{BS}|\big{|}\leq 1.

Recall that the average load of any bin of $\mathtt{BB}$ together with any bin of $\mathtt{BS}$ does not exceed $1.5+\varepsilon/2$, so by invariant I2 the average load of bins of $\mathtt{BB}\cup\mathtt{BS}$ possibly excluding one bin is not larger than $1.5+\varepsilon/2$.

Therefore we have $\operatorname{\text{{alg}}}(I)=|\mathtt{BB}|+|\mathtt{BM}|+|\mathtt{BSC}|+|\mathtt{MC}|+|\mathtt{SC}|$. Furthermore, we have several invariants concerning the distribution of items to different bin types. The intuition behind these invariants is always the same: We have to ensure that no other algorithm is able to use the small and medium items to cover a much large number of bins.

The big items contained in $\mathtt{BM}$ are at least as big as the ones in $\mathtt{BSC}$ which in turn are at least as big as the ones in $\mathtt{BSP}$, and the smallest big items are placed in $\mathtt{BB}$, i. e., $s(i)\geq s(i^{\prime})$ for each (i) $i\in\operatorname{big}(\mathtt{BM})$ and $i^{\prime}\in\operatorname{big}(\mathtt{BS}\cup\mathtt{BB})$; each (ii) $i\in\operatorname{big}(\mathtt{BM}\cup\mathtt{BSC})$ and $i^{\prime}\in\operatorname{big}(\mathtt{BSP}\cup\mathtt{BB})$; each (iii) $i\in\operatorname{big}(\mathtt{BM}\cup\mathtt{BS})$ and $i^{\prime}\in\operatorname{big}(\mathtt{BB})$. The smallest biggest items are in $\mathtt{BB}$ and the largest in $\mathtt{BM}$. Informally, $\mathtt{BB}\leq\mathtt{BSP}\leq\mathtt{BSC}\leq\mathtt{BM}$. 2. 4.

The union of items in $\mathtt{M}$ cannot be used to cover a bin together with a big item from $\mathtt{BS}$ or $\mathtt{BB}$, i. e., $\mathtt{BS}\cup\mathtt{BB}\neq\emptyset\implies s(\mathtt{M})<1-s_{\max}(\mathtt{BS}\cup\mathtt{BB})$. In the case $\mathtt{BS}\cup\mathtt{BB}=\emptyset$, there are no restrictions on $s(\mathtt{M})$. We can not build another $\mathtt{BM}$ bin from $\mathtt{M}$ and $\mathtt{BS}\cup\mathtt{BB}$. 3. 5.

If a bin containing only small items exists, all bins in $\mathtt{BS}$ are covered, i. e., $|\mathtt{S}|>0\implies|\mathtt{BSP}|=0$. We do not have unnecessary $\mathtt{S}$ bins in the sense that if they exist, their items cannot be used elsewhere.

Lastly, there are some bin types with bins that are not covered, and we have to ensure that they are not wastefully packed:

If there are small items in $\mathtt{BSP}$, they are all included in the bin containing the biggest item in $\mathtt{BSP}$. The next bin of $\mathtt{BSP}$ that is planned to be covered by adding small items to it is the most loaded one. 2. 7.

Each of $\mathtt{S}$ and $\mathtt{M}$ will contain at most one bin that is not covered, i. e., $|\mathtt{SC}|\geq|\mathtt{S}|-1$ and $|\mathtt{MC}|\geq|\mathtt{M}|-1$. As long as medium and small items arrive and they are packed into $\mathtt{M}$ and $\mathtt{S}$, bins of these sets are opened one by one.

This concludes the definition of all invariants. It is easy to see that the invariants all hold in the beginning when no item has arrived yet. Next, we describe the insertion procedures and argue that the invariants are maintained.

Examples.

In the following, we briefly discuss several examples to build intuition for the invariants. Figure 3 shows four exemplary packings. The first three are consistent with the invariants and the last one is not, and we first discuss the former three and then the latter.

As indicated in the captions, only the allowed bin types (invariant I1) are present in examples 1, 2, 3; and we have $|\mathtt{BB}|+1=|\mathtt{BS}|$, $|\mathtt{BB}|=|\mathtt{BS}|+1$ and $|\mathtt{BB}|=|\mathtt{BS}|$ in examples 1, 2, and 3, respectively, yielding invariant I2 for the three first examples. Concerning the distribution of big items, that is, invariant 3, note that the big items get smaller when going from left to right in each of the examples which corresponds to the correct distribution. In the first two examples, there is exactly one bin in $\mathtt{M}$ containing only one medium item, which already gives invariant 7 with respect to $\mathtt{M}$ and it is easy to see that this invariant also holds for example 3. This item is relatively big in the second example, however each big item present in the solution is too small to be combined with the medium item to form a covered bin. In the first example, the big items are bigger, but the medium item is smaller, and the same holds. Hence, invariant 4 holds, and this is also the case for example 3, where each big item is contained in $\mathtt{BM}$. Note that in the third example $\mathtt{M}$ contains multiple bins, which may only happen if $\mathtt{BS}=\mathtt{BB}=\emptyset$, due to invariant 4. In examples 2 and 3, we have $\mathtt{BSP}=\emptyset$ and hence invariants 6 and 5 trivially hold. In example 1, on the other hand, there is exactly one bin in $\mathtt{BSP}$ containing small items, and this bin also contains a big item of maximal size among the ones in $\mathtt{BSP}$, yielding 6 for this example, and we have $\mathtt{S}=\emptyset$, yielding 5. Lastly, in each of the three examples there is at most one bin in $\mathtt{S}$ which is not covered, and hence invariant 7 also holds with respect to $\mathtt{S}$.

The last example, on the other hand, is carefully designed such that all invariants are infringed or meaningless: The two bins $B_{5}$ and $B_{8}$ contain both small and medium items; and bin $B_{9}$ is overpacked (covered but not barely covered). Therefore invariant I1 is infringed. Furthermore, there are three bins containing one big and no medium items, but only one bin with two big items. This is in conflict to invariant I2. The two biggest big items are combined in bin $B_{1}$, violating invariant 3. Moreover, the bins $B_{6}$ and $B_{7}$ both are not covered, and exclusively contain medium items, which could be combined with several big items to form barely covered bins. Hence, both 7 and 4 are infringed. There are two bins in $\mathtt{BSP}$ containing small items, infringing invariant 6; and additionally $\mathtt{S}\neq\emptyset$, violating invariant 5.

Insertion Procedures.

We start with the definition of two simple auxiliary procedures used in the following:

• •

$\mathsf{GreedyPush}(i,\mathcal{B})$ is given an item $i$ and a set of bins $\mathcal{B}$. If all the bins contained in $\mathcal{B}$ are covered, it creates a new bin containing item $i$, and otherwise it inserts $i$ into the most loaded bin that is not covered.

• •

$\mathsf{GreedyPull}(B,\mathcal{B})$ is given a bin $B$ and a set of bins $\mathcal{B}$. It successively removes a largest non-big item from a least loaded bin from $\{B^{\prime}\in\mathcal{B}\,|\,\mathopen{}\operatorname{small}(B^{\prime})\cup\operatorname{medium}(B^{\prime})\neq\emptyset\}$ and inserts it into $B$. This is repeated until either $B$ is covered or $\mathcal{B}$ does not contain non-big items.

Consider one application of $\mathsf{GreedyPull}$ such that $B$ already has a big item. The total size of moved items is smaller than $1$.

Both procedures are used to insert and repack non-big items. Note that calling $\mathsf{GreedyPush}$ for a small item and bin set $\mathtt{BSP}$ or $\mathtt{S}$, or a medium item and bin set $\mathtt{M}$, the last two invariants 6 and 7 are maintained. For $\mathtt{BSP}$, the most loaded bin always contains the largest big item, and if there is at least one small item, such a bin is unique. It could happen that as a result of inserting a small item into this bin of $\mathtt{BSP}$ the bin is covered and moves to $\mathtt{BSC}$.

For each insertion procedure, we will argue that the invariants are maintained and focus on the critical ones, that is, in each context the invariants, that are not discussed explicitly, trivially hold. For example, we do not discuss I1 in the following, because it will always be easy to see that it is maintained.

Insertion of Small Items.

If the arriving item $i^{*}$ is small, we call $\mathsf{GreedyPush}(i^{*},\mathtt{BSP})$, if $\mathtt{BSP}\neq\emptyset$, and $\mathsf{GreedyPush}(i^{*},\mathtt{S})$ otherwise. Insertion into a bin of $\mathtt{BSP}$ (the most loaded one) may lead to a covered bin, in which case the bin becomes a bin of $\mathtt{BSC}$ (but remains in $\mathtt{BS}$. It is easy to verify, that all invariants, and 5, 6 and 7 in particular, are maintained by this. Furthermore, there is no migration in this case. The insertion of a medium or big item, however, is more complicated.

Insertion of Big Items.

In the case that a big item $i^{*}$ arrives, we have to be careful where we place it exactly, because, on the one hand, the distributions of big and medium items, that is, invariants 3 and 4, have to be maintained, and, on the other hand, we have to balance out $\mathtt{BS}$ and $\mathtt{BB}$ (I2). We consider placing the item in $\mathtt{BM}$, $\mathtt{BS}$ or $\mathtt{BB}$ in this order, i. e., we first try to insert $i^{*}$ into $\mathtt{BM}$, then into $\mathtt{BS}$ and finally into $\mathtt{BB}$. Figure 4 illustrates this process.

• •

Insertion into ${\mathtt{BM}}$.

We insert $i^{*}$ into $\mathtt{BM}$, if either $s(i^{*})+s(\mathtt{M})\geq 1$ or $s(i^{*})>s_{\min}(\operatorname{big}(\mathtt{BM}))$. Note that the first condition implies $s(i^{*})\geq s_{\max}(\operatorname{big}(\mathtt{BB}\cup\mathtt{BS}))$, because of 4, and therefore the insertion of $i^{*}$ into $\mathtt{BM}$ maintains 3 in both situations. The second condition implies $\mathtt{BM}\neq\emptyset$, because we set $s_{\min}(\emptyset)=+\infty$. In either of these cases, we create a new bin $B^{*}=\{i^{*}\}$ and call $\mathsf{GreedyPull}(B^{*},\mathtt{M})$, thereby ensuring that 4 is maintained if the new bin is covered. If the first condition did hold, $B^{*}$ is covered afterwards and we do nothing else. Otherwise, there is a bin $B\in\mathtt{BM}$ containing a big item $i$ with $s(i)=s_{\min}(\operatorname{big}(\mathtt{BM}))<s(i^{*})$, and we have $\mathtt{M}=\emptyset$. We remove $i$ from $B$, yielding $\mathtt{M}=\{B\}$, and call $\mathsf{GreedyPull}(B^{*},\mathtt{M})$ a second time. Afterwards, $B^{*}$ is covered, because $s(i^{*})>s(i)$. Furthermore, $s(i)+s(\mathtt{M})<1$, because $B$ was barely covered before and the biggest medium item was removed from $B$ due to the second call of $\mathsf{GreedyPull}$. The item $i$ is reinserted using a recursive call to the procedure of inserting a big item. However, item $i$ will not be considered for insertion into $\mathtt{BM}$, because neither the first nor second condition holds for this item, and the other insertion options have no recursive calls for insertion into $\mathtt{BM}$. It is easy to verify that the distribution of medium items in $\mathtt{M}$ (7) is maintained.

• •

Insertion into ${\mathtt{BS}}$.

This step is possible for item $i^{*}$ that satisfies $s(i^{*})+s(\mathtt{M})<1$ and $s(i^{*})\leq s_{\min}(\operatorname{big}(\mathtt{BM}))$. Thus, $\mathtt{BM}$ will have the largest big items as required in Invariant 3 after the insertion is performed. In this case there is no recursive call for inserting a big item.

We insert $i^{*}$ into $\mathtt{BS}$, if either $s(i^{*})>s_{\min}(\operatorname{big}(\mathtt{BS}))$ or the following two conditions hold: $s(i^{*})\geq s_{\max}(\operatorname{big}(\mathtt{BB}))$ and $|\mathtt{BS}|\leq|\mathtt{BB}|$. Note that $s(i^{*})\geq s_{\max}(\operatorname{big}(\mathtt{BB}))$ trivially holds, if $\mathtt{BB}=\emptyset$. Inserting $i^{*}$ into $\mathtt{BS}$ under these conditions already ensures the correct distribution of big items (3) with respect to $\mathtt{BS}$ and $\mathtt{BB}$, but we still have to be careful concerning the distribution within the two subsets of $\mathtt{BS}$. The procedure is divided into three simple steps. As a first step, we create a new bin $B^{*}=\{i^{*}\}$ and call $\mathsf{GreedyPull}(B^{*},\mathtt{S})$. No matter whether $B^{*}$ is now covered or not, Invariant 5 is satisfied as either $B^{*}$ is covered and therefore $\mathtt{BSP}=\emptyset$ both before and after the call, or $B^{*}$ is not covered but now $\mathtt{S}=\emptyset$ (it is possible that both will hold). Note that all properties of the invariants are satisfied, if $B^{*}$ is already covered. In particular, Invariant 3 holds within $\mathtt{BS}$ because $\mathtt{BSP}=\emptyset$. In the remainder of the second step of the insertion into ${\mathtt{BS}}$ algorithm we deal with the case that $B^{*}$ is not covered.

Let $\mathtt{XB}$ denote the set of bins $B\in\mathtt{BS}$ that include small items as well as a big item $i$ with $s(i)<s(i^{*})$. Recall that any bin of $\mathtt{BSC}$ has at least one small item, while at most one bin of $\mathtt{BSP}$ has small items.

First, assume that $\mathtt{XB}=\emptyset$ but $B^{*}$ is not covered. There are two cases. In the first case, at least one item of $\mathtt{S}$ was moved. In this case before we started dealing with $i^{*}$, the set $\mathtt{BSP}$ was empty, and now $B^{*}$ is the unique bin of $\mathtt{BSP}$, and its big item is not larger than those of $\mathtt{BSC}$ (if the last set is not empty) so the invariants 3 and 6 are maintained. In the second case, $\mathtt{S}$ was empty, and $B^{*}$ is now a bin of $\mathtt{BSP}$ with only a big item. Since $\mathtt{XB}=\emptyset$, adding $B^{*}$ to $\mathtt{BSP}$ maintains the invariants 3 and 6. Thus, it is left to deal with the case $\mathtt{XB}\neq\emptyset$. In the remainder of the second step of the insertion into ${\mathtt{BS}}$ algorithm we deal with the case that $\mathtt{XB}$ is not empty.

As $B^{*}$ is not yet covered, we now have $\mathtt{S}=\emptyset$, and this might have been the case before the call of $\mathsf{GreedyPull}$, in particular if we had $\mathtt{BSP}\neq\emptyset$. Due to the existence of a big item that is smaller than $i^{*}$ in $\mathtt{BS}$ (such items exist in all bins of $\mathtt{XB}$), we have to be careful in order to maintain the correct distribution of big and small items inside of $\mathtt{BS}$ (3 and 6).

In the second step, we construct a set of bins $\tilde{\mathtt{B}}\subseteq\mathtt{BS}$ from which small items are removed in order to cover $B^{*}$. If $\mathtt{BSP}\cap\mathtt{XB}\neq\emptyset$, this set has exactly one bin (containing small items) by Invariant 6. If such a bin exists, we denote it by $B_{1}$. If $\mathtt{BSC}\cap\mathtt{XB}\neq\emptyset$, the set $\mathtt{BSC}$ includes a bin that contains a big item $i^{\prime}$ with $s_{\min}(\operatorname{big}(\mathtt{BSC}))=s(i^{\prime})<s(i^{*})$ and we denote one such bin (with a big item of minimum size in $\mathtt{BSC}$) by $B_{2}$. As $\mathtt{XB}\neq\emptyset$, at least one of the bins $B_{1}$ or $B_{2}$ must exist, but it can also be the case that both exist. Let $\tilde{\mathtt{B}}$ be the set of cardinality $1$ or $2$, which contains these bins. The next operation of the second step is to call $\mathsf{GreedyPull}(B^{*},\tilde{\mathtt{B}})$. It is easy to see that no matter whether $B^{*}$ is covered or not after this operation, the invariants 3 and 6 hold. Specifically, if $B_{2}$ does not exist, $B^{*}$ is not necessarily covered, but 3 and 6 hold as all big items of $\mathtt{BSC}$ are not smaller than $i^{*}$ (as every such bin has at least one small item). If $B_{2}$ exists, then $B^{*}$ keeps receiving items coming first from $B_{1}$ and then possibly also from $B_{2}$, until it is covered. As the total size of small items of $B_{2}$ is sufficient for covering $B^{*}$ since the big item of $B_{2}$ is smaller than $i^{*}$, $B^{*}$ will be covered, so all big items of $\mathtt{BSP}$ are not larger than $i^{*}$.

Lastly, we describe the third step, which is performed for all cases above, after $i^{*}$ has been inserted. The insertion of $i^{*}$ might have violated I2, that is, we now have $|\mathtt{BS}|=|\mathtt{BB}|+2$. In this case, we perform the last step, namely, we select two bins $B_{3},B_{4}\in\mathtt{BS}$ with minimal big items, merge the big items into a $\mathtt{BB}$ bin and remove and reinsert all small items from $B_{3}$ and $B_{4}$, using insertion of small items. This yields, $|\mathtt{BS}|=|\mathtt{BB}|-1$ and I2 holds.

• •

Insertion into ${\mathtt{BB}}$.

If $i^{*}$ was not inserted in any of the last steps, it is inserted into $\mathtt{BB}$. In this case, we know from the conditions above that $s(i^{*})\leq s_{\min}(\operatorname{big}(\mathtt{BS}\cup\mathtt{BM}))$, and additionally that $s(i^{*})\geq s_{\max}(\operatorname{big}(\mathtt{BB}))$ implies $|\mathtt{BS}|=|\mathtt{BB}|+1$. We consider two cases.

If $|\mathtt{BS}|=|\mathtt{BB}|+1$ (and hence $\mathtt{BS}\neq\emptyset$), we select a bin $B\in\mathtt{BS}$ with a big item of minimal size. We insert $i^{*}$ into $B$ to obtain a $\mathtt{BB}$ bin and remove and reinsert all small items from $B$. This yields $|\mathtt{BS}|=|\mathtt{BB}|-1$ and I2 holds.

If $|\mathtt{BS}|<|\mathtt{BB}|+1$, we have $s(i^{*})<s_{\max}(\operatorname{big}(\mathtt{BB}))$ (and hence $\mathtt{BB}\neq\emptyset$). In this case, we select a bin $B\in\mathtt{BB}$ with a big item $i$ of maximal size, insert $i^{*}$ into $B$, and remove and reinsert $i$. Because of its size and invariant 4, the item $i$ will be inserted into $\mathtt{BS}$. Note that in both cases invariant 3 is maintained.

Lemma 3**.**

The overall size of items migrated due to the insertion of a big item $i^{*}$ is upper bounded by $11$.

Proof.

First, note that an insertion into $\mathtt{BS}$ can not trigger the reinsertion of a big item. The insertion into $\mathtt{BB}$ can only trigger the reinsertion of a single big item into $\mathtt{BS}$ and the insertion into $\mathtt{BM}$ can only trigger the reinsertion into $\mathtt{BB}$ or $\mathtt{BS}$. Hence, each insertion of a big item can trigger at most two other insertions of big items in total and thus only move a total size of $2$ this way.

Concerning the direct reassignments:

• •

If $i^{*}$ is inserted into $\mathtt{BM}$, this may directly cause reassignments of items with size at most $3$: there may be two calls of $\mathsf{GreedyPull}$ in each of which items with overall size at most $1$ may be moved and additionally a big item with size at most $1$ may be moved.

• •

If $i^{*}$ is inserted into $\mathtt{BS}$, the corresponding bound is $5$: there may be two calls of $\mathsf{GreedyPull}$ in both of which items with overall size at most $1$ may be moved and additionally a big item with size at most $1$ and small items with overall size at most $2$ may be moved.

• •

If $i^{*}$ is inserted into $\mathtt{BB}$, the corresponding bound is $1$: either small items with overall size at most $1$ or a big item are moved.

Hence, the total size of items migrated is at most $2+3+5+1=11$.

∎

Insertion of Medium Items.

If a medium item $i^{*}$ arrives, $\mathsf{GreedyPush}(i^{*},\mathtt{M})$ is called. Afterwards, the invariant 4 may be infringed and if this happens, we have $\mathtt{BS}\cup\mathtt{BB}\neq\emptyset$ and $s(\mathtt{M})\geq 1-s_{\max}(\mathtt{BS}\cup\mathtt{BB})$, and we continue as follows. We will now describe how to pack a barely covered bin using the items from $\mathtt{M}$ and a largest big item from $\mathtt{BS}\cup\mathtt{BB}$ to maintain 4 again.

If $\mathtt{BS}=\emptyset$, I2 implies that $\mathtt{BB}$ contains a single bin $B$ including two items $i$ and $i^{\prime}$ with $s_{\max}(\mathtt{BS}\cup\mathtt{BB})=s(i)\geq s(i^{\prime})$. We remove $i^{\prime}$ from $B$, and call $\mathsf{GreedyPull}(B,\mathtt{M})$ to create a $\mathtt{BM}$ bin. Afterwards, $s(\mathtt{M})$ and $s_{\max}(\mathtt{BS}\cup\mathtt{BB})$ are at most as big as they were before $i^{*}$ arrived as the first item we pulled from $\mathtt{M}$ is at least as big as $i^{*}$, and therefore 4 holds. Furthermore $\mathtt{BS}=\mathtt{BB}=\emptyset$ and I2 still holds. Lastly, we reinsert the big item $i^{\prime}$.

If, on the other hand, $\mathtt{BS}\neq\emptyset$, the corresponding big item $i$ with $s_{\max}(\mathtt{BS}\cup\mathtt{BB})=s(i)$ is contained in a bin $B\in\mathtt{BS}$, because of 3. In this case, we remove the small items from $B$ and call $\mathsf{GreedyPull}(B,\mathtt{M})$. Afterwards 4 holds, but I2 may be infringed due to the removal of a bin from $\mathtt{BS}$, i. e., $|\mathtt{BB}|=|\mathtt{BS}|+2$. In this case, we remove the two biggest items $i_{1}$ and $i_{2}$ from the bins $B_{1},B_{2}\in\mathtt{BB}$ and if $B_{1}\neq B_{2}$ merge the two bins. This yields $|\mathtt{BB}|=|\mathtt{BS}|+1$ and I2 holds. Afterwards, we reinsert the two items $i_{1}$ and $i_{2}$, which both will be inserted in $\mathtt{BS}$ due to their sizes. No matter whether we had to rebalance $|\mathtt{BB}|$ and $|\mathtt{BS}|$ or not, we reinsert the removed small items from $B$ as a last step.

Figure 5 contains an illustration of this process.

Lemma 4**.**

The overall size of items migrated due to the insertion of a medium item $i^{*}$ is upper bounded by $27$.

Proof.

In the first case, one big item is reinserted, resulting in the migration of items with size at most $1+11=12$ (see Lemma 3). Furthermore, there is one call of $\mathsf{GreedyPull}$ moving items with overall size at most $1$. This yields a size of at most $13$.

In the second case, medium items with size at most $1$ are moved using $\mathsf{GreedyPull}$ and small items with overall size at most $1$ are moved in the last step. Furthermore, three big items may be moved and two of them may be reinserted, causing total migration of size at most $1+1+3+2\cdot 11=27$. Hence, the overall size of migrated items is upper bounded by $27$. ∎

Analysis.

The migration bound stated in Theorem 2 or more precisely $\frac{27}{\varepsilon}$ is already implied by Lemma 3 and Lemma 4, as a medium item has size above $\varepsilon$. Furthermore, it is easy to see that:

Remark 5**.**

The presented algorithm for static online bin covering has a polynomial running time.

Hence, the only thing left to show is the stated asymptotic competitive ratio:

Lemma 6**.**

The presented algorithm has an asymptotic competitive ratio of $1.5+\varepsilon$ with an additive constant of $3$.

Proof.

First, we consider the case $\mathtt{BSP}=\emptyset$ (see Figure 3, second and third). In this case, the claim holds because the bins on average have not too much excess size. More precisely, we obviously have $\operatorname{\text{{opt}}}(I)\leq s(I)$, and invariants I1 and 7 imply:

[TABLE]

Furthermore, we have $0.5|\mathtt{BB}|\leq 0.5(|\mathtt{BS}|+1)$, due to Invariant I2, and $|\mathtt{BS}|=|\mathtt{BSC}|$, as $\mathtt{BSP}=\emptyset$ holds in the case we are currently considering. Hence:

[TABLE]

A similar argument holds, if $\mathtt{BSP}\neq\emptyset$ but $\mathtt{BB}=\emptyset$. In this case, we have $|\mathtt{BSP}|=1$, because of invariant I2 and thus $\mathtt{BS}=\mathtt{BSP}$; and $\mathtt{S}=\emptyset$, because of Invariant 5. Hence:

[TABLE]

Next, we consider the case $\mathtt{BSP}\neq\emptyset$ and $\mathtt{BB}\neq\emptyset$ (see Figure 3, first example). In this case, we have $\mathtt{MC}=\emptyset$, because of Invariant 4, and $\mathtt{S}=\emptyset$, because of Invariant 5. Note that every bin of $\mathtt{BSC}\cup\mathtt{BM}$ has at least one item that is not big, since big items have sizes below $1$, and these bins are covered.

Let $\xi=s_{\max}(\mathtt{BSP})$ be the size of a big item from $\mathtt{BSP}$ with maximal size. Then all items in $\mathtt{BB}\cup\mathtt{BSP}$ are upper bounded in size by $\xi$ (3) and $\xi>0.5$. We construct a modified instance $I^{*}$ as follows:

The size of each big item with size below $\xi$ is increased to $\xi$. 2. 2.

Every big item of size larger than $\xi$ is split into a big item of size $\xi$ and a medium or small item, such that the total size of these two items is equal to the size of the original item. Let $X$ be the set of items with sizes of $\xi$, which we will call $\xi$-items in the instance after these transformations ($X$ includes also items whose sizes were $\xi$ in $I$). 3. 3.

For each bin from $\mathtt{BSC}\cup\mathtt{BM}$, select the largest item of $I$ that is not big and call it special. By increasing item sizes if necessary, change the sizes of all special items to $0.5$. Let $Y$ be the set of special items (whose sizes are now all equal to $0.5$). Let $Z$ be the set of the remaining items not belonging to $X$ or $Y$ (in the instance $I^{*}$ after the transformations, so there maybe be items that did not exist in $I$ resulting from splitting a big item).

The set of items in $I^{*}$ is just $X\cup Y\cup Z$. For the instance $I^{*}$, any bin of $\mathtt{BB}$ contains two items of $X$ (and no other items). Any bin of $\mathtt{BSP}$ has an item of $X$, and one of these bins may also have small items of $Z$, but it is not covered. Any bin of $\mathtt{BSC}\cup\mathtt{BM}$ has one item of $X$, one item of $Y$, and possibly items of $Z$. There may be one uncovered bin of $\mathtt{M}$, containing items of $Z$.

Note that $\operatorname{\text{{opt}}}(I)\leq\operatorname{\text{{opt}}}(I^{*})$, since any packing for $I$ can be used as a packing for $I^{*}$ with at least the same number of covered bins. Next, we investigate the relationship between $\operatorname{\text{{opt}}}(I^{*})$ and the packing of the algorithm for the original instance $I$. For some optimal solution for $I^{*}$ without overpacked bins (more than barely covered), let $k_{2}$, $k_{1}$ and $k_{0}$ be the sets of covered bins with $2$, $1$ and [math] items from $X\cup Y$, respectively. Then we have $\operatorname{\text{{opt}}}(I^{*})=k_{2}+k_{1}+k_{0}$ and due to counting:

[TABLE]

Since each item in $X\cup Y$ is upper bounded by $\xi$, we have:

[TABLE]

The total size of items (of $Z$ only) packed into the bin of $\mathtt{M}$ is below $1-\xi$ since $\mathtt{BSP}$ has a big item of size $\xi$ in $I$, by Invariant 4, since every item of $\mathtt{BS}\cup\mathtt{BB}$ is smaller than $1-s(M)$. For $\mathtt{BSP}$ only one bin may contain items of $Z$ by Invariant 6, and this bin has an item of size $\xi$ in $I$ (and it is not covered), so it also has items of $Z$ of total size below $1-\xi$. Consider a bin of $\mathtt{BSC}\cup\mathtt{BM}$. The total size of items excluding the special item is the same for $I$ and $I^{*}$. Since such a bin is barely covered and for $I$ it has items of one class except for the big item (small or medium), removing the special item results in a load below $1$. The total size of items of $I^{*}$ in such a bin excluding the $\xi$-item and the special item is below $1-\xi$.

Therefore, we find that

[TABLE]

Hence:

[TABLE]

In the second to last step, we again used invariant I2. ∎

3 Non-amortized Migration in the Dynamic Case

In this section we extend the result of the static case and show:

Theorem 7**.**

For each $0<\varepsilon<1$ with $1/\varepsilon\in\mathbb{Z}$, there is an algorithm $\operatorname{\text{{alg}}}$ for dynamic online bin covering with polynomial running time, an asymptotic competitive ratio of $1.5+\varepsilon$ with additive constant $\mathcal{O}(\log 1/\varepsilon)$, and a non-amortized migration factor of $\mathcal{O}(\frac{\log^{2}(1/\varepsilon)}{\varepsilon^{5}})$.

Motivation and Discussion.

It is not too hard to see that the insertion procedures for big and medium items designed for the static case can be reversed in order to deal with departures of such items. However, small items never cause migration in the static case algorithm and borrowing this approach in the dynamic case causes immediate problems: Let $N$ be some positive integer. Consider the case that $N^{2}$ items of size $1/N$ arrived and were placed into $N$ bins, covering each of them perfectly. Next, one item from each bin leaves yielding a solution without any covered bin while the optimum number of covered bins is $N-1$. Hence, a migration strategy for arbitrarily small items is needed in order to design a competitive algorithm. Now, coming up with a migration strategy to deal with the present example is rather simple, since all the items are of the same size, but in principle small items may differ in size by arbitrary multiplicative factors. That is, it is possible that when a new small item which is relatively small arrives, some of the existing small items cannot be migrated at all. Still, the case with only small items can be dealt with comparatively easily by adapting a technique that was developed for dynamic online bin packing with migration [3]. The basic idea is to sort the items non-increasingly and maintain a packing that corresponds to a partition of this sequence into barely covered bins. If an item arrives, it is inserted into the correct bin and excess items are pushed to the right, that is, to the neighboring bin containing the next items in the ordering, and this process is repeated until the packing is restored. Correspondingly, if an item departs, items are pulled in from the next bin to the right. In this process the arrival or departure of a small item can only cause movements of items that are at most as big as the original one. While this is a useful property, it obviously does not suffice to bound migration: Too many bins have to be repacked. In order to deal with this, the bins are partitioned into chains of appropriate constant length with a buffer bin at the end, which is used to interrupt the migration process. This technique is sufficient for the set of bins $\mathtt{S}$ containing only small items.

The small items are also placed together with big items in the bins of $\mathtt{BS}$ and in principle the same problem can occur here: Few items with very small overall size can leave many bins uncovered when leaving and hence we need a migration strategy and additional structure for these bins as well. Unfortunately, a straight-forward combination of the chain approach with bins containing big items fails. The main reason for this is that in order to adapt our analysis, we need to cover the bins in $\mathtt{BS}$ containing larger big items with higher priority and furthermore guarantee that there are no (or only few) bins contained in $\mathtt{S}$ if there are bins containing big items that are not covered, i. e., $\mathtt{BSP}\neq\emptyset$. It is not hard to see that spreading one sequence of chains out over the bins of $\mathtt{BS}$ and $\mathtt{S}$ will not suffice.

To overcome these problems, we developed a new technique: We partition the bins of $\mathtt{BS}$ into few, that is, $\mathcal{O}(\log 1/\varepsilon)$ many, groups. Each of the groups is in turn partitioned into parallel chains of length $\mathcal{O}(1/\varepsilon)$. The groups are defined such that they comply with a non-increasing ordering of both the big and the small items: the first group contains the largest big and small items, the next group the remaining largest, and so on. Similarly, the big or small items contained in a bin of a single parallel chain are at most as big as the ones in the predecessor bin of that chain. However, no such structure is maintained in between the parallel chains of the same group. Now, whenever a buffer bin of a parallel chain becomes empty or overfilled, items are pushed or pulled directly into or out of the next group. This may spark a recursive reaction, but since there are only few groups overall the total migration can be bounded. Furthermore, we are able to guarantee (i) that there is at most one group $\mathtt{G}$ containing uncovered bins, and that all groups before are covered. Finally, if $\mathtt{S}\neq\emptyset$, we can guarantee (ii) that all bins of $\mathtt{BS}$ are barely covered. Properties (i) and (ii) are the essential properties we need in order to adapt our approach to the dynamic case.

The buffer bins of the parallel chains act as the interface between one group and another, and therefore have a special role in this construction. We require that the buffer bins of the same group have some special properties, e. g., that they can exchange items among each other without migration cost. To guarantee these properties, we simulate the buffer bins of chains belonging to a fixed group using one group buffer bin. Hence, all chains within the same group share the same buffer bin. Because of their special role in the procedure, these group buffer bins are considered as a separate class, denoted by $\mathtt{GB}$. These bins exclusively contain small items but may be overpacked, that is, unlike any other bin in the construction they may be covered but not barely covered. To avoid confusion, we slightly alter the definition of $\mathtt{S}$, excluding the group buffer bins regardless of whether they are at most barely covered or not. Furthermore, we require the bins of $\mathtt{BSC}$ to comply with a more restricted notion of being barely covered: bins of this type need to be well-covered. A bin $B$ is called well-covered, if it is barely covered and additionally has the following property: If $s_{\max}(\operatorname{big}(B))+s_{\max}(B\setminus\operatorname{big}(B))\geq 1$, then $|B|\leq 2$. In particular, consider the situation that $B$ contains one big item and more than one small item. As $B$ is barely covered, removing the largest small item from $B$ makes it not covered. But $B$ is also well-covered, hence removing all of the small items but the largest one will also leave $B$ not covered. We call a bin $B$ more than well-covered, if one can remove a subset of items in $B$ to make $B$ well-covered and at most well-covered, if one can add a (possibly empty) set of items to $B$ to make it well-covered.

The Algorithm.

In the following, we will describe in detail the additional structure needed to deal with the small items along with the insertion procedures for small items. We first describe the chain structure used for $\mathtt{S}$ and then the group structure used for $\mathtt{BS}$. Next, we discuss the insertion and deletion procedures of medium and big items. The main challenge here is to properly deal with the insertion and deletion of big items in $\mathtt{BS}$, because these can interfere with the group structure. Lastly, we will argue that the migration, competitive ratio and running time of the overall algorithm is properly bounded. In order to do so we will, in the course of this section, again introduce invariants and argue that they are maintained by the algorithm. Indeed, some of the invariants can be transferred directly or with only small changes from the static case:

1. I1

The solution has the proposed bin type structure, i. e., $\mathtt{Bins}=\mathtt{BB}\ \dot{\cup}\ \mathtt{BM}\ \dot{\cup}\ \mathtt{BS}\ \dot{\cup}\ \mathtt{M}\ \dot{\cup}\ \mathtt{S}\ \dot{\cup}\ \mathtt{GB}$ and $\mathtt{BS}=\mathtt{BSC}\ \dot{\cup}\ \mathtt{BSP}$. 2. I2

The sets $\mathtt{BB}$ and $\mathtt{BS}$ are balanced in size, i. e., \big{|}|\mathtt{BB}|-|\mathtt{BS}|\big{|}\leq 1. 3. I3

The big items contained in $\mathtt{BM}$ are at least as big as the ones in $\mathtt{BS}$ which in turn are at least as big as the ones in $\mathtt{BB}$, i. e., $s(i)\geq s(i^{\prime})$ for each $i\in\operatorname{big}(\mathtt{BM})$ and $i^{\prime}\in\operatorname{big}(\mathtt{BS}\cup\mathtt{BB})$; or $i\in\operatorname{big}(\mathtt{BM}\cup\mathtt{BS})$ and $i^{\prime}\in\operatorname{big}(\mathtt{BB})$. 4. I4

The items in $\mathtt{M}$ cannot be used to cover a bin together with a big item from $\mathtt{BS}$ or $\mathtt{BB}$, i. e., $\mathtt{BS}\cup\mathtt{BB}\neq\emptyset\implies s(\mathtt{M})<1-s_{\max}(\mathtt{BS}\cup\mathtt{BB})$. 5. I5

If there is a bin which only contains small items and is not a group buffer bin, then all bins in $\mathtt{BS}$ are covered, i. e., $|\mathtt{S}|>0\implies|\mathtt{BSP}|=0$. 6. I6

The set $\mathtt{M}$ contains at most one bin that is not covered.

In the following, we slightly change our notions of bins, that is, we allow empty bins. Until now, we assumed that a bin ceases to exist as soon as it becomes empty. In the following, however, there are some situations in which empty bins are maintained by the algorithm. This will be made clear in each case. Furthermore, without loss of generality we assume that $1/\varepsilon$ is an integer.

3.1 Chains

Preliminaries.

We formally define a chain as a totally ordered finite set of bins, where each bin contains at most one big item and no medium items, such that the following conditions are fulfilled. The ordering of the chain $\mathtt{C}$ is consistent with a non-increasing ordering of the small items contained in $\mathtt{C}$, that is, for bins $B,B^{\prime}\in\mathtt{C}$ and small items $i\in B$ and $i^{\prime}\in B^{\prime}$, we have $s(i)\geq s(i^{\prime})$, if $B$ precedes $B^{\prime}$ in $\mathtt{C}$. Furthermore, the corresponding condition for big items holds as well, and if there is a bin $B$ in $\mathtt{C}$ containing no big item, then the successors of $B$ contain no big items as well.

Let $\mathtt{C}$ be a chain, $B\in\mathtt{C}$, and $X$ a set of small items. We say that $X$ is eligible for $\mathtt{C}$ and $B$, if $\mathtt{C}$ remains a chain after $X$ is inserted into $B$. Furthermore, we denote the $j$-th bin in the ordering of $\mathtt{C}$ as $B(\mathtt{C},j)$. We define two basic operations on chains, which are recursive procedures. Intuitively, $\mathsf{ChainPush}(X,B)$ puts a set of small items $X$ into bin $B$ and pushes the now superfluous small items to the next bin. In contrast, $\mathsf{ChainPull}(B)$ pulls small items from these next bins to cover $B$. More formally, these operations behave as follows:

• •

$\mathsf{ChainPush}(X,B,\mathtt{C})$ is given a chain $\mathtt{C}$, a bin $B\in\mathtt{C}$, and a set $X$ of small items eligible for $\mathtt{C}$ and $B$. The set of items $X$ is inserted into $B$. If $B$ is now overpacked, that is, more than well-covered, we repeatedly remove a smallest small item from $B$ until $B$ is well-covered and call the set of removed items $X^{\prime}$. If $B$ is the last bin in the chain, the set $X^{\prime}$ is returned. Otherwise there is a successor $B^{\prime}$ of $B$ and $\mathsf{ChainPush}(X^{\prime},B^{\prime},\mathtt{C})$ is called.

• •

$\mathsf{ChainPull}(B,\mathtt{C})$ is given a chain $\mathtt{C}$ and a bin $B\in\mathtt{C}$. If $B$ is not covered and not the last bin in the chain, we repeatedly move the biggest small item from $B^{\prime}$ to $B$, where $B^{\prime}$ is the successor of $B$ in $\mathtt{C}$, until either $B$ becomes well-covered or $B^{\prime}$ does not contain small items anymore. Afterwards $\mathsf{ChainPull}(B^{\prime},\mathtt{C})$ is called.

Remember that a bin $B$ is called well-covered, if it is barely covered and additionally we have that $s_{\max}(\operatorname{big}(B))+s_{\max}(B\setminus\operatorname{big}(B))\geq 1$ implies $|B|\leq 2$. Note that in both procedures the inputs of the recursive calls are legal, e.g., when $\mathsf{ChainPush}(X^{\prime},B^{\prime},\mathtt{C})$ or $\mathsf{ChainPull}(B^{\prime},\mathtt{C})$ are called, $\mathtt{C}$ is still a chain, $B^{\prime}\in\mathtt{C}$, and $X^{\prime}$ is eligible for $\mathtt{C}$ and $B^{\prime}$. This immediately yields:

Remark 8**.**

After a call of $\mathsf{ChainPush}(X,B,\mathtt{C})$ or $\mathsf{ChainPull}(B,\mathtt{C})$, the set $\mathtt{C}$ remains a chain.

If $Y$ is the set of items moved away from a bin $B$ due to a call of $\mathsf{ChainPush}$, we say that $Y$ was pushed out of $B$ and moreover, if $Y$ is pushed out of the last bin of the chain, we say that it was pushed out of the chain. Correspondingly, if $Y$ was moved away from a bin $B$ due to a call of $\mathsf{ChainPull}$, we say that $Y$ was pulled out of $B$. Our next goal is to formulate and prove some easy technical results concerning these operations. These results will be among the main tools for bounding the migration due to the small items. We consider $\mathsf{ChainPush}$ first and $\mathsf{ChainPull}$ second.

Lemma 9**.**

Let $\mathtt{C}$ be a chain, $B\in\mathtt{C}$ be at most well-covered, and $X$ be a set of small items eligible for $\mathtt{C}$ and $B$ such that $X\cup\operatorname{big}(B)$ forms a bin that is at most well-covered. Furthermore, assume that $s_{\min}(X)\geq s_{\max}(\operatorname{small}(B))$ or $|X|=1$. Finally, let $Y\neq\emptyset$ be the set of items that are pushed out of $B$, due to a call of $\mathsf{ChainPush}(X,B,\mathtt{C})$. Then $B$ is well-covered after the call and we have:

$Y\cup\operatorname{big}(B)$* forms a bin that is at most well-covered.* 2. 2.

$s_{\max}(X)\geq s_{\max}(Y)$. 3. 3.

$s(Y)\leq s(X)+s_{\max}(X)$. 4. 4.

If $B$ has a direct successor $B^{\prime}$ in $\mathtt{C}$, then $Y$ is eligible for $\mathtt{C}$ and $B^{\prime}$ and $s_{\min}(Y)\geq s_{\max}(\operatorname{small}(B^{\prime}))$ (before the recursive call of $\mathsf{ChainPush}(Y,B^{\prime},\mathtt{C})$).

Proof.

Note that $B$ is well-covered, as $Y\neq\emptyset$. We now distinguish two cases, namely $s_{\min}(X)\geq s_{\max}(\operatorname{small}(B))$ and $s_{\min}(X)<s_{\max}(\operatorname{small}(B))$. In the first case, note that no item belonging to $X$ will be pushed out of $B$, or, more precisely: if $Y^{\prime}$ is the subset of $X$ that is pushed out, there is a set $Z$ of items remaining in $B$ that does not belong to $X$ and that is equivalent to $Y^{\prime}$ in the sense that there exists a bijection between the two, mapping items of equal size onto each other. Therefore, $Y\cup\operatorname{big}(B)$ is at most well-covered, because $B$ was at most well-covered. In the second case, we have $s_{\min}(X)<s_{\max}(\operatorname{small}(B))$ and hence $|X|=1$ by assumption. Let $X=\{i^{*}\}$. Note that the items that are pushed out of $B$ each have size at most $s(i^{*})$, and there can be at most one item with size $s(i^{*})$ in $Y$ because $B$ was at most well-covered before $i^{*}$ was inserted. Hence $Y\cup\operatorname{big}(B)$ is at most well-covered, because replacing the item with size $s(i^{*})$ from $Y$ — if it exists — with the biggest item from $\operatorname{small}(B)$, yields a set of items completely contained in $B$ before the call to $\mathsf{ChainPush}$. The above considerations also show $s_{\max}(X)\geq s_{\max}(Y)$.

Since $B$ was at most well-covered, removing the smallest items from $B$ with overall size $s(X)$ after $X$ was inserted will suffice to make it at most well-covered again. The exact value $s(X)$ may not be met and therefore one extra item may be needed whose size is bounded by $s_{\max}(X)$, due to the already established property that $s_{\max}(X)\geq s_{\max}(Y)$. Note that these considerations also hold, if $B$ was well-covered with only one small item, or $|X|=1$ and $X\cup\operatorname{big}(B)$ is well-covered. This implies the third point and the fourth holds, because the smallest items are pushed out of $B$ and $\mathtt{C}$ is a chain. ∎

Lemma 10**.**

Let $\mathtt{C}$ be a chain, $B\in\mathtt{C}$ a bin that is not covered and not the last bin in $\mathtt{C}$, and $B^{\prime}$ its successor. Furthermore, let $Y$ be the set of items that are pulled out of $B^{\prime}$ due to a call of $\mathsf{ChainPull}(B,\mathtt{C})$. We have:

$Y\subseteq\operatorname{small}(B)$. 2. 2.

$B$* is well-covered after the call, if $B^{\prime}$ was well-covered.* 3. 3.

$s(Y)\leq(1-s(B))+s_{\max}(\operatorname{small}(B^{\prime}))$.

Proof.

The first assertion follows directly from the definition of $\mathsf{ChainPull}$. Note that $\operatorname{small}(B^{\prime})\cup\operatorname{big}(B)$ forms a covered bin due to the definition of chains, if $B^{\prime}$ was well-covered. This together with the definition of $\mathsf{ChainPull}$ implies the second assertion and this also holds if $|\operatorname{small}(B^{\prime})|=1$. Furthermore, it suffices to pull items with size $(1-s(B))$ out of $B^{\prime}$ in order to cover $B$. However, the exact value $(1-s(B))$ may not be met and therefore one extra item may be needed whose size is bounded by $s_{\max}(\operatorname{small}(B^{\prime}))$ and this proves the last claim. ∎

Sequential Chains.

We maintain a partition of $\mathtt{S}$ into sequential chains $\mathtt{SCh}_{1}$, …, $\mathtt{SCh}_{C}$ with $|\mathtt{SCh}_{c}|\in[(1/\varepsilon+1),(2/\varepsilon+1)]$ for $c<C$ and $|\mathtt{SCh}_{C}|\leq 2/\varepsilon+2$. Herein, the exact value of $C$ depends on the instance. The last bin of each chain is its buffer bin. See Figure 6 for an illustration.

We require that all bins that are not buffer bins are well-covered. Buffer bins, on the other hand, are non-empty and at most well-covered. The set of buffer bins is denoted by $\mathtt{SB}$. These properties are summarized in the following invariant:

$\mathtt{S}$ has the described chain structure, in particular, $\mathtt{S}\setminus\mathtt{SC}\subseteq\mathtt{SB}$ and $|\mathtt{SB}|\leq\varepsilon|\mathtt{SC}|+1$.

The distribution of small items in $\mathtt{S}$ is already limited by our definition of chains. However, we will require an even stronger property such that all of the orderings of the small items are consistent with each other:

The non-increasing ordering of the small items in $\mathtt{S}$ by size is consistent with both the ordering of the chains and their internal ordering.

More precisely, due to this invariant for each item $i\in B(\mathtt{SCh}_{c},j)$ and $i^{\prime}\in B(\mathtt{SCh}_{c^{\prime}},j^{\prime})$, we have $s(i)\geq s(i^{\prime})$, if $(c,j)$ is lexicographically smaller than $(c^{\prime},j^{\prime})$. We next describe the insertion and deletion of a small item $i^{*}$ into $\mathtt{S}$ maintaining these invariants.

Insertion.

We describe the insertion of a set of small items $X$ into $\mathtt{S}$ in two insertion scenarios: In scenario 1, a new item $i^{*}$ was inserted into the instance, that is, $X=\{i^{*}\}$, and in scenario 2, a set of items $X$ with $s(X)\leq 1$ and $s_{\min}(X)\geq s_{\max}(\mathtt{S})$ was moved from $\mathtt{BS}$ to $\mathtt{S}$. In both scenarios, we treat the case $\mathtt{S}=\emptyset$ as if there was exactly one chain with one bin, which is empty. In scenario 1, we select the first bin $B$ (with respect to the ordering of the chains and their internal ordering) containing items that are smaller than $i^{*}$, or the last bin if no such bin exists. Let $\mathtt{C}$ be the chain $B$ is contained in. In scenario 2, $\mathtt{C}$ is the first chain and $B$ its first bin. In both cases, we call $\mathsf{ChainPush}(X,B,\mathtt{C})$. Due to the choice of $B$, Remark 8 and a simple inductive application of Lemma 9, we can conclude that the ordering of the small items is maintained (invariant 8) and each non-buffer bin in $\mathtt{C}$ remains well-covered (7). Let $Y$ be the set of items that are pushed out of $\mathtt{C}$. If $Y\neq\emptyset$, we know that the buffer bin $B^{\prime}$ of $\mathtt{C}$ is now well-covered, due to Lemma 9, and furthermore $Y$ forms a bin that is at most well-covered, again due to Lemma 9. Hence, we turn the buffer bin into a regular bin and declare $Y$ the new buffer bin of $\mathtt{C}$. If $\mathtt{C}$ now has length $2/\varepsilon+2$, we split it evenly into two chains each of which contains $\frac{1}{\varepsilon}+1$ bins and declare the last bin of the first chain its buffer bin. This yields two chains with length $1/\varepsilon+1$, thereby maintaining invariant 7. An example of this insertion is illustrated in Figure 7.

Remark 11**.**

The overall size of migrated items due to the insertion of $X$ into $\mathtt{S}$ is at most $\mathcal{O}(1/\varepsilon^{2})s(X)$, and therefore $\mathcal{O}(1/\varepsilon^{2})s(i^{*})$ in scenario 1.

Proof.

Let $X_{k}$ be the $k$-th set pushed out of a bin due to the call of $\mathsf{ChainPush}$. A simple inductive application of assertions (2) and (3) of Lemma 9 yields that $s(X_{k})\leq s(X)+ks_{\max}(X)\leq(k+1)s(X)$. There are at most $2/\varepsilon+2$ bins in the chain, and hence the overall size of migrated items is at most $(2/\varepsilon+2)(2/\varepsilon+2)s(X)=\mathcal{O}(1/\varepsilon^{2})s(X)$. ∎

Deletion.

Next, we consider the case that $i^{*}$ is deleted from a bin $B$ belonging to chain $\mathtt{C}$ (that is a part of $S$). If $B$ is still well-covered or a buffer bin, we do nothing. Hence, we design a procedure to deal with the case that a non-buffer bin $B$ has become not covered. Similar to the insertion case, this procedure will work regardless of whether $B$ is not covered because $i^{*}$ was deleted, or because some set of small items has been removed from $B$ to be placed in another group of bins. We call $\mathsf{ChainPull}(B,\mathtt{C})$. Since the invariants 7 and 8 did hold before and due to Remark 8 and a simple inductive application of Lemma 10, we know that the ordering of the small items is maintained (invariant 8) and each non-buffer bin in $\mathtt{C}$ except for the bin $B^{*}$ directly preceding the buffer remains well-covered. If $B^{*}$ is well-covered as well, the chain structure (invariant 7) is maintained, and we do nothing else. Otherwise, the old buffer bin of $\mathtt{C}$ is deleted and $B^{*}$ becomes the new buffer bin, which is not a problem, if $|\mathtt{C}|\geq 1/\varepsilon+1$ or $\mathtt{C}$ is the last chain. Hence, we consider the case that $|\mathtt{C}|=1/\varepsilon$ and there is a direct successor chain $\mathtt{C}^{\prime}$ of $\mathtt{C}$. If $|\mathtt{C}^{\prime}|>1/\varepsilon+1$ the first bin of $\mathtt{C}^{\prime}$ is removed from this chain and declared the new buffer bin of $\mathtt{C}$, and otherwise $\mathtt{C}$ and $\mathtt{C}^{\prime}$ are concatenated and we call the resulting chain again $\mathtt{C}$. In both cases, we call $\mathsf{ChainPull}(B^{*},\mathtt{C})$, and the invariants 8 and 7 hold afterwards (and this call to $\mathsf{ChainPull}$ will not result in the need to concatenate two chains).

Remark 12**.**

The overall size of migrated items is at most $\mathcal{O}(1/\varepsilon)(1-s(B))+\mathcal{O}(1/\varepsilon^{2})\psi$, where $\psi$ is the maximum size of a small item in any bin succeeding $B$. In particular, if $i^{*}$ was deleted from $B$ this amounts to $\mathcal{O}(1/\varepsilon^{2})s(i^{*})$.

Proof.

Let $X_{k}$ be the $k$-th set pulled out of a bin due to one of the at most two calls of $\mathsf{ChainPull}$. Note that there can be at most $2/\varepsilon+1$ such bins. A simple inductive application of assertion (3) of Lemma 10 yields that $s(X_{k})\leq(1-s(B))+ks_{\max}(B^{\prime})$. In the case that an item $i^{*}$ was deleted from $B$, we additionally have $(1-s(B))\leq s(i^{*})$ and $s_{\max}(B^{\prime})\leq s(i^{*})$. ∎

3.2 Groups

We maintain a partition of $\mathtt{BS}$ into groups $\mathtt{Gr}_{1}$, …, $\mathtt{Gr}_{G}$ with $|\mathtt{Gr}_{g}|=2^{g-1}\lceil\varepsilon|\mathtt{BS}|\rceil$ for $g<G$ and $|\mathtt{Gr}_{G}|\leq 2^{G-1}\lceil\varepsilon|\mathtt{BS}|\rceil$. Note that $|\mathtt{Gr}_{g}|\leq\lceil\varepsilon|\mathtt{BS}|\rceil+\sum_{g^{\prime}=1}^{g-1}|\mathtt{Gr}_{g^{\prime}}|$ for each $g\in[G]$ and $G\leq\log(1/\varepsilon)+2$. These properties are summarized in the following invariant:

$\mathtt{BS}$ has the described group structure.

Furthermore, it will be useful in the following to consider the bins $\mathtt{S}$ containing exclusively small items as the last group, that is, $\mathtt{S}=\mathtt{Gr}_{G+1}$. Each group $\mathtt{Gr}_{g}$, for $g\leq G$, is in turn partitioned into $C_{g}=\lceil\varepsilon|\mathtt{Gr}_{g}|\rceil$ sets such that each of these sets has cardinality $1/\varepsilon$ except for the last which may be smaller. For each of these sets there is a buffer bin and the set of these buffer bins is called $\mathtt{BGr}_{g}$. As mentioned above, these buffer bins have a special role that will be described in more detail below. The sets together with their buffer bins form parallel chains, and since all the bins of such a chain are contained in the corresponding group, we sometimes say that the parallel chains are contained in or part of their respective group. See Figure 8 for an illustration.

Each bin in a parallel chain is at most well-covered. The well-covered bins are all placed in a sequence at the start of the chain, and there can be at most one bin of the chain containing small items that is not covered, and this bin is positioned directly following the last well-covered bin of the chain. Note that this implies $|\{B\in\bigcup_{g\in[G]}\mathtt{BGr}_{g}\,|\,\mathopen{}\operatorname{small}(B)\neq\emptyset\}|\leq\varepsilon|\mathtt{BSC}|+G$. Again, we summarize:

Each group has the described internal parallel chain structure.

Note that due to the definition of chains, the above invariant also restricts the internal distribution of big and small items in each group. With the next two invariants, we control the distribution of big and small items between the different groups.

The ordering of the groups (including $\mathtt{S}=\mathtt{Gr}_{G+1}$) is consistent with a non-increasing ordering of both the big and the small items. 2. 12.

There is a group-index $g^{*}\in[G+1]$ such that each bin in each group preceding $\mathtt{Gr}_{g^{*}}$ is well-covered and each succeeding group does not contain small items. *Small items will always be used to create well-covered bins. *

More precisely, the former invariant together with 10 yields the following. Let $i\in B(\mathtt{C},j)$ and $i^{\prime}\in B(\mathtt{C}^{\prime},j^{\prime})$, where $\mathtt{C}$ and $\mathtt{C}^{\prime}$ are (parallel or sequential) chains belonging to group $\mathtt{Gr}_{g}$ and $\mathtt{Gr}_{g^{\prime}}$ respectively and $i,i^{\prime}$ belong to a common class (either both are big or both are small). Then $g<g^{\prime}$, implies $s(i)\geq s(i^{\prime})$ and the same holds, if $\mathtt{C}=\mathtt{C}^{\prime}$ and $j<j^{\prime}$. Furthermore, due to the latter invariant, in some sense, there is always exactly one group being filled with or emptied of small items (i. e., the group of index $g^{*}$ of invariant 12). Next, we discuss the buffer bins of parallel chains in more detail.

Group Buffer Bins.

If we can always maintain the group structure and the chain structures described above, we are able to guarantee an asymptotic competitive ratio of $3/2+\varepsilon$. Unfortunately, maintaining this structure will be rather complicated. Firstly, the buffer bins of parallel chains behave very different from other bins. In order to have a notion of well-covered buffer bins, we assume that the buffer bin of each parallel chain contains a virtual big item that is of the same size as the big item in the second to last bin of the chain. This virtual big item will only be used in the theoretical analysis.

Furthermore, in a parallel chain setting, each chain by itself is ordered with regards to the small and big items. But the distribution of item sizes of chains within the same group might be very complicated. For example, we might want to add a small item into a chain $\mathtt{C}_{1}$ in group $\mathtt{Gr}_{g}$. This will trigger a push of small items along this chain and might remove some small items $Y$ from the buffer bin of $\mathtt{C}_{1}$. The natural approach would be to try to insert these items into the subsequent group $\mathtt{Gr}_{g+1}$, but there might be another chain $\mathtt{C}_{2}$ in group $\mathtt{Gr}_{g}$ that contains items smaller than those in $Y$. Hence, we first would need to insert the items of $Y$ into $\mathtt{C}_{2}$, triggering even more repacking. To prevent this cascade of repacking, we observe that the smallest small items in $\mathtt{Gr}_{g}$ must be contained in the buffer bins. Now, if we push small items along $\mathtt{C}_{1}$, we will first rearrange the small items in the buffer bins such that the buffer bin of $\mathtt{C}_{1}$ contains only the smallest items. In this way, we can indeed push the removed items $Y$ to $\mathtt{Gr}_{g+1}$. To simplify this rearrangement of small items in buffer bins, we will make the following two assumptions that may seem counter-intuitive at first glance: Firstly, the buffer bins of the same group are allowed to exchange items without migration costs; and secondly, items may be split between buffer bins of the same group, with part of an item placed in one buffer bin and the other part in another.

We justify these assumptions as well as the virtual big items, by simulating these bins using one group buffer bin for each group $\mathtt{Gr}_{g}$ (as indicated in Figure 8). All the small items from the buffer bins of $\mathtt{Gr}_{g}$ are in fact placed in the group buffer bin of $g$ and the buffer bins of the chains are only virtually maintained by the algorithm. Clearly, splitting items and moving them without cost does not pose a problem anymore, as all of these items are placed on the same bin and do not leave it. The set of group buffer bins is denoted by $\mathtt{GB}$. Note that we do neither consider the (virtual) buffer bins of the parallel chains to be a part of $\mathtt{BS}$, nor the actual group buffer bins to be a part of $\mathtt{S}$.

Let $B$ be the buffer bin of a parallel chain $\mathtt{C}$. If an item is placed fractionally in $B$ this item is at most as big as any other item placed in a preceding bin of the chain. Furthermore, if $B$ contains small item pieces, we guarantee that there is a small item $i$ fully contained in $B$ with the property that $i$ is at least as big as any other small item for which item pieces are placed in $B$. Due to this property, the definition of well-covered can be extended to the buffer bins quite naturally: the bin $B$ is called well-covered, if (i) it is covered, if (ii) the small item pieces together with the virtual big item but excluding $i$, cannot cover a bin where $i$ is a largest small item fully contained in $B$, and if (iii) the virtual big item and $i$ together can cover a bin, then there is no other small item piece placed in $B$.

The buffer bins of each group and the corresponding group buffer bin have the described structure.

If $\mathsf{ChainPush}$ is called on the parallel chain $\mathtt{C}$, fractional item pieces may be pushed out of $\mathtt{C}$. When this case occurs, we will carefully redistribute the item pieces in the buffer bins of the group, or remove the full item from the group. The operation $\mathsf{ChainPull}$, on the other hand, could pull fractional items further into the chain and we would like to avoid that also. However, as described above, we guarantee that the biggest small item in the buffer bin $B$ is fully placed in it. Hence, it should be pulled first. Afterwards, if $B$ still contains small item pieces, we simply choose a small item $i^{\prime}$ with maximal size that is at least fractionally placed on $B$, and pull all pieces of $i^{\prime}$ onto $B$. Since we only move item pieces from other buffer bins of the group, no additional migration costs occur.

Insertion.

When a small item $i^{*}$ arrives, we have to be careful to maintain the described structure when inserting it. In particular, we have to maintain the parallel chain structure in each group (invariant 10) and the correct distribution of small items (11 and 12). For the group structure (9) and the other invariants, it will be easy to see that they are maintained.

The first step is to choose the appropriate group $\mathtt{Gr}_{g}$ depending on the size of $i^{*}$ and with respect to the correct distribution of the small items (11 and 12). More precisely, $\mathtt{Gr}_{g}$ is either (i) the first group containing an item that is smaller than $i^{*}$ if such a group exists; or (ii) the last group containing small items, if that group is the last group or contains a bin that is not covered; or (iii) the group directly after the last group containing small items, otherwise.

Instead of describing the insertion of $i^{*}$ into $\mathtt{Gr}_{g}$, we take a slightly more general approach and consider two scenarios, where a set $X$ of small items has to be inserted into $\mathtt{Gr}_{g}$, similar to the insertion into $\mathtt{S}$. We do so, because the insertion procedure works recursively. In scenario 1 we have $X=\{i^{*}\}$, and in scenario 2 all items in $X$ are at least as big as any small item in $\mathtt{Gr}_{g}$, and adding a big item from $\mathtt{Gr}_{g}$ to $X$ forms a bin that is at most well covered. For the case $g=G+1$ we already discussed the same scenarios and refer to the section on sequential chains. Hence we assume $g<G+1$.

We distinguish two cases in the following depending on the existence of bins without any small items. If $\mathtt{Gr}_{g}$ contains a chain $\mathtt{C}$ that includes a bin without any small item, the procedure is rather easy: we choose an appropriate bin $B$ with respect to the parallel chain structure (10 and 12). More precisely, in scenario 1, we choose the first bin containing an item that is smaller than $i^{*}$ if such a bin exists; and otherwise the first bin that is not covered and is either the first bin of the chain or has a well-covered predecessor. In scenario 2, we simply pick the first bin of the chain. We perform $\mathsf{ChainPush}(X,B,\mathtt{C})$. Remark 8 and an easy inductive application of Lemma 9 yield that no items are pushed out of $\mathtt{C}$ and all invariants are maintained.

On the other hand, if each bin in $\mathtt{Gr}_{g}$ contains small items, only the buffer bins may not be covered. This complicates the maintenance of our invariants.

We pick a chain $\mathtt{C}$ with the property that the size of a largest small item contained in its buffer bin is minimal. This chain has the property that each small item placed in its buffer bin could also be placed in any other buffer bin of the group without violation of the ordering of small items in the chain (10). Again, we choose an appropriate bin $B$ with respect to the parallel chain structure, that is, the first bin in scenario 2, or in scenario 1 the first bin containing an item that is smaller than $i^{*}$ if such a bin exists, or the last bin of the chain. We call $\mathsf{ChainPush}(X,B,\mathtt{C})$ and denote the set of items pushed out of $\mathtt{C}$ as $Y$.

If $Y=\emptyset$, the insertion procedure is now complete and all invariants hold (see above). Hence, we consider the case $Y\neq\emptyset$. Note that $Y$ may contain the biggest small item previously placed in the buffer bin of $\mathtt{C}$. However, in this case all items now contained in the buffer bin are not fractional and hence, the new biggest item is neither. In any case, invariant 13 is maintained. Ideally, we would like to simply insert $Y$ into the next group $\mathtt{Gr}_{g+1}$, but the structure of $Y$ might be unsuited to do so without violating our invariants. We will thus construct a more suitable set $Z$ from $Y$ and $\mathtt{BGr}_{g}$ and insert this set into $\mathtt{Gr}_{g+1}$. The remaining items $Y^{\prime}=Y\setminus Z$ will be placed on the buffer bins of $\mathtt{Gr}_{g}$.

More formally, let $Z\subseteq\operatorname{small}(\mathtt{BGr}_{g}\cup Y)$ be a set of small items constructed greedily by choosing the smallest available item and putting it into $Z$ until $s(Z)\geq s(Y)$. Ties are broken in favor of items (fractionally) contained in $Y$. Clearly, we have $s(Z)-s_{\max}(Z)<s(Y)$ and $s_{\max}(Z)\leq s_{\min}(Y\setminus Z)$. We remove all items or item pieces belonging to $Z$ from $Y$ and $\mathtt{Gr}_{g}$ and define $Y^{\prime}=Y\setminus Z$. Note, that in this process of creating $Z$, no buffer bin can become empty, because no item that is the biggest small item of a buffer bin can be included in $Z$ due to the choice of chain $\mathtt{C}$. Hence, invariant 13 is maintained. Next, we place the items and item pieces from $Y^{\prime}$ onto buffer bins of $\mathtt{Gr}_{g}$: If a piece of an item $i\in Z$ was previously placed on a buffer bin $B$, we can imagine that removing it left a gap. As $s(Z)\geq s(Y)$, the space $s(Z\cap\mathtt{BGr}_{g})$ freed up by constructing $Z$ is at least $s(Y^{\prime})$. Hence, we can place the items from $Y^{\prime}$ fractionally into these gaps. Note that at this point all invariants hold and $Z$ contains items that are appropriate for the insertion in $\mathtt{Gr}_{g+1}$ with respect to the distribution of small items in the groups (invariant 11). As a last step, we split $Z$ into two sets $Z_{1}$ and $Z_{2}$ such that their insertion into $\mathtt{Gr}_{g+1}$ is consistent with scenario 2. The sets are defined as follows. Let $q$ be the size of the biggest item piece contained in $Y$. The first set $Z_{1}$ is chosen such that $s(Z_{1})\geq q$, $s(Z_{1})-s_{\min}(Z_{1})<q$, and $s_{\min}(Z_{1})\geq s_{\max}(Z\setminus Z_{1})$ (with $s_{\max}(\emptyset)=0$). We set $Z_{2}=Z\setminus Z_{1}$ and first insert $Z_{2}$ and then $Z_{1}$.

Lemma 13**.**

Inserting $Z_{1}$ and $Z_{2}$ into $\mathtt{Gr}_{g+1}$ is consistent with scenario 2, and this includes the case $g=G$.

Proof.

For the case $g=G$ note that $s(Z_{1})\leq 2\varepsilon\leq 1$ and $s(Z_{2})<s(Y)\leq 1$ which is sufficient for scenario 2 in this case. We assume $g<G$ in the following and consider two cases. Let $i$ be the biggest item (fractionally) contained in $Y$.

In the first case, we assume that $i$ is big enough to cover a bin together with the biggest (big) item $b$ contained in $\mathtt{Gr}_{g+1}$. Note that due to invariant 11 the big items contained in $\mathtt{Gr}_{g}$ are at least as big as $b$. Since the buffer bin $B^{\prime}$ of chain $\mathtt{C}$ was at most well-covered, this implies that $Y=\{i\}$. Remember that we choose the chain $\mathtt{C}$ in a way such that the size of the largest small item, call it $i^{\prime}$, in its buffer bin $B^{\prime}$ is minimal. As $Y=\{i\}$, either $i$ is this largest small item $i^{\prime}$ placed on $B^{\prime}$ before the push, or scenario 1 applies and $i=i^{*}$ was just inserted into the instance. In both cases we have $s(i)\leq s(i^{\prime})$. Due to our choice of $\mathtt{C}$, any largest small item contained in a buffer bin of $\mathtt{Gr}_{g}$ is large enough to cover a bin together with any big item contained in $\mathtt{Gr}_{g}$. Therefore, each buffer bin contains exactly one small item and that item is at least as big as $i$. This in turn implies that $Z=Y=\{i\}$, $Z_{1}=Z$ and $Z_{2}=\emptyset$, yielding the assertion in this case.

In the second case, $i$ is not big enough to cover a bin together with $b$. Hence, $Z_{1}$ fits the requirements. Furthermore, note that $Z_{2}$ is at most as big as $Y$ minus the biggest item piece contained in that set. This implies that $Z_{2}$ is suitably small as well: either $Y$ was fully contained in the buffer bin before (yielding the assertion), or scenario 1 applies and $i^{*}\in Y$. In the latter case, $i^{*}$ has to be the biggest item (and item piece) contained in $Y$ and an item that is bigger than $i^{*}$ remains in the buffer bin $B^{\prime}$ of $\mathtt{C}$. Hence, $Z_{2}$ is also suitably small. ∎

Lemma 14**.**

The overall size of items that are migrated due to the insertion of a small item $i^{*}$ is $\mathcal{O}((1/\varepsilon^{3})\cdot\log^{2}(1/\varepsilon))s(i^{*})$.

Proof.

Let $X_{0}=\{i^{*}\}$ and $g_{0}$ be the index of the group $i^{*}$ is inserted to. For the case $g_{0}=G+1$, we refer to Remark 11 that already guarantees the claimed bound. Hence, we assume $g_{0}\leq G$. Furthermore, let $g_{k}=g_{0}+k$ for $k\in\{1,\dots,G+1-g_{0}\}$ and $X_{k}$ be a set of items that is (recursively) inserted into $\mathtt{Gr}_{g_{k}}$. Note that at most $2^{k}$ sets are inserted into $\mathtt{Gr}_{g_{k}}$ for each $k\in\{0,\dots,G+1-g_{0}\}$ (due to the insertion of both parts of $Z$) and $k\leq G+1\leq\log(1/\varepsilon)+3$ (invariant 9).

We first consider $\mathtt{Gr}_{g_{0}}$. When $X_{0}$ is inserted into this group, $\mathsf{ChainPush}$ is called exactly once (not counting recursive calls). Let $X_{0,r}$ be the $r$-th set pushed out of a bin due to this call. A simple inductive application of Lemma 9 yields that $s(X_{0,r})\leq s(X_{0})+rs_{\max}(X_{0})=(r+1)s(i^{*})$. The corresponding chain has length at most $1/\varepsilon+1$. Hence, the overall size of items moved in this group due to the insertion of $X_{0}$ is at most $\mathcal{O}(1/\varepsilon^{2})s(i^{*})$. Let $Z_{1}$ and $Z_{2}$ be the sets that are inserted into the next group. Considering the choice of these sets and the lengths of the parallel chains, we have $s(Z_{1})+s(Z_{2})\leq(1/\varepsilon+3)s(i^{*})$, and therefore this upper bound holds for both sets independently. This proves the base case of the inductive claim that $s(X_{k})\leq(1+k(1/\varepsilon+2))s(i^{*})$. The claim for $k$ holds by noting that $s_{\max}(X_{k})\leq s(i^{*})$ (using 11), and that the chain to which $X_{k}$ is inserted has at most $\frac{1}{\varepsilon}+1$ bins (including the buffer bin).

Furthermore, the overall size of migrated items in group $\mathtt{Gr}_{g_{k}}$ due to the insertion of $X_{k}$ is at most $(1/\varepsilon+1)(1+k(1/\varepsilon+2)+1/\varepsilon+1)s(i^{*})=\mathcal{O}((1/\varepsilon^{2})\cdot\log(1/\varepsilon))s(i^{*})$ and this bound also holds for $k=G+1-g_{0}$ (see Remark 11). Hence, the overall size of migrated items is bounded by $(G+1)2^{G+1}\mathcal{O}((1/\varepsilon^{2})\cdot\log(1/\varepsilon))s(i^{*})=\mathcal{O}((1/\varepsilon^{3})\cdot\log^{2}(1/\varepsilon))s(i^{*})$. ∎

Deletion.

We now consider the case that a small item $i^{*}$ is deleted. Like in the case of insertion, we have to be careful to maintain the parallel chain structure in each group (invariant 10) and the correct distribution of small items (11 and 12). Let $i^{*}$ be removed from a bin $B^{*}$ positioned in a chain $\mathtt{C}^{*}$ in a group $\mathtt{Gr}_{g}$. We already considered the case $g=G+1$ and hence assume $g\leq G$. There are several cases in which we do nothing: If (i) $B^{*}$ is still well-covered; or if (ii) $B^{*}$ is a buffer bin; or if (iii) we have $g<G+1$ and $\mathtt{Gr}_{g}$ is the last group containing small items and $B^{*}$ was the last bin in $\mathtt{C}^{*}$ that contained small items. In these cases, it is easy to see that the group structure and all invariants are maintained. For the steps that we take otherwise, we again take a slightly more general approach, because they are recursive in nature, and because they will also be useful when considering big and medium items.

A gap bin $B$ is a bin that is part of the group structure belonging to some parallel or sequential chain and should be covered with respect to the invariants 10, 12 and 8, but (due to repacking) is currently not. More precisely, $B$ is not a buffer bin, and there are small items positioned in subsequent bins, which may either be part of the same parallel or sequential chain, or may be part of a subsequent group or sequential chain. Furthermore, we call a gap bin maximal, if there are no gap bins among the subsequent bins. In the following, we design a procedure $\mathsf{GapFill}(B)$ used to repair such a maximal gap bin $B$. It may be called recursively in situations in which there are more gap bins and therefore the parallel chain structure (invariant 10) and the correct distribution of small items (12) may not hold. However, we can guarantee that for each initial (non-recursive) call of $\mathsf{GapFill}(B)$, the bin $B$ will be the only gap bin, and we will guarantee that there are no gap bins left after the call (including all recursive calls). Now, it is easy to see that the bin $B^{*}$ is indeed a maximal gap bin and we will handle the remaining cases by a call of $\mathsf{GapFill}(B^{*})$.

Let $B$ be a maximal gap bin positioned in a chain $\mathtt{C}$ in a group $\mathtt{Gr}_{g}$. First, we discuss the special case $g=G+1$. In the section on chains, we already designed a procedure for the case that a non-buffer bin $B$ becomes not covered, that is, in the scenario discussed there, we have only a single (maximal) gap bin in the group. In all application scenarios of $\mathsf{GapFill}$ in the last group, this will actually be enough, but it is also very easy to see that the described procedure will work for any maximal gap bin, the only difference being that invariant 7 may not hold because of other gap bins that might be present.

From now on, we assume $g<G+1$. As a first step, we call $\mathsf{ChainPull}(B,\mathtt{C})$. Afterwards, $\mathtt{C}$ remains a chain, and $B$ as well as each bin which was followed by a well-covered bin before is well-covered (see Remark 8 and Lemma 10). Hence, if $g$ is the last group containing small items, or the second to last bin $B^{\prime}$ in $\mathtt{C}$ remains well-covered, we do nothing else, because all invariants hold (except for gap bins which may be present in preceding groups or a parallel chain). Otherwise, $B^{\prime}$ is not covered, but all bins between $B$ and $B^{\prime}$ are well-covered. In this case, we repeatedly move the largest small item from the subsequent group $\mathtt{Gr}_{g+1}$ to $B^{\prime}$ until either $\mathtt{Gr}_{g+1}$ does not contain small items anymore or $B^{\prime}$ becomes well-covered. Afterwards, each bin in the chain $\mathtt{C}$ starting from $B$ has the correct structure with respect to the correct distribution of small items (invariants 11 and 12). Note that, if there is a small item in $\mathtt{Gr}_{g+1}$ that can cover a bin together with the big item from $B^{\prime}$, than the same holds for the biggest small item from $\mathtt{Gr}_{g+1}$ and $B^{\prime}$ did not contain small items before, because these would be even bigger (due to 11) and cover the bin. Hence, in that case only one item would be pulled from $\mathtt{Gr}_{g+1}$ and it would be the only small item in $B^{\prime}$ afterwards. Furthermore, note that at most one bin from $\mathtt{Gr}_{g+1}$ can lose all of its small items in the above process, if it was well-covered to begin with, and if this happens, all the pulled items were pulled from this very bin (due to the distribution of big items 11). Therefore, each small item that was pulled from $\mathtt{Gr}_{g+1}$ was previously contained in the first bin of a chain.

If we stopped pulling items from $\mathtt{Gr}_{g+1}$ because it did not contain small items anymore, we do nothing else, because then $\mathtt{Gr}_{g}$ has become the last group containing small items, and $B^{\prime}$ does not have to be covered with respect to invariant 12. Hence, we consider the case that $\mathtt{Gr}_{g+1}$ still contains small items. By pulling the items from $\mathtt{Gr}_{g+1}$, we might have created multiple maximal gap bins. We now could consider each such bin individually to recurse, but in order to have bounded migration, we need to guarantee that only a constant number of maximal gap bins, namely four, have to be considered. We will achieve this by moving items within the first bins of the chains of $\mathtt{Gr}_{g+1}$ such that at most four gap bins remain.

To this end, we first consider the case that $\mathtt{Gr}_{g+2}$ does also contain small items, i. e., $\mathtt{Gr}_{g+1}$ is not the last group containing small items. Let $\mathtt{Fst}$ be the set of first bins in chains belonging to $\mathtt{Gr}_{g+1}$. We may assume that $\mathtt{Fst}$ contains more than four bins that are not well-covered because otherwise there is nothing to do. In this case, each of the bins in $\mathtt{Fst}$ still contains at least one small item and no small item in the group can cover a bin together with the biggest big item in the group (see considerations above). We pick a set $\mathtt{F}\subseteq\mathtt{Fst}$ with $|\mathtt{F}|=4$ and the property that a smallest small item contained in a bin belonging to $\mathtt{F}$ is at least as big as a smallest small item from a bin belonging to $\mathtt{Fst}\setminus\mathtt{F}$, i. e., $s_{\min}(\operatorname{small}(\mathtt{F}))\geq s_{\min}(\operatorname{small}(\mathtt{Fst}\setminus\mathtt{F}))$. Due to that choice, any small item from $\mathtt{F}$ can be moved to any bin from $\mathtt{Fst}\setminus\mathtt{F}$ without violating the ordering of the small items (Invariant 10). We now repeatedly pick a bin from $\mathtt{F}$ with maximal load and move a biggest small item from that bin to a bin $\mathtt{Fst}\setminus\mathtt{F}$ that is not covered. By this process each bin can receive items whose size is at most twice as big as the items that were pulled from this bin. Furthermore, for each bin $B^{\prime\prime}$ contained in $\mathtt{F}$, the overall size of small items contained in $B^{\prime\prime}$ before small items were pulled to $\mathtt{Gr}_{g}$ was at least half as big as the overall size of items that were pulled. This is due to the distribution of big items (invariant 11) and due to the fact that there was no small item in $\mathtt{Gr}_{g+1}$ big enough to cover a bin together with the big item from $B^{\prime}$ in this case (see considerations above). Hence, each bin in $\mathtt{Fst}\setminus\mathtt{F}$ can be covered by this process and we can recurse on the remaining at most four gap bins in $\mathtt{F}$.

If, on the other hand, $\mathtt{Gr}_{g+1}$ is the last group containing small items there are two cases. In the case that $g<G$, we can use the same approach as before with one difference. In this case there can be bins that are positioned at the start of the chain but do not need to be covered, because there are no small items in any subsequent bin of the chain. Hence, we can simply exclude these bins in the considerations. Lastly, if $g=G$, we do not have parallel chains in $\mathtt{Gr}_{g+1}=\mathtt{S}$ and all items have been pulled from the same bin. In any case, for each maximal gap bin $B^{\prime\prime}$ in $\mathtt{Gr}_{g+1}$ we call $\mathsf{GapFill}(B^{\prime\prime})$.

Note that the call of $\mathsf{GapFill}(B)$ repairs the gap bin $B$ as well as all created gap bins via recursive calls. Hence, after the call of $\mathsf{GapFill}(B^{*})$ in the deletion procedure all invariants and the correct distribution of small items (11 and 12) in particular hold.

Lemma 15**.**

Let $B$ be a maximal gap bin. The overall size of items that are migrated due to a call of $\mathsf{GapFill}(B)$ is at most $\mathcal{O}((1/\varepsilon^{3})\cdot\log^{2}(1/\varepsilon))$. Furthermore, the migration due to the deletion of an item $i^{*}$ is bounded by $\mathcal{O}((1/\varepsilon^{4})\cdot\log^{2}(1/\varepsilon))s(i^{*})$.

Proof.

The initial call of $\mathsf{GapFill}(B)$ may cause several recursive calls in later groups. Let $B^{*}$ be a maximal gap bin for which such a call occurs, and $\mathtt{C}^{*}$ its chain, $\mathtt{Gr}_{g^{*}}$ its group, $\varphi^{*}=(1-s(B^{*}))$ be its free space (at the time of the call), and $\psi^{*}$ be the maximal size of a small item in any subsequent bin. We first consider the case $g^{*}<G+1$. The call of $\mathsf{GapFill}(B^{*})$ results in a call of $\mathsf{ChainPull}$. Let $X_{r}$ be the $r$-th set pulled out of a bin due to this call. A simple inductive application of Lemma 10 yields that $s(X_{r})\leq(1-s(B^{*}))+r\psi^{*}$, and we have $r\leq 1/\varepsilon$. Hence, the overall size of items pulled from the last non-buffer bin $B^{\prime}$ of $\mathtt{C}^{*}$ is at most $(1-s(B^{*}))+\psi^{*}/\varepsilon$, and the overall size of items migrated due to the call of $\mathsf{ChainPull}$ is at most $1/\varepsilon((1-s(B^{*}))+\psi^{*}/\varepsilon)$. In the next step, items may be pulled to $B^{\prime}$ from the next group, and because of the above observation their size is as well upper bounded by $(1-s(B^{*}))+\psi^{*}/\varepsilon+\psi^{*}$. This in turn implies, that the repacking that may be caused in the next group in order to bound the number of emerging gap bins is upper bounded by $\mathcal{O}((1-s(B^{*}))+\psi^{*}/\varepsilon)$. After this repacking, at most $4$ maximal gap bins remain in the next group. It is easy to see that for each of these gap bins $B^{\prime\prime}$ we have $(1-s(B^{\prime\prime}))\leq(1-s(B^{*}))+\psi^{*}/\varepsilon+\psi^{*}$ as well. Summing up, the migration directly caused by the call of $\mathsf{GapFill}(B^{*})$ (excluding recursive calls) is bounded by $\mathcal{O}(1/\varepsilon((1-s(B^{*}))+\psi^{*}/\varepsilon))$. Due to Remark 12 this bounds also holds for the case $g^{*}=G+1$.

Now, let $g_{0}$ be the index of the group $B$ is positioned in, and $g_{0}+K$ the last group in which a (recursive) call of $\mathsf{GapFill}$ occurs. Furthermore, let $g_{k}=g_{0}+k$ for $k\in\{0,\dots,K\}$, $B_{k}$ a maximal gap bin created in $\mathtt{Gr}_{g_{k}}$, and $\psi_{k}$ the maximal size of a small item in any subsequent bin. Note that at most $4^{k}\leq 4^{G}$ such gap bins are created in $\mathtt{Gr}_{g_{k}}$ for $k\leq G$ and the bound of $4^{G}$ also holds for the last group. Clearly, we have $B_{0}=B$ and we set $\psi=\psi_{0}$. The observations above yield that the migration directly caused by the call of $\mathsf{GapFill}(B_{k})$ is at most

[TABLE]

because $\psi_{r}\leq\psi$ for each $r\in\{0,\dots,K\}$ (due to invariant 11) and $K\leq G$. Therefore the overall migration can be bounded by:

[TABLE]

In the case that an item $i^{*}$ is deleted, we have $(1-s(B))\leq s(i^{*})$ and $\psi\leq s(i^{*})$, yielding the proposed bound for that case. ∎

3.3 Big and Medium Items

To deal with the arrival or departure of big and medium items, we mainly use the ideas developed in the static case. However, changing bins belonging to $\mathtt{BS}$ is now much more complicated because we have to be careful to maintain the group and chain structure (invariants 9 and following). For example, removing a big item and its bin from $\mathtt{BS}$ will decrement the size of the corresponding group and possibly $\lceil\varepsilon|\mathtt{BS}|\rceil$. Furthermore, the corresponding parallel chain may become too short.

In this section, we first design some auxiliary procedures to carefully manipulate the group structure. Utilizing these, we next describe the deletion and insertion procedures of big items, and lastly the procedures for medium items. The latter are much simpler but may involve the insertion or deletion of big items from $\mathtt{BS}$ and hence are dealt with in the end.

Preliminaries.

We introduce a series of auxiliary procedures used for small local changes in the groups maintaining their internal structure. These procedures use $\mathsf{GapFill}$ and the insertion procedure for small items as subroutines, and are used in situations in which the group structure (invariant 9) may be slightly disturbed. In particular, the sizes of the groups may be different and $G$ – the total number of groups – may be disturbed by some additive constant. It is easy to see that this is not a problem regarding the analysis of $\mathsf{GapFill}$ and the insertion procedure for small items, because the sizes of the groups do not influence and are not influenced by these procedures; and a change to $G$ by some additive constant merely results in some additional constant factor in the analysis of their migration. Furthermore, $\mathtt{BS}$ and $\mathtt{BB}$ may not be balanced (invariant I2) before or after the call of one of the auxiliary procedures. This will be handled, when they are used.

• •

$\mathsf{GroupInsert}(i,\mathtt{Gr}_{g})$ is called to insert a big item $i$ into a group $\mathtt{Gr}_{g}$ with $g<G+1$. To do so, we create a new bin $B$ containing $i$. There are two cases. If $\mathtt{Gr}_{g}$ contains a parallel chain $\mathtt{C}$ with length smaller than $1/\varepsilon+1$, bin $B$ is inserted into $\mathtt{C}$ at a position that maintains the correct distribution of big items in the chain (invariant 10). More precisely, right before the buffer bin, if all big items in $\mathtt{C}$ are at least as big as $i$, or right in front of the first bin containing a big item that is smaller than $i$. If $B$ was inserted right in front of the buffer bin, we adjust the size of the virtual big item placed in the buffer bin of $\mathtt{C}$ to be $s(i)$, thereby maintaining invariant 13. Otherwise, a new parallel chain is created in $\mathtt{Gr}_{g}$ containing only $B$ and a buffer bin whose virtual big item has size $s(i)$. Lastly, $B$ now may be a maximal gap bin and we call $\mathsf{GapFill}(B)$ in this case. Afterwards, the parallel chain structure (invariant 10), as well as the correct distribution of small items (12) are guaranteed.

• •

$\mathsf{GroupDelete}(B,\mathtt{Gr}_{g})$ is used to repair the internal structure of a group $\mathtt{Gr}_{g}$ with $g<G+1$ after the big item of a bin $B$ positioned in $\mathtt{Gr}_{g}$ was removed. Let $\mathtt{C}$ be the parallel chain $B$ is positioned in. We remove all small items from $B$ and delete the bin. Next, we remove all small items from the buffer bin of $\mathtt{C}$. If $\mathtt{C}$ now has length one, we delete the chain, and if additionally $\mathtt{Gr}_{g}$ has become empty, we also delete the group. Otherwise, we consider two cases: If $\mathtt{C}$ is the only chain with length smaller than $1/\varepsilon+1$, we adjust the size of the virtual big item in its buffer to be the same as the size of the big item in its direct predecessor, thereby maintaining invariant 13. In the second case there is another chain $\mathtt{C}^{\prime}$ with length smaller $1/\varepsilon+1$ and hence $\mathtt{C}$ has length $1/\varepsilon$ (due to 10). We remove the last non-buffer bin $B^{\prime}$ from $\mathtt{C}^{\prime}$, and remove all small items from $B^{\prime}$ and the buffer bin of $\mathtt{C}^{\prime}$. Then, we insert $B^{\prime}$ into $\mathtt{C}$ at the position maintaining the correct distribution of big items (10). If $B^{\prime}$ was inserted right in front of the buffer bin, we adjust the size of the virtual big item placed in the buffer of $\mathtt{C}$ (maintaining 13). If $\mathtt{C}^{\prime}$ now has length $1$, we delete it, and otherwise we adjust the size of the corresponding virtual big item in its buffer bin as well, again maintaining 10 and 13. Now $B^{\prime}$ may be a maximal gap bin and we call $\mathsf{GapFill}(B^{\prime})$ in this case. Lastly, we reinsert all small items that have been removed. Note that afterwards the parallel chain structure (invariant 10), as well as the correct distribution of small items (12) are guaranteed.

• •

$\mathsf{GroupPush}(\mathtt{Gr}_{g})$ is used to decrement the size of a group $\mathtt{Gr}_{g}$, with $g\leq G$, by pushing a big item of minimal size to the next group. We select a non-buffer bin $B$ from $\mathtt{Gr}_{g}$ containing a big item $i$ of minimal size, remove $i$ from $B$, and call $\mathsf{GroupDelete}(B,\mathtt{Gr}_{g})$. If $g<G$, we then call $\mathsf{GroupInsert}(i,\mathtt{Gr}_{g+1})$. Otherwise, we create a new group belonging to $\mathtt{BS}$ with only one parallel chain. The chain has two bins, namely a bin containing only $i$ and a buffer bin whose virtual item has size $s(i)$.

• •

$\mathsf{GroupPull}(\mathtt{Gr}_{g})$ is used to increment the size of a group $\mathtt{Gr}_{g}$, with $g<G$, by pulling a big item of maximal size from the next group. We select a bin $B$ from $\mathtt{Gr}_{g+1}$ containing a big item $i$ of maximal size, remove $i$ from $B$, call $\mathsf{GroupDelete}(B,\mathtt{Gr}_{g+1})$, and then $\mathsf{GroupInsert}(i,\mathtt{Gr}_{g})$.

Lemma 16**.**

The overall size of items migrated due to a call of one of the auxiliary procedures above is at most $\mathcal{O}((1/\varepsilon^{3})\cdot\log^{2}(1/\varepsilon))$.

Proof.

In both $\mathsf{GroupDelete}$ and $\mathsf{GroupInsert}$ at most one big item and small items with overall size of at most $4$ are removed. The small items are reinserted causing migration of at most $\mathcal{O}((1/\varepsilon^{3})\cdot\log^{2}(1/\varepsilon))$ (see Lemma 14), and there is a call of $\mathsf{GapFill}$ yielding the same bound (see Lemma 15). Both in $\mathsf{GroupPush}$ and $\mathsf{GroupPull}$ one big item is moved and the other two auxiliary procedures are called once. ∎

Deletion of Big Items.

When a big item $i^{*}$ is deleted, there are three cases we have to consider based on the bin $B^{*}$ that item $i^{*}$ was positioned in. Firstly, if $B^{*}\in\mathtt{BM}$, we simply delete the bin and reinsert the corresponding medium items starting with the largest one. Next, if $B^{*}\in\mathtt{BB}$, we have to be a bit more careful in order to keep the sets $\mathtt{BS}$ and $\mathtt{BB}$ balanced (invariant I2). If $|\mathtt{BB}|\geq|\mathtt{BS}|$ did hold before, we select a bin $B\in\mathtt{BB}$ containing a big item $i$ of maximal size (with a preference for $B^{*}$ itself), replace $i$ with the remaining item from $B^{*}$, and reinsert $i$ (thereby deleting $B^{*}$). If, on the other hand, $|\mathtt{BB}|=|\mathtt{BS}|-1$ did hold, we select a big item $i$ of minimal size from $\mathtt{BS}$ and move it to $B^{*}$. Afterwards, I2 holds, but the removal of $i$ from $\mathtt{BS}$ may have violated several invariants concerning the structure of $\mathtt{BS}$. To deal with this, we use the deletion procedure for the third case $B^{*}\in\mathtt{BS}$, which is by far the most complicated and described in the following.

Let $\mathtt{Gr}_{g}$ be the group $B^{*}$ is positioned in. We perform $\mathsf{GroupDelete}(B^{*},\mathtt{Gr}_{g})$. Now, $|\mathtt{Gr}_{g}|$ is decreased by one and $\lceil\varepsilon|\mathtt{BS}|\rceil$ may have decreased by one. We first deal with the former and then consider the latter. In particular, if $g<G$, we iteratively perform $\mathsf{GroupPull}(\mathtt{Gr}_{g^{\prime}})$ for one group after another with $g^{\prime}=g,\dots,G-1$. Afterwards, $G$ may have been decreased by one and we have $|\mathtt{Gr}_{g}|=2^{g-1}\lceil\varepsilon(|\mathtt{BS}|+1)\rceil$ for $g<G$ and $|\mathtt{Gr}_{G}|\leq 2^{G-1}\lceil\varepsilon(|\mathtt{BS}|+1)\rceil$. If $\lceil\varepsilon(|\mathtt{BS}|+1)\rceil=\lceil\varepsilon|\mathtt{BS}|\rceil$ the group structure, that is, 9, again holds. Otherwise, there are $2^{g-1}$ too many bins positioned in group $\mathtt{Gr}_{g}$ for $g<G$ and up to $2^{G-1}$ too many in $\mathtt{Gr}_{G}$. Hence, for each $g^{\prime}\in[G-1]$, we perform $\sum_{r=1}^{g^{\prime}}2^{r-1}=2^{g^{\prime}}-1$ many calls of $\mathsf{GroupPush}(\mathtt{Gr}_{g^{\prime}})$. Afterwards, there are $\ell\leq 2^{G}-1$ too many bins in $\mathtt{Gr}_{G}$ and we perform $\ell$ calls of $\mathsf{GroupPush}(\mathtt{Gr}_{G})$, thereby creating up to one additional group. The last step is to rebalance $\mathtt{BS}$ and $\mathtt{BB}$, if necessary, that is, if $|\mathtt{BS}|=|\mathtt{BB}|-2$, we select a bin $B\in\mathtt{BB}$ containing a big item of maximal size. If necessary, we switch the second item in $B$ such that the big items in $B$ are as big as any other in $\mathtt{BB}$. Then we delete $B$ and reinsert the big items. These big items will be inserted into $\mathtt{BS}$ but will not incur further recursive calls for insertion or deletion of big items.

Insertion of Big Items.

The steps that we take, when a big item $i^{*}$ has to be inserted in the dynamic case are very similar to the static case: We consider inserting $i^{*}$ into $\mathtt{BM}$, $\mathtt{BS}$ and $\mathtt{BB}$ in this order and based on the same conditions. The insertion for $\mathtt{BM}$ works exactly as in the static case and the one for $\mathtt{BB}$ is changed only slightly. In particular, there are two cases considered in the procedure, namely $|\mathtt{BS}|=|\mathtt{BB}|+1$ and $|\mathtt{BS}|<|\mathtt{BB}|+1$. In the former, a bin $B\in\mathtt{BS}$ is selected containing a big item $i$ of minimal size, and this item $i$ is used to form a new bin together with $i^{*}$. The only change to the procedure is that we deal with the removal of $i$ from $\mathtt{BS}$ using the deletion procedure for big items. We now describe how to insert $i^{*}$ into $\mathtt{BS}$.

When $i^{*}$ is to be inserted into $\mathtt{BS}$ we first select the correct group $\mathtt{Gr}_{g}$ with respect to the distribution of big items (invariant 11), that is, $g=G$ if $i^{*}$ is at most as big as any other big item in $\mathtt{BS}$, or the first group containing a big item smaller than $i^{*}$ otherwise. We call $\mathsf{GroupInsert}(i^{*},\mathtt{Gr}_{g})$. Now, $|\mathtt{Gr}_{g}|$ is increased by one and $\lceil\varepsilon|\mathtt{BS}|\rceil$ may have increased by one, that is, invariant 9 may not hold. We first deal with the former and then consider the latter. In particular, we iteratively call $\mathsf{GroupPush}(\mathtt{Gr}_{g^{\prime}})$ for one group after another with $g^{\prime}=g,\dots,G-1$. Furthermore, if the last group was of full size, that is $|\mathtt{Gr}_{G}|=2^{G-1}\lceil\varepsilon|\mathtt{BS}|\rceil$ before the above operations, we also call $\mathsf{GroupPush}(\mathtt{Gr}_{G})$. Afterwards, $G$ may have been increased by one and we have $|\mathtt{Gr}_{g}|=2^{g-1}\lceil\varepsilon(|\mathtt{BS}|-1)\rceil$ for $g<G$ and $|\mathtt{Gr}_{G}|\leq 2^{G-1}\lceil\varepsilon(|\mathtt{BS}|-1)\rceil$. Hence, if $\lceil\varepsilon(|\mathtt{BS}|-1)\rceil=\lceil\varepsilon|\mathtt{BS}|\rceil$ the group structure(9) again holds. Otherwise, there are $2^{g-1}$ bins too few positioned in group $\mathtt{Gr}_{g}$ for $g<G$.For each $g^{\prime}\in[G-2]$, we perform $\sum_{r=1}^{g^{\prime}}2^{r-1}=2^{g^{\prime}}-1$ many calls of $\mathsf{GroupPull}(\mathtt{Gr}_{g^{\prime}})$. Furthermore, if $G>1$, we perform $\min\{2^{G-1}-1,|\mathtt{Gr}_{G}|\}$ many calls of $\mathsf{GroupPull}(\mathtt{Gr}_{G-1})$, thereby possibly deleting the last group. Lastly, the insertion of $i^{*}$ might have violated I2, that is, we now have $|\mathtt{BS}|=|\mathtt{BB}|+2$. In this case, we select a big item $i$ from $\mathtt{BB}$ and create a bin containing two dummy items of the same size as $i$. Afterwards I2 and all other invariants hold. We then delete the two dummy items one after another using the deletion procedures described above.

Medium items.

Dealing with medium items in the dynamic case is not a big problem, because we can essentially use the same ideas as in the static case. In fact, we have to make only one small adjustment to the insertion procedure in the static case: When the arriving medium item has been inserted into $\mathtt{M}$ and we have the situation that $s(\mathtt{M})\geq 1-s_{\max}(\mathtt{BS}\cup\mathtt{BB})$ and $\mathtt{BS}\neq\emptyset$, then a big item $i$ is to be removed from $\mathtt{BS}$. We handle this as follows: We replace $i$ by a dummy item of the same size, form a new bin $B$ containing $i$ and call $\mathsf{GreedyPull}(B,\mathtt{M})$. Afterwards I4 holds. Then we delete the big dummy item and call the corresponding deletion procedure.

When a medium item $i^{*}$ is deleted from its bin $B^{*}$, we distinguish a few cases. If $B^{*}$ remains barely covered, we do nothing. Otherwise, if $B^{*}\in\mathtt{M}$, we delete the bin and reinsert all the medium items. Note that these items will simply be reinserted into $\mathtt{M}$ via $\mathsf{GreedyPush}$ and cause no further migration, because of invariant I4. Lastly if $B^{*}\in\mathtt{BM}$, we call $\mathsf{GreedyPull}(B^{*},\mathtt{M})$. If $B^{*}$ is barely covered afterwards, we do nothing else. Otherwise, $\mathtt{M}=\emptyset$ and we remove the big item $i$ from $B^{*}$ (yielding $\mathtt{M}=\{B^{*}\}$), and reinsert $i$. Note that in this case $i$ will not be inserted into $\mathtt{BM}$.

Lemma 17**.**

The overall size of items that are migrated due to the insertion or deletion of a big or medium item $i^{*}$ is $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$.

Proof.

We consider the same cases as above and in the same order.

If $i^{*}$ is big and deleted from a bin $B^{*}\in\mathtt{BM}$, then medium items with size at most $1$ are reinserted. Because the largest item is reinserted first and because of invariants I4 and I3, only one of these items can trigger further migration and all others will be inserted into $\mathtt{M}$. Hence, we get the same migration as for medium items plus some constant.

If $B^{*}\in\mathtt{BB}$, the deletion may cause a reinsertion of a big item, or the deletion of a big item positioned in $\mathtt{BS}$, as well as $\mathcal{O}(1)$ further migration. In the first case, the corresponding big item will be inserted into $\mathtt{BS}$, because of its size, and because of the considered case, the insertion cannot cause further deletions of big items. Similarly, in the second case, the deletion cannot cause further insertions of big items. Hence, the migration is given by the migration for insertions or deletions of big items into $\mathtt{BS}$ plus some constant.

If $B^{*}\in\mathtt{BS}$ we may perform one call of $\mathsf{GroupDelete}$, $\mathcal{O}(G)=\mathcal{O}(\log(1/\varepsilon))$ calls of $\mathsf{GroupPull}$, $2^{G+\mathcal{O}(1)}=\mathcal{O}(1/\varepsilon)$ calls of $\mathsf{GroupPush}$ and some additional constant migration. Furthermore, there may be two big items that are reinserted. Because of the choice of the items and invariant I3, they are inserted into $\mathtt{BS}$, and because of the corresponding case no deletions of big items are caused by these insertions. Hence, the migration in this case is at most $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$ (see Lemma 16) plus the migration due to the possible insertions of big items.

We consider the case that $i^{*}$ is big and has to be inserted. As described in Lemma 3 inserting a big item into $\mathtt{BM}$ may directly cause $\mathcal{O}(1)$ migration, and the insertion of a big item into $\mathtt{BS}$ or $\mathtt{BB}$. Furthermore, the insertion of $i^{*}$ into $\mathtt{BB}$ may cause $\mathcal{O}(1)$ migration and either a deletion of a big item from $\mathtt{BS}$ or the reinsertion of a big item, which will be placed into $\mathtt{BS}$. In both cases this causes no further insertions or deletions of big items. Hence, in both cases the migration is essentially given by the migration for the insertion or deletion of a big item into $\mathtt{BS}$.

If a big item $i^{*}$ is inserted into $\mathtt{BS}$, we may perform one call of $\mathsf{GroupInsert}$, $\mathcal{O}(G)=\mathcal{O}(\log(1/\varepsilon))$ calls of $\mathsf{GroupPush}$, $2^{G+\mathcal{O}(1)}=\mathcal{O}(1/\varepsilon)$ calls of $\mathsf{GroupPull}$ and some additional constant migration. Furthermore, two deletions of big items from $\mathtt{BB}$ may be caused. Because of the corresponding case no reinsertions of big items are caused by these deletions. Hence, the migration in this case is at most $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$ (see Lemma 16) plus the migration due to the possible insertions of big items.

If $i^{*}$ is a medium item and has to be inserted, we have $\mathcal{O}(1)$ migration and the deletion or insertion of a big item may be caused. In case of a deletion the corresponding item was positioned in $\mathtt{BS}$. If the item $i^{*}$ is deleted, this may cause $\mathcal{O}(1)$ migration as well as the reinsertion of a big item. Hence, the migration in this case is at most $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$.

Summarizing, the overall size of items that are migrated due to the insertion or deletion of a big or medium item $i^{*}$ is $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$. ∎

3.4 Analysis

In this section, we finish the proof of Theorem 7. We already proved bounds on the migration that may be caused due to insertions and deletions of algorithms (see Lemmas 14,15 and 17). Note that medium items may cause the migration of items with overall size $\mathcal{O}((1/\varepsilon)^{4}\cdot\log^{2}(1/\varepsilon))$ but may have size $\varepsilon$ themselves yielding the bound of $\mathcal{O}((1/\varepsilon)^{5}\cdot\log^{2}(1/\varepsilon))$ stated in Theorem 7. Furthermore, we argued that the invariants are maintained by the insertion and deletion procedures throughout the section. Using these invariants, we prove the stated asymptotic competitive ratio and additive constant.

Lemma 18**.**

The algorithm for the dynamic case has an asymptotic competitive ratio of $1.5+\varepsilon$ with additive constant $\mathcal{O}(\log 1/\varepsilon)$.

Proof.

First, we consider the case $\mathtt{BSP}=\emptyset$. In this case, the claim holds because the bins on average have not too much excess size. More precisely, we obviously have $\operatorname{\text{{opt}}}(I)\leq s(I)$, and the invariants I1 and I6 imply:

[TABLE]

Furthermore, we have $s(\mathtt{GB})<(1/2+\varepsilon)(\varepsilon|\mathtt{BSC}|+G)\leq\varepsilon|\mathtt{BSC}|+G$, due to 9 and 10; $s(\mathtt{S}\setminus\mathtt{SC})<\varepsilon|\mathtt{SC}|+1$, due to 7; $(0.5-\varepsilon)|\mathtt{BB}|\leq(0.5-\varepsilon)(|\mathtt{BS}|+1)$, due to I2; and $|\mathtt{BS}|=|\mathtt{BSC}|$, because of the case we are considering. Hence:

[TABLE]

A similar argument holds, if $\mathtt{BSP}\neq\emptyset$ and $\mathtt{BB}=\emptyset$. In this case, we have $\mathtt{BS}=\mathtt{BSP}$ and $|\mathtt{BSP}|=1$, because of invariant I2; $\mathtt{GB}=\emptyset$, because of 9 and 10; and $\mathtt{S}=\emptyset$, because of invariant I5. Hence:

[TABLE]

Next, we consider the case $\mathtt{BSP}\neq\emptyset$ and $\mathtt{BB}\neq\emptyset$. In this case, we have $\mathtt{MC}=\emptyset$, because of Invariant I4, and $\mathtt{S}=\emptyset$, because of Invariant I5. According to invariant 12, there is a $g^{*}\in[G+1]$ such that each bin in each group preceding $\mathtt{Gr}_{g^{*}}$ is well-covered and each succeeding group does not contain small items, and because $\mathtt{BSP}\neq\emptyset$, we have $g^{*}<G+1$. Let $\xi=s_{\min}(\operatorname{big}(\mathtt{Gr}_{g^{*}}))$ be the size of a big item from $\mathtt{Gr}_{g^{*}}$ with minimal size. Because of the invariants I3 and 11, the items in $\mathtt{BB}$ and each group succeeding $\mathtt{Gr}_{g^{*}}$ are upper bounded in size by $\xi$. We construct a modified instance $I^{*}$ as follows:

The remaining big items (the ones bigger than $\xi$) are split into a big item of size $\xi$ and a medium or small item. Let $X$ be the set of items with size $\xi$. 2. 2.

For each bin from $\mathtt{BSC}\cup\mathtt{BM}\cup\{B\,|\,\mathopen{}B\in\bigcup_{g\in[G]}\mathtt{BGr}_{g},B\text{ is well-covered}\}$, we increase the size of a biggest item that is not big to $0.5$. Let $Y$ be the set of these items and $Z$ be the set of the remaining items not belonging to $X$ or $Y$.

Note that $\operatorname{\text{{opt}}}(I)\leq\operatorname{\text{{opt}}}(I^{*})$. For some optimal solution for $I^{*}$ in which each bin is at most barely covered, let $k_{2}$, $k_{1}$ and $k_{0}$ be the numbers of covered bins with $2$, $1$ or [math] items from $X\cup Y$ respectively. We have:

[TABLE]

Furthermore, $(1-\xi)k_{1}+k_{0}\leq s(Z)$ and, due to 10, 9, I4, 12 and the choice of $\xi$, we have:

[TABLE]

Hence:

[TABLE]

Lastly, we conclude the proof of Theorem 7 by arguing that the running time bound holds.

Lemma 19**.**

The insertion and deletion procedures in the dynamic case have polynomial running time in both the input size and $1/\varepsilon$.

Proof.

We first consider the insertion or deletion of small items. When one of these procedures is called, there may be $\mathcal{O}(1/\varepsilon)$ many recursive calls. For each of these calls it is rather ease to see that the running time is linear in the number of items. Concerning the insertion or deletion of big or medium items, we already saw in the migration analysis (Lemma 17) that only a constant number of recursive calls of big and medium items may be caused. Furthermore, small items (and there are at most $n$ such items) may removed or reinserted due to these calls. ∎

4 Amortized Migration

We will now take a look at the setting, where the migration is amortized. Here we are concerned with the maximum ratio of the migration performed divided by the total size of items that have arrived up to some point. This is easier than the standard non-amortized migration considered before.

4.1 Dynamic Case

For the dynamic case, we will show that the lower bound of $3/2$ on the competitive ratio also holds if amortized migration is allowed. Hence, our above algorithm that only uses non-amortized migration is optimal (except for an extra $\varepsilon$). This result can also be proved for the other definition of asymptotic competitive ratio.

Proposition 20**.**

There is no algorithm for dynamic online bin covering with a constant amortized migration factor $\beta$ and an asymptotic competitive ratio smaller than $3/2$.

Proof.

Let $\operatorname{\text{{alg}}}$ be an algorithm for dynamic online bin covering with an amortized migration factor of $\beta$. Suppose that $\operatorname{\text{{alg}}}$ has asymptotic competitive ratio $3/2-\delta$ for some constant value $1/2\geq\delta>0$, i. e., for each instance we have $\operatorname{OPT}(I)\leq(3/2-\delta)\cdot\operatorname{\text{{alg}}}(I)+c$ for some constant $c$. We will now construct for each even integer $N$ an instance $I^{(N)}$. This instance is comprised of $m+1$ phases, where $m$ is an even number that is specified later on and depends on $N$ and $\beta$. In each of the phases some number of equally sized items either arrives or departs. The instance corresponding to the first phase is called $I^{(N)}_{0}$ and the one corresponding to the first $j+1$ phases is called $I^{(N)}_{j}$. The optimal (offline) objective value for each of these instances will be a multiple of $N$, i. e., $\operatorname{OPT}(I^{(N)}_{j})\in\{3N,(3/2)N\}$. We will show that the ratio between this value and the objective value achieved by $\operatorname{\text{{alg}}}$ is at least $3/2$ for at least one value of $j\in\{0,\ldots,m\}$ with constant amortized migration factor.

We now describe the instance $I^{(N)}$: In the first phase $3N$ big items with size $1-\varepsilon$ arrive; and for each odd $j\in[m]$ there are $3N$ small items with size $\varepsilon$ arriving in phase $j$ and departing in phase $j+1$. We choose the parameter $\varepsilon$ such that $3N$ small items cannot fill a whole bin, and such that the total size of $3N$ small items is upper bounded by the size of a big item, e.g., $\varepsilon=\min\{(9\beta N+2)^{-1},(6N)^{-1}\}$. Note that for each $j\in\{0,\dots,m\}$ the optimal (offline) objective value for $I^{(N)}_{j}$ is $3N/2$ if $j$ is even, and $3N$ if $j$ is odd (see Fig. 9).

Claim 21**.**

For each even integer $N$, there is some index $j\in\{1,\ldots,m\}$ such that $(3/2)\operatorname{\text{{alg}}}(I^{(N)}_{j})\leq\operatorname{OPT}(I^{(N)}_{j})$.

Proof.

If $\operatorname{\text{{alg}}}(I^{(N)}_{j})\leq N$ for some even $j$ or $\operatorname{\text{{alg}}}(I^{(N)}_{j})\leq 2N$ for some odd $j$, we are done. Hence, let $\mathfrak{P}$ denote the property that $\operatorname{\text{{alg}}}(I^{(N)}_{j})>N$ for all even $j$ and $\operatorname{\text{{alg}}}(I^{(N)}_{j})>2N$ for all odd $j$, and we analyze whether $\mathfrak{P}$ can be obtained by $\operatorname{\text{{alg}}}$. Since two big items are needed to cover a bin and $3N$ small items are not sufficient for covering a bin, $\mathfrak{P}$ implies that at least $N+1$ bins have to contain at least $2$ big items, if $j$ is even; and at least $N+1$ bins have to contain exactly one big item, if $j$ is odd.

Hence, to maintain that $\mathfrak{P}$ holds in two consecutive phases, some big item has to be moved, and therefore the migration performed in each phase is at least $1-\varepsilon$. However, the total size of items arriving or departing in every phase $I^{(N)}_{1},I^{(N)}_{2},\dotsc$ is only

[TABLE]

In the first inequality, we use $\varepsilon\leq(9\beta N+2)^{-1}$. In the last inequality, we use $N\geq 1$ implying $\varepsilon\leq 1/6\leq 1/3$ and thus $(1-2\varepsilon)\geq 1/3$.

Hence, the total size of migrated items is at least $m(1-\varepsilon)$ and the total load of items arriving or departing is strictly smaller than $(3N)(1-\varepsilon)+m(1-2\varepsilon)/\beta$. As $\operatorname{\text{{alg}}}$ has amortized migration factor $\beta$, it is allowed to reassign a total size of $\beta S$, after items of size $S$ have arrived or departed. The total size of arrived and departed items equals $(3N)(1-\varepsilon)+m(1-2\varepsilon)/\beta$ in our setting. Hence, $\operatorname{\text{{alg}}}$ is allowed to migrate a total size $(3N\beta)(1-\varepsilon)+m(1-2\varepsilon)$. Choosing $m$ – the number of phases – such that $m>(3N\beta)(1-\varepsilon)/\varepsilon$ then gives $(3N\beta)(1-\varepsilon)+m(1-2\varepsilon)<m(1-\varepsilon)$. Hence $\operatorname{\text{{alg}}}$ can not migrate a total size of $m(1-\varepsilon)$. As it needs to migrate at least such a total size to maintain property $\mathfrak{P}$, we can conclude that $\mathfrak{P}$ can not hold. Hence, there is some index $j\in\{1,\ldots,m\}$ such that $\operatorname{\text{{opt}}}(I^{(N)}_{j})/\operatorname{\text{{alg}}}(I^{(N)}_{j})\geq 3/2$, concluding our proof. ∎

This is sufficient to prove the proposition: From above, we know that for each even $N$, there is some value $j$ such that $(3/2)\cdot\operatorname{\text{{alg}}}(I^{(N)}_{j})\leq\operatorname{\text{{opt}}}(I^{(N)}_{j})$. The asymptotic competitive ratio of $\operatorname{\text{{alg}}}$ then implies $\operatorname{\text{{opt}}}(I^{(N)}_{j})\leq(3/2-\delta)\cdot\operatorname{\text{{alg}}}(I^{(N)}_{j})+c$ and thus

[TABLE]

This is equivalent to $c/\delta\geq\operatorname{\text{{alg}}}(I^{(N)}_{j})$. As $\operatorname{\text{{alg}}}$ has asymptotic competitive ratio $3/2-\delta$ and $\operatorname{\text{{opt}}}(I^{(N)}_{j})=k_{j}N$, we have $c/\delta\geq\operatorname{\text{{alg}}}(I^{(N)}_{j})\geq\frac{k_{j}N-c}{3/2-\delta}$ and thus $c(3/2-\delta)/\delta+c\geq k_{j}N$. As $N$ can be made arbitrarily large, this is a contradiction to the assumption that both $c$ and $\delta$ are constant values. Hence, an asymptotic competitive ratio of $3/2-\delta$ is not achievable with constant amortized migration factor $\beta$.

∎

4.2 Static Case

In contrast to the dynamic case, where amortized migration does not help to improve upon the lower bound of $3/2$ on the competitive ratio, amortization allows to design a simple algorithm for the static case, achieving a competitive ratio of $1+\varepsilon$ with amortized migration of $\mathcal{O}(1/\varepsilon)$. Some of the ideas applied here were used for bin packing [14] in the past. The small value $\varepsilon$ will again satisfy $0<\varepsilon\leq 0.5$.

In order to achieve this goal, we make use of an asymptotic fully polynomial time approximation scheme (AFPTAS), denoted by $\operatorname{\text{{alg}}}_{\operatorname{off}}$, for the offline version of the problem due to Jansen and Solis-Oba [21]. For an instance $I$ and an approximation parameter $\varepsilon$, the algorithm $\operatorname{\text{{alg}}}_{\operatorname{off}}$ produces a packing that covers $\operatorname{\text{{alg}}}_{\operatorname{off}}(I,\varepsilon)$ bins with $\operatorname{\text{{opt}}}(I)\leq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I,\varepsilon)+\mathcal{O}(1/\varepsilon^{3})$ in time that is polynomial in the input size and $\frac{1}{\varepsilon}$. Let $\mu\geq 1$ be a constant such that

[TABLE]

holds for every input $I$.

Our algorithm will be called $\operatorname{\text{{alg}}}_{\operatorname{on}}$ and its profit for input $I$ and $\varepsilon$ is denoted by $\operatorname{\text{{alg}}}_{\operatorname{on}}(I,\varepsilon)$. Denote the instance after $\tau$ items were presented, that is, at time $\tau$, as $I_{\tau}$. Our online algorithm $\operatorname{\text{{alg}}}_{\operatorname{on}}$ will have the same guarantee as the offline algorithm in terms of the order of growth of the additive term, i. e., we will show $\operatorname{\text{{opt}}}(I_{\tau})\leq(1+\mathcal{O}(\varepsilon))\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{\tau},\varepsilon)+\mathcal{O}(1/\varepsilon^{3})$, and more specifically, we will show that $\operatorname{\text{{opt}}}(I_{\tau})\leq(1+3\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{\tau},\varepsilon)+\frac{6\mu}{\varepsilon^{3}}$ for every time $\tau$. There will be a sequence of special times denoted by $t_{1},t_{2},\cdots$ for which it will hold that $\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)=\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$ and therefore $\operatorname{\text{{opt}}}(I_{t_{i}})\leq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)+\frac{\mu}{\varepsilon^{3}}$ will hold for every $i\geq 1$.

Algorithm $\operatorname{\text{{alg}}}_{\operatorname{on}}$ will apply $\operatorname{\text{{alg}}}_{\operatorname{off}}$ (with the same value of $\varepsilon$) in every step, i. e., when a new item arrives. This is done in order to obtain an approximated value of the profit of an optimal solution. As we saw before, arguments that are based on total size are valid for approximating this value by a factor of $2$, but not within a smaller factor. In the special times $t_{1},t_{2},\ldots$ defined in what follows, the output of $\operatorname{\text{{alg}}}_{\operatorname{off}}$ will be used in order to obtain a new solution, and the input is completely repacked such that it is packed as in this solution ($\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$). In this case, all items are removed from their bins and repacked identically to the output of $\operatorname{\text{{alg}}}_{\operatorname{off}}$. This is done instead of assigning the new item. In other times which are not special, only the profit of $\operatorname{\text{{alg}}}_{\operatorname{off}}$ will be used, and the new item is packed into a new bin.

Thus, at times that are not special, algorithm $\operatorname{\text{{alg}}}_{\operatorname{on}}$ will always greedily assign a new item to a new non-covered bin, and on occasion it will define the current time as special and then it completely repacks the instance with the help of $\operatorname{\text{{alg}}}_{\operatorname{off}}$. We define special times as follows. The first special time $t_{1}$, which is the first time in which we repack the instance using $\operatorname{\text{{alg}}}_{\operatorname{off}}$ is when $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{1}})\geq 3\mu/\varepsilon^{3}>1$ (by $\varepsilon\leq 0.5$ and $\mu\geq 1$). We have $t_{1}>1$ since after the arrival of just one item no solution has profit above $1$. Before time $t_{1}$, the profit of $\operatorname{\text{{alg}}}_{\operatorname{on}}$ is zero. The other special times are defined as follows. Let $t_{i}$ (for $i\geq 1$) be the last special time, i. e., the last time that a repacking was performed. For the current time $\tau>t_{i}$, if $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{\tau},\varepsilon)<(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$, the new item is packed into a new bin and $\tau$ is not a special time. Otherwise, we let $t_{i+1}=\tau$, i. e., $\tau$ is a special time, and instead of packing the new item immediately, we perform the next repacking. Thus, time $t_{i+1}>t_{i}$, is the first time $\tau>t_{i}$ for which $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{{\tau}},\varepsilon)\geq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$, and thus $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i+1}},\varepsilon)\geq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$ while $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{\theta},\varepsilon)<(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$, where $t_{i}+1\leq\theta\leq t_{i+1}-1$.

Clearly, the running time of our online algorithm is polynomial in $t$ and $1/\varepsilon$, since it is the sum of running times of $\operatorname{\text{{alg}}}_{\operatorname{off}}$ for all prefixes of the input. Before we discuss the migration factor, we show that this algorithm always maintains a near-optimal solution. We will use the property that holds at special times, and analyze the other times.

At any time $\tau<t_{1}$ (before the first repacking), we have that $\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{\tau})<3\mu/\varepsilon^{3}$ while $\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{\tau})\geq 0$, and by (1) we get $\operatorname{\text{{opt}}}(I_{\tau})\leq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{\tau},\varepsilon)+\frac{\mu}{\varepsilon^{3}}\leq(1+\varepsilon)\cdot\frac{3\mu}{\varepsilon^{3}}+\frac{\mu}{\varepsilon^{3}}<\frac{6\mu}{\varepsilon^{3}}\leq(1+3\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{\tau})+\frac{6\mu}{\varepsilon^{3}}$. For every special time $t_{i}$ we have $\operatorname{\text{{opt}}}(I_{t_{i}})\leq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)+\frac{\mu}{\varepsilon^{3}}=(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)+\frac{\mu}{\varepsilon^{3}}\leq(1+3\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)+\frac{6\mu}{\varepsilon^{3}}$, since at any special time, once the repacking is applied, the packing of $\operatorname{\text{{alg}}}_{\operatorname{on}}$ is identical to that of $\operatorname{\text{{alg}}}_{\operatorname{off}}$.

Now consider a time $\tau$ satisfying $\tau>t_{i}$ for some $i\geq 1$, and if $t_{i}$ is not the last special time, then we also require $\tau<t_{i+1}$. Thus, no special times are defined at times $t_{i}+1,\ldots,\tau$, and we have

[TABLE]

Since all items $t_{i}+1,\ldots,\tau$ are assigned to new bins, and covered bins remain such, we have $\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{\tau},\varepsilon)\geq\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)$. Due to the repacking at the special time $t_{i}$, we find $\operatorname{\text{{alg}}}_{\operatorname{on}}(I_{t_{i}},\varepsilon)=\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$, and get

[TABLE]

Combining the last two inequalities (2) and (3) gives

[TABLE]

By (1) for time $\tau$, $\operatorname{\text{{opt}}}(I_{\tau})\leq(1+\varepsilon)\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{\tau},\varepsilon)+\frac{\mu}{\varepsilon^{3}}$, and we get

[TABLE]

as $\varepsilon^{2}<\varepsilon$.

Hence, $\operatorname{\text{{alg}}}_{\operatorname{on}}$ achieves an asymptotic competitive ratio of $1+3\varepsilon$, and an appropriate scaling of $\varepsilon$ allows us to obtain competitive ratio $1+\varepsilon$.

Finally, we will show that $\operatorname{\text{{alg}}}_{\operatorname{on}}$ has an amortized migration factor of $\mathcal{O}(1/\varepsilon)$. Let $k$ be the number of special times (which are $t_{1},t_{2},\ldots,t_{k}$). Let $U_{i}$ denote the optimal profit at time $t_{i}$, which is a monotonically non-decreasing sequence. Let $S_{i}$ denote the total size of the first $t_{i}$ input items. The total size of migrated items is at most $\sum_{i=1}^{k}S_{i}$, while the total size of items is at least $S_{k}$. Let $\Delta_{i}=\operatorname{\text{{alg}}}_{\operatorname{off}}(I_{t_{i}},\varepsilon)$, where for every $1\leq i\leq k-1$ we have $\Delta_{i+1}\geq(1+\varepsilon)\Delta_{i}$, and additionally, $\Delta_{1}\geq\frac{3\mu}{\varepsilon^{3}}>1$.

We claim that $U_{i}$ satisfies $\Delta_{i}\leq U_{i}<3\Delta_{i}$. The inequality $\Delta_{i}\leq U_{i}$ holds since $U_{i}$ is the optimal profit at a certain time while $\Delta_{i}$ is the profit of some solution for the same input. Since $U_{i}\geq U_{1}\geq\Delta_{1}\geq\frac{3\mu}{\varepsilon^{3}}$ and by (1) we get $U_{i}\leq(1+\varepsilon)\Delta_{i}+\frac{\mu}{\varepsilon^{3}}<2\Delta_{i}+U_{i}/3$, which implies $U_{i}<3\Delta_{i}$.

Moreover, there exists an optimal solution where every bin has load in $[1,2)$, and there is at most one bin that is not covered. Thus, $U_{i}\leq S_{i}<2U_{i}+1<3U_{i}$.

We find by $\Delta_{k}\leq U_{k}\leq S_{k}$:

[TABLE]

By

[TABLE]

and by

[TABLE]

we find

[TABLE]

This analysis holds also for every prefix of the input if the input was repacked at least once (and otherwise the amortized migration factor is zero). Hence, the amortized migration factor of $\operatorname{\text{{alg}}}_{\operatorname{on}}$ is at most $9+\frac{9}{\varepsilon}=\mathcal{O}(1/\varepsilon)$ and we obtain the following theorem.

Theorem 22**.**

For every $\varepsilon>0$, there is an algorithm for static online bin covering with polynomial running time, an asymptotic competitive ratio of $1+\varepsilon$, and an amortized migration factor of $\mathcal{O}(1/\varepsilon)$.

In the following, we will show that an error in the amortized setting is inevitable, even if we allow an unbounded running time.

Theorem 23**.**

There is no (possibly exponential time) algorithm for static online bin covering that maintains an optimal solution with constant amortized migration factor $\beta$.

Proof.

We say that a bin is perfectly covered, if it contains items of total size exactly $1$, and call a solution perfect if all of its bins are perfectly covered. Obviously, if there is a perfect solution to a bin covering instance, it is optimal and each optimal solution for this instance has to be perfect.

Let $N$ be a positive even integer. Our input consists of $N+1$ phases. The first phase (phase [math]) consists of items of total size $N$ and phase $j$ (for $j\geq 1$) consists of items of total size $2$. Let $I_{j}$ be the instance after phase $j$ arrived.

We will ensure that the optimum $\operatorname{\text{{opt}}}(I_{j})=N+2j$ is realized by a unique perfect solution (up to some transpositions). Furthermore, the total size of items that need to be moved to transform an optimal solution of $I_{j}$ to an optimal solution of $I_{j+1}$ is at least $(N-j+2)/3$. Hence, items with total size $\Omega(N^{2})$ have to be moved to maintain an optimal solution at all times while the total size of all arriving items is $3N$ yielding that the needed amortized migration is $\Omega(N)$. Since the construction works for arbitrarily big values of $N$, this suffices to prove the claim, as this rules out a constant amortized migration factor.

We will proceed by first describing all occurring items in detail and noting some basic properties, then we define the phases, describe the optimal solutions and finally we prove their uniqueness and the necessary migration.

Let $\varepsilon=1/(N+1)^{4}$. The items are either huge, large, medium or tiny and each of these classes contains items of $N$ levels. More precisely, for each level $i\in[N]$ we have:

• •

One huge item with size $\mathtt{huge}(i)=1-(N-i+1)\varepsilon(1+(i-1)(N+1))$.

• •

One large item of type A with size $\mathtt{large}_{A}(i)=1/2+i(N+1)\varepsilon$, and one large item of type B with size $\mathtt{large}_{B}(i)=\mathtt{large}_{A}(i)+\varepsilon$.

• •

One medium item of type A with size $\mathtt{medium}_{A}(i)=1/2-i(N+1)\varepsilon$, and one large item of type B with size $\mathtt{medium}_{B}(i)=\mathtt{medium}_{A}(j)-\varepsilon$.

• •

$N-i+1$ tiny items each with size $\mathtt{tiny}(i)=\varepsilon(1+(i-1)(N+1))$.

We now state some simple properties of these items:

Claim 24**.**

It holds

$\mathtt{large}_{A}(i)+\mathtt{medium}_{A}(i)=\mathtt{large}_{B}(i)+\mathtt{medium}_{B}(i)=\mathtt{huge}(i)+(N-i+1)\mathtt{tiny}(i)=1$; 2. 2.

$\sum_{i=1}^{N}(N-i+1)\cdot\mathtt{tiny}(i)<1$* (i. e., all tiny items together cannot fill a bin completely);* 3. 3.

$\mathtt{huge}(N)<\mathtt{huge}(1)$, $\mathtt{large}_{A}(1)<\mathtt{large}_{A}(N)$, $\mathtt{large}_{B}(1)<\mathtt{large}_{B}(N)$, $\mathtt{medium}_{A}(N)<\mathtt{medium}_{A}(1)$, $\mathtt{medium}_{B}(N)<\mathtt{medium}_{B}(1)$, $\mathtt{tiny}(1)<\mathtt{tiny}(N)$; 4. 4.

$\mathtt{huge}(N)>\mathtt{large}_{B}(N)$, $\mathtt{large}_{A}(1)>\mathtt{medium}_{A}(1)$, $\mathtt{medium}_{B}(N)>\mathtt{tiny}(N)$; 5. 5.

$\mathtt{medium}_{B}(N)>1/3$, $\mathtt{large}_{A}(1)>1/2$, $\mathtt{medium}_{A}(1)<1/2$, $\mathtt{huge}(N)+\mathtt{medium}_{B}(N)>\leavevmode\nobreak\ 1$ 6. 6.

$\mathtt{huge}(i)+\mathtt{medium}_{X}(i^{\prime})>1$* and $\mathtt{huge}(i)+\mathtt{large}_{X}(i^{\prime})>1$ for all $X\in\{A,B\}$ and all $i,i^{\prime}\in\{1,\ldots,N\}$.*

For completeness, the simple proof of this fact can be found in the appendix.

Hence, large and medium items of the same type and level can be used to pack a bin perfectly and every other combination of two large or medium items does not cover a bin perfectly. Let $s_{h},s_{\ell},s_{m}$ and $s_{t}$ be sizes of some huge, large, medium and tiny item respectively. Summarizing the claim, we have (i) all tiny items together cannot fill a whole bin, (ii) $s_{h}>s_{\ell}>s_{m}>s_{t}$, (iii) $s_{m}>1/3$, (iv) $s_{\ell}>1/2>s_{m}$, and (v) $s_{h}+s_{m}>1$. Hence, in a perfect solution to an instance $I$ comprised of a subset of the above items, a bin may contain

(1) exactly one large item together with the unique matching medium item;

(2) at most two items that are medium or large, and at least one tiny item; or

(3) exactly one huge, and at least one tiny item.

Furthermore, if $I$ contains the first $n\leq N$ levels of huge items, we have:

Claim 25**.**

In a perfect solution of $I$, the first $n$ levels of huge items have to be packed together with the first $n$ levels of tiny items in a unique way.

Proof.

To see this, consider the bin $B_{k}$ containing the huge item of level $k$ in a perfect solution. Due to point 6 in Claim 24, $B_{k}$ cannot contain any large or medium item, as the solution is perfect. Hence, $B_{k}$ must contain some tiny items. These tiny items in $B_{k}$ must have a total size of $r_{k}=1-\mathtt{huge}(k)=(N-k+1)\varepsilon(1+(k-1)(N+1))$. As $(r_{k}/\epsilon)\bmod(N+1)=(N-k+1)$ and $(\mathtt{tiny}(i)/\varepsilon)\bmod(N+1)=1$ for all $i=1,\ldots,N$, we need at least $N-k+1$ tiny items to cover bin $B_{k}$.

Now, suppose that there is some bin $B_{k}$ that does not contain all $N-k+1$ tiny items of level $k$ and let this $k$ be minimal. Hence, for each $i\in\{1,\ldots,k-1\}$, the bin $B_{i}$ contains the $N-i+1$ tiny items of level $i$ and all of these tiny items are thus packed. As $B_{k}$ needs to contain $N-k+1$ tiny items, it hence must contain at least one tiny item of size at least $\mathtt{tiny}(k+1)$ (due to the monotonicity of $\mathtt{tiny}(i)$). Hence, the sum of the tiny items in $B_{k}$ is at least

[TABLE]

Hence, $B_{k}$ is not perfectly covered, a contradiction to the assumption.

∎

We proceed with the definition of the phases: Phase [math] consists of all large items of type A, all medium items of type B and the tiny items of level $1$. Note that the large items of type $B$ and the medium items of type $A$ are not yet available. As $\mathtt{large}_{A}(i)+\mathtt{medium}_{B}(i)+\mathtt{tiny}(1)=1$ (see Claim 24), the total volume of items in phase [math] is $N$. This (perfect) packing also shows that $\operatorname{\text{{opt}}}(I_{0})=N$ (see Fig. 10).

Claim 26**.**

Putting one item of size $\mathtt{large}_{A}(i)$, one item of size $\mathtt{medium}_{B}(i)$, and one item of size $\mathtt{tiny}(1)$ into a bin is the unique optimal perfect packing (up to the packing of the tiny items) for phase [math].

Proof.

Due to the definition of the sizes, two large items have total size strictly larger than $1$ and two medium items have total size strictly smaller than $1$. The total size of items in phase [math] is exactly $N$, the total size of all tiny items is not enough to cover a single bin (Claim 24), and we have exactly $N$ large and $N$ medium items. Hence, every bin in a perfect packing must contain one large item and one medium item. Now let $B_{i}$ be the bin containing $\mathtt{large}_{A}(i)$.

Suppose that the solution described above is not unique. Hence, there is some bin $B_{i}$ that contains an item of size $\mathtt{medium}_{B}(j)$ with $i\neq j$. If $j>i$, the monotonicity of $\mathtt{medium}_{B}(\cdot)$ shows that this bin is not perfectly covered. If $j<i$, the pidgeonhole principle shows that there must be some bin $B_{i^{\prime}}$ containing an item of size $\mathtt{medium}_{B}(j^{\prime})$ with $j^{\prime}>i^{\prime}$, which is again a contradiction. ∎

For each $j\in[N]$, phase $j$ consist of the huge item of level $j$, the large type B item of level $j$, the medium type A item of level $N-j+1$ and the tiny items of level $j+1$ if $j<N$, and no tiny items otherwise. The items of instance $I_{j}$ can be packed perfectly as follows. The huge and tiny items of level $1$ to $j$ are packed in the unique possible way described above; the large and medium type B items of level $1$ to $j$ are matched to form $j$ perfectly packed bins, and similarly the large and medium type A items of level $N$ to $N-j+1$ are matched. Lastly, for each $k\in\{1,\dots,N-j\}$, we have $\mathtt{large}_{A}(k)+\mathtt{medium}_{B}(j+k)+\mathtt{tiny}(j+1)=1$ and we pack the remaining items correspondingly (see Fig. 11). This packing has $N+2j$ perfectly covered bins.

Claim 27**.**

The packing described above is unique.

Proof.

Claim 25 implies that the huge items are packed together with the fitting tiny ones in $j$ perfectly covered bins. There are only $N-j$ tiny items left and each bin that does not correspond to a perfect match of a medium and large item has to contain a tiny item as described in the proof of Claim 26. As we still need to fill $N+j$ bins perfectly, $2j$ of these bins need to be packed by perfect matches. This is exactly the number of perfect matches available and we thus need to pack all of them.

Furthermore, large items cannot be combined in one perfectly covered bin (Claim 24) and therefore each of them has to be packed into a single bin together with a tiny item. For each such bin there is exactly one medium item left that fits perfectly, namely the one chosen above. ∎

In order to transform the unique perfect solution of instance $I_{j-1}$ into the one for $I_{j}$, at least $N-j+2$ non-tiny items have to be moved (see Fig. 11). Each of these items has a size of at least $1/3$. Hence, a total migration of $\sum_{j=1}^{N}(N-j+2)/3\geq\Omega(N^{2})$ is needed while the total size of the instance is $3N$. As we are only allowed to repack a total size of $\beta 3N$, this implies $\beta\geq\Omega(N)$, a contradiction to the assumption that $\beta$ is a constant.

This concludes the proof.

∎

Appendix A Proof of Claim 24

Proof of 24.

We simply calculate:

• •

$\mathtt{large}_{A}(i)+\mathtt{medium}_{A}(i)=1/2+i(N+1)\varepsilon+1/2-i(N+1)\varepsilon=1$

• •

$\mathtt{large}_{B}(i)+\mathtt{medium}_{B}(i)=1/2+i(N+1)\varepsilon+1/2+\varepsilon-i(N+1)\varepsilon-\varepsilon=1$

• •

$\mathtt{huge}(i)+(N-i+1)\mathtt{tiny}(i)=\\ {1-(N-i+1)\varepsilon(1+(i-1)(N+1))+(N-i+1)\varepsilon(1+(i-1)(N+1))}=1$ 2. 2.

We have

[TABLE] 3. 3.

We also calculate:

• •

$\mathtt{huge}(N)=1-N\varepsilon<1-N^{2}\varepsilon=1-\varepsilon(1+(N-1)(N+1))=\mathtt{huge}(1)$

• •

$\mathtt{large}_{A}(1)=1/2+(N+1)\varepsilon<1/2+N(N+1)\varepsilon=\mathtt{large}_{A}(N)$

• •

$\mathtt{large}_{B}(1)=1/2+(N+1)\varepsilon+\varepsilon<1/2+N(N+1)\varepsilon+\varepsilon=\mathtt{large}_{B}(N)$

• •

$\mathtt{medium}_{A}(N)=1/2-N(N+1)\varepsilon<1/2-(N+1)\varepsilon=\mathtt{medium}_{A}(1)$

• •

$\mathtt{medium}_{B}(N)=1/2-N(N+1)\varepsilon-\varepsilon<1/2-(N+1)\varepsilon-\varepsilon=\mathtt{medium}_{B}(1)$

• •

$\mathtt{tiny}(1)=\varepsilon<\varepsilon(1+(N-1)(N+1))=\mathtt{tiny}(N)$ 4. 4.

Again, we calculate

• •

Note that $(N+1)^{4}>(N+1)^{4}/2+N(N+3)$ for all $N\geq 1$ and hence $\mathtt{huge}(N)=1-N\varepsilon=1-N/(N+1)^{4}>1/2+N(N+2)/(N+1)^{4}=\\ 1/2+N(N+1)\varepsilon+\varepsilon=\mathtt{large}_{B}(N)$.

• •

$\mathtt{large}_{A}(1)=1/2+(N+1)\varepsilon>1/2-(N+1)\varepsilon=\mathtt{medium}_{A}(1)$

• •

Note that $(N+1)^{4}/2>N^{2}+N(N+2)$ for $N\geq 1$ and hence $\mathtt{medium}_{B}(N)=1/2-N(N+1)\varepsilon-\varepsilon=1/2-N(N+2)\varepsilon=1/2-N(N+2)/(N+1)^{4}>N^{2}/(N+1)^{4}=\varepsilon(1+(N-1)(N+1))=\mathtt{tiny}(N)$ 5. 5.

Finally, some calculations show that

• •

Note that $(N+1)^{4}/2>(N+1)^{4}/3+N(N+2)$ and hence $\mathtt{medium}_{B}(N)=1/2-N(N+1)\varepsilon-\varepsilon=1/2-N(N+2)\varepsilon>1/3$.

• •

$\mathtt{large}_{A}(1)=1/2+(N+1)\varepsilon>1/2$

• •

$\mathtt{medium}_{A}(1)=1/2-(N+1)\varepsilon<1/2$

• •

From $\mathtt{medium}_{B}(N)>1/3$, we have $\mathtt{huge}_{N}+\mathtt{medium}_{B}(N)>1-N\varepsilon+1/3=1-N/(N+1)^{4}+1/3>1$. 6. 6.

This follows from the above points. Note that $\mathtt{huge}(N)$ is the smallest huge item and $\mathtt{medium}_{B}(1)$ the smallest medium item. Hence, point 5 implies that the sum of these two already exceeds $1$. As every medium or large item is larger than $\mathtt{medium}_{B}(1)$ due to points 3 and 4, the claim follows.

∎