Submitted to Operations Research
manuscript (Please, provide the manuscript number!)
Authors are encouraged to submit new papers to INFORMS journals by means of
a style file template, which includes the journal title. However, use of a template
does not certify that the paper has been accepted for publication in the named journal. INFORMS journal templates are for the exclusive purpose of submitting to an
INFORMS journal and should not be used to distribute the papers in print or online
or to submit the papers to another publication.
Online Make-to-Order Joint Replenishment Model:
Primal Dual Competitive Algorithms
Niv Buchbinder
Computer Science Dept., Open University of Israel, niv.buchbinder@gmail.com, *
Tracy Kimbrel
National Science Foundation, tkimbrel@gmail.com
Retsef Levi
Sloan School of Management, MIT, Cambridge, MA, 02139, retsef@mit.edu,
†
Konstantin Makarychev
Microsoft Research, konstantin.makarychev@gmail.com
Maxim Sviridenko
Department of Computer Science, University of Warwick, sviri@dcs.warwick.ac.uk,
‡
In this paper, we study an online make-to-order variant of the classical joint replenishment problem (JRP)
that has been studied extensively over the years and plays a fundamental role in broader planning issues, such
as the management of supply chains. In contrast to the traditional approaches of the stochastic inventory
theory, we study the problem using competitive analysis against a worst-case adversary.
Our main result is a 3-competitive deterministic algorithm for the online version of the JRP. We also prove
a lower bound of approximately 2.64 on the competitiveness of any deterministic online algorithm for the
problem. Our algorithm is based on a novel primal-dual approach using a new linear programming relaxation
of the offline JRP model. The primal-dual approach that we propose departs from previous primal-dual and
online algorithms in rather significant ways. We believe that this approach can extend the range of problems
to which online and primal-dual algorithms can be applied and analyzed.
Key words : Joint replenishment problem, Online algorithm, Competitive Analysis, Primal-dual
History : A preliminary version of this paper appeared in the Proceedings of the Nineteenth Annual
ACM-SIAM Symposium on Discrete Algorithms, SODA 2008.
1
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
2
1. Introduction
Inventory theory provides streamlined stochastic optimization models that attempt to capture
tradeoffs between opposing costs in managing the flow of multiple types of goods through a supply chain. Uncertainty about future demands is one of the major challenges that make inventory
management problems very complex. Most traditional stochastic inventory models studied in the
literature assume that the probability distributions of the future demands are known, or at least
partially known, as part of the input. However, in many practical scenarios the underlying probability distributions are not available. Moreover, any attempt to create a distributional model of the
demands entails a significant risk of serious misspecification which may lead to very poor policies.
In this paper, we study an online version of the classical joint replenishment problem (JRP)
that has been studied extensively over the years, and plays a fundamental role in broader planning
issues, such as the management of supply chains (e.g. (5, 26)). In particular, following the classical
online framework (8), the assumption is that future demands are entirely unknown and generated
by a worst-case adversary. We consider the JRP model under an online make-to-order coordination
mechanism, where the production of finished goods is triggered only by actual demands, and
no finished goods are held in inventory (13, 19, 25). Make-to-order coordination is a classical
mechanism which is very common in scenarios with highly customized finished goods and high
setup and changeover costs, for example in the steel and glass industries. (The other common
coordination mechanism is make-to-stock, in which finished goods are produced before the actual
demand occurs, and then kept in inventory.)
The main contribution of the paper is the design and analysis of a new primal-dual based
algorithmic approach that leads to policies with robust performance. The performance is analyzed
using the classical concept of competitive ratio (8), in which the performance of the online algorithm
is compared to the optimal offline solution that is computed based on full knowledge of the entire
sequence of demands. Our main result is a 3-competitive deterministic online algorithm for the
online make-to-order JRP. That is, the cost of the online algorithm is guaranteed to be at most 3
times the cost of the optimal offline solution. In addition, we establish a lower bound of 2.64 on the
competitive ratio of any deterministic online algorithm. The online algorithms we develop employ
several new ideas and techniques (discussed in detail below) that we believe can potentially extend
∗
†
Supported by ISF grant 954/11 and BSF grant 2010426.
Part of this research was conducted while the author was a postdoctoral fellow at the IBM, T. J. Watson Research
Center. Partially supported by NSF grants DMS-0732175 and CMMI-0846554 (CAREER Award), an AFOSR award
FA9550-08-1-0369, an SMA grant and the Buschbaum Research Fund of MIT.
‡
Research was supported by EPSRC grant EP/J021814/1, FP7 Marie Curie Career Integration Grant and Royal
Society Wolfson Research Merit Award.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
3
the range of classical inventory management problems to which online and primal-dual algorithms
can be applied and analyzed. In particular, this approach can be very effective in devising robust
policies that can be implemented under minimal knowledge about the evolution of future demands.
The details of the offline make-to-order JRP model are as follows. A set D of demands for N
different commodities is specified over a planning horizon of T discrete periods. Each demand point
(i, t) ∈ D requires certain number of units of commodity i, where i = 1, . . . , N and t = 1, . . . , T . Since
holding inventories is not allowed, demand point (i, t) can be satisfied only from orders placed in
period t or later in time. At the beginning of each period s = 1, . . . , T , we can place an order for
any combination of items, and this order can be used to serve pending demand points that arrived
in period s or earlier in time. Each such order incurs a fixed joint ordering cost K0 , as well as a
fixed item ordering cost Ki for each item (commodity) i = 1, . . . , N included in the order, regardless
of the number of units being ordered. The fixed ordering costs drive us to order in large batches.
This is traded off against delay penalty cost, which captures the costs incurred by allowing demand
points to wait for some amount of time until they are satisfied. For each demand point (i, t) and a
potential order s ≥ t, we let wits be the corresponding late penalty cost incurred by demand point
(i, t), if served from an order in period s. The only assumption is that, for each single demand
point (i, t), the delay penalty cost wits is increasing in s. This includes the case in which a demand
point must be served within a specified time window after its arrival. (In this case wits = ∞ after
the time window.) The goal is to find a feasible ordering policy that minimizes the overall ordering
and delay penalty costs.
The offline JRP model is known to be APX-Hard (4, 30). Levi, Roundy and Shmoys have
proposed a primal-dual 2-approximation algorithm for the offline make-to-stock JRP model (26),
and this has been improved by Levi, Roundy, Shmoys and Sviridenko, who proposed a 1.8approximation algorithm using an LP-rounding approach (27). Recently, Nonner and Souza (30)
studied a natural special case of the offline JRP in which each demand has a strict deadline (i.e.,
the delay penalty is 0 until the deadline and ∞ afterwards). They designed a randomized 5/3approximation for this variant, and proved that even this special case is already APX-hard. (In the
offline make-to-stock JRP model there are holding costs for maintaining physical inventory instead
of delay penalty costs. However, mathematically the make-to-stock and the make-to-order offline
models are equivalent, and all complexity results and algorithms can be transparently converted
to the offline make-to-order variants.) The special case of the offline joint replenishment problem
with a single type of commodity, also known as the single-item lot-sizing problem, is polynomially
solvable via dynamic programming (37) or primal-dual algorithms (for example, (20, 26)).
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
4
In the online make-to-order JRP model, the demand points and the length of the planning horizon
T are not known in advance. Instead, demand points arrive in an online manner, and the ordering
decision made in each time period s is based only on demand points that arrived up to period s.
This assumption is particulary realistic in settings where the demand is highly unpredictable, and
cannot be estimated appropriately from historical data. Indeed, this is the case when the products
are highly customized to customer specific requests. We measure the performance of our algorithms
by the standard competitive ratio between the cost incurred by the online algorithm and the
minimum cost obtained by an offline optimal solution when the input is generated by a worst-case
adversary. The online single-item lot-sizing problem is equivalent to the well-understood TCPacknowledgment problem. Dooly, Goldman and Scott gave an optimal 2-competitive deterministic
algorithm for this problem (15). Karlin, Kenyon and Randall gave an optimal e/(e − 1)-competitive
randomized algorithm (23). Buchbinder, Jain and Naor have recently proposed an analysis of these
algorithms using a primal-dual approach (10).
1.1. Our results and techniques
The main result of this paper is a 3-competitive deterministic algorithm for the online make-toorder JRP model. In addition, we obtain a lower bound of 2.64 on the competitive ratio of any
deterministic online algorithm. We also implemented the algorithm, and present the results of
computational experiments that test the typical empirical performance of our algorithm. In our
experiments the empirical competitive ratio ranges in the interval [1.5, 2.2] with typical value of
less than 2.
The deterministic algorithm for the online TCP-acknowledgement problem (or the online maketo-order single-item lot-sizing problem) (15) is simply based on balancing the ordering cost with the
delay penalty cost. We place an order whenever the cumulative delay penalty cost of the currently
pending demands exceeds K, where K is the fixed ordering cost. However, it can be shown that any
straightforward extension of this idea to the JRP model does not lead to algorithms with bounded
competitive ratio. The fundamental problem is the choice of which items (commodities) should
be included once the decision has been made to place a (joint) order. Intuitively, the dilemma is
whether to include in the order items for which the current cumulative delay penalty costs are
relatively low. Including such items runs into the risk of incurring high item ordering costs because
of unnecessary orders of these items; excluding them runs the risk of incurring high joint ordering
costs due to placing multiple orders, each including only a small number of items. More specifically,
it is not clear whether the future arrivals of demands will justify additional joint orders that can
be used to satisfy the currently pending demands of those items. Instead it may be better to serve
them from the order placed in the current period.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
5
We propose a primal-dual algorithm for the online JRP model. Our primal-dual approach is
based on a novel linear programming relaxation (LP) of the offline JRP model. The LP and its
dual program guide the decisions made by the online algorithm. Specifically, we simultaneously
construct online both a feasible primal integer solution and a feasible dual solution. We then show
that the cost of the primal solution is at most 3 times the cost of the dual solution, obtaining a
3-competitive algorithm. For intuition, it helps to think of the dual variables as budgets that are
being used to pay for the cost of the primal solution, which consists of the joint ordering cost, the
item ordering costs and the delay penalty costs. The budget of each as-yet-unknown demand point
(i, t) is 0 until time t. Starting at time t, the corresponding budget can change until this demand
point is frozen.
We note that our primal-dual algorithm departs from previously known algorithms in rather
significant ways. In particular, the online nature of the problem requires several fundamentally
different algorithmic approaches compared to primal-dual algorithms that were previously designed
for offline versions of the JRP model (26), the facility location problem (22) and other combinatorial
problems (e.g., (18)). For example, all of these algorithms have a second clean-up phase, in which
the initial primal solution is modified to make it cheaper. However, this is not possible in an online
setting, and we need a different approach.
Now we describe the main aspects of the new algorithmic approach that we propose and contrast
it with the previous offline primal-dual algorithms. Joint orders are placed when the budgets of a
subset of demand points are sufficient to pay the joint ordering cost and the item ordering costs
of a certain potential order, as well as the resulting delay penalty costs incurred by serving them
from that order. (This corresponds to a dual constraint becoming tight.) However, this potential
order may be in the past, and because the problem is online it can not be used anymore. Instead
we place an order in the current period, initially including all the corresponding items, and freeze
the budgets of all the demand points that will be served by this order. As already mentioned, the
fundamental issue that arises at this point is whether to include additional items in the current
order even though their current budgets are not sufficient to pay for their respective item ordering
costs. This issue is handled through what we call a simulation step. We temporarily increase the
algorithmic time indicator beyond the current time period, and adjust the budgets of the active (not
frozen) demand points accordingly, assuming that no demand point will arrive in future periods.
Throughout this phase certain dual constraints become tight and this guides the algorithm in
including additional items in the current order. However, at the end of the simulation step all the
dual budgets are decreased back to their original values at the beginning of the simulation step,
and the algorithmic time indicator is again aligned with the current time period. In particular,
it is not guaranteed that the budgets of the corresponding demand points will eventually reach
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
6
their simulation values. Thus, unlike almost all other primal-dual approximation algorithms, our
algorithm is not dual ascent. That is, the budgets of certain demand points can temporarily go
up, and then be decreased, and go up again, until they are frozen. Intuitively, one can think of the
simulation step as a ‘loan’ taken by the algorithm to pay for additional orders of certain items.
It is not clear a-priori that it will be able to fully recap this ‘loan’ in the future. Thus, we need
to make sure that the ‘loan’ being taken is not too high; in other words, we need to carefully
monitor the simulation step and design the right stopping rule. We believe that the concept of
the primal-dual simulation step could have applications in other online and offline settings, and
extend the applicability of primal-dual approximation and online algorithms. In addition, unlike
previous algorithms, the performance analysis of our algorithm is not based on showing how to use
the dual budgets to pay the cost of each order placed by the algorithm separately. Instead, we use
the algorithm to partition the orders into clusters of phases, and then show how to use the dual
budgets to pay for the overall cost of each cluster. Specifically, we show that each dual budget is
not used more than 3 times.
1.2. Literature Review
Most traditional inventory management models assume that the underlying demand distributions
are fully specified as part of the model input. At the same time this is recognized to be a problematic assumption in many practical settings, in which it is unrealistic to expect that the demand
distributions can be characterized. In fact, misspecification of the demand distributions could lead
to meaningless output results. Several alternative approaches have been proposed to overcome this
limitation, in which only partial information about the demand distributions is assumed (e.g.,
moments, support, past historical data). There are also several frameworks (e.g., regret, minmax
and robust optimization, comparison to full knowledge of the distributions) that have been used to
evaluate the performance of the corresponding algorithms. We refer the reader to the recent paper
by Huh at al (21) for an extensive literature review.
Online algorithms and competitive analysis are the most robust framework since one has no
assumptions on the future demands, and they are assumed to be generated by a worst-case adversary (8). Moreover, the relative benchmark of comparing to an offline optimal solution is very stringent. There have been several attempts to apply the online framework to simple inventory models,
such as the well-known newsvendor problem (for a sample of papers see (31, 32, 33, 28, 29, 33, 38)).
However, these models assume a weaker adversary (e.g., one that has to draw the demand from
a given support), and some use a much weaker notion of competitiveness comparing the online
solution to the static offline optimal solution. (This solution has to commit to one action and repeat
it throughout all the periods.) Another approach to restrict the power of the adversary has been
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
7
to assume that while the adversary will choose the worst-case demands (requests), their sequence
of arrivals will be random (14, 2, 17). This framework allows remarkably good performance guarantees under certain (mild) assumptions in some scenarios. Van Den Heuvel and Wagelmans (34)
study an online variant of the classical make-to-stock single item lot-sizing problem. I their model
orders are determined in an online manner and are irrevocable, but the number of units ordered
can be modified later on in an offline manner; they showed that the best possible competitive ratio
in this case is 2, which matches the one obtained by the heuristic proposed in (6). For fully online
and worst-case adversary profit maximization variants of this problem Wagner (39) obtained optimal online algorithms, but the competitive ratios are not constants. Another inventory-scheduling
online model has been studied by (24). In this paper we study the more complex fully online
(multi-item and fixed costs) inventory model of the JRP, and obtain a constant competitive ratio
within the worst-case adversary framework.
The primal-dual approach is a well-studied discipline in the design and analysis of optimization
and approximation algorithms (35). Buchbinder and Naor (11) have recently proposed a primaldual framework for online packing and covering problems. This framework includes, for example,
a large number of routing and load balancing problems, the online set cover problem, paging, and
ad-auctions (3, 9, 7, 10), as well as other problems (See (12) for a survey). Recently, the primal-dual
approach was also used to analyze an easier random arrival model in which the input is generated
by an adversary, but is given to the online algorithm in a random order. In particular, with some
additional mild assumptions a near-optimal solution can be obtained for any packing problem
(See, i.e., (14, 2, 17)). As we shall discuss below, the algorithm we propose in this paper and the
performance analysis require new and more delicate algorithmic ideas (e.g., the simulation step
that we describe below) that depart from previous work.
2. Preliminaries
In this section we formally define our problem. Let H = {1, 2, . . . , N } be the set of item types
(commodities). In the JRP model the cost of an order does not depend on the number of units
ordered, but only on the item types in the order. The cost of an order is composed of a joint
ordering cost denoted by K0 and a fixed item ordering cost of Ki for ordering any number of units
∑
of item type i. Thus, the cost of ordering a set S ⊆ {1, 2, . . . , N } is C(S) , K0 + i∈S Ki . New
demands arrive at times t ∈ {1, 2, . . . , T } for some unknown T . Let T = {1, 2, . . . , T } be the set of
times in the planning horizon. Each demand specifies some item type that is needed. Let D be the
set of demands. Each demand is thus defined by a pair (i, t), where i is the item type associated
with the demand and t ∈ T is the arrival time of the demand.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
8
Every demand (i, t) ∈ D can be satisfied in any time period s ≥ t after its arrival. The delay
penalty cost of satisfying demand (i, t) at time s is wits which is an increasing function of s. It is
convenient to view the delay function in increments between each time s and the subsequent time
s + 1. Let ∆its ≥ 0 be the additional penalty of delaying demand (i, t) from time s until time s + 1.
That is ∆its = wi,t,s+1 − wits .
2.1. Linear Program Formulation and Its Dual
It is not difficult to verify that there exists an optimal offline solution that makes orders only at
times at which new demands arrive (i.e., times t ∈ T). To define a lower bound on the optimal cost
we start by formulating the problem as an integer program, and then consider its linear program
relaxation whose minimum solution is a lower bound on the optimal integral cost. We define for
each set S and time t ∈ T a variable x(S, t) that is an indicator for the event of sending an order for
the types of S at time t. Let z(i, t, s) indicate the event of delaying demand (i, t) from time s until
time s + 1. The cost of any offline algorithm can be described as the linear cost function in line
(1) below. The constraints in line (2) stipulate that for any demand (i, t) and time s greater than
its arrival time, either the demand has been served by some order prior to time s, or it is delayed
at time s. Note that the number of constraints and variables in this LP formulation is exponential
with respect to the number of item types. However, since our proposed algorithm doesn’t require
solving the resulting LP explicitly, it can be implemented efficiently.
min
∑T ∑
t=1
S⊆{1,...,r} C(S)x(S, t) +
∀(i, t) ∈ D, s ≥ t :
∑s
τ =t
∑
∑
S | i∈S
∑
(i,t)∈D
s≥t ∆its
· z(i, t, s)
x(S, τ ) + z(i, t, s) ≥ 1.
(1)
(2)
x(S, τ ), z(i, t, s) ≥ 0
Again, constraint (2) ensures that if a demand (i, t) has not been satisfied by some time s ≥ t,
then one has to charge additional delay penalty of ∆its . The objective function captures the total
resulting order and delay costs. It is readily verified that if the variables are constraint to be integers
{0, 1} then the resulting integer program provides an exact formulation of the problem. Then, the
relaxation provides a lower bound.
Next, we consider (3)-(5) below which is the dual problem of the linear program (1)-(2). The dual
program in this case has an intuitive meaning. In the dual program we have a variable y(i, t, s) for
each demand (i, t) and time s ≥ t. The dual variable can be interpreted as a budget. The objective
of the dual program is to maximize the total budget earned from all demands. Constraint (4)
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
9
states that the budget earned by demand (i, t) between two consecutive times is at most the delay
it incurred between these two consecutive times. Constraint (5) stipulates that the total budget
earned by demands whose type is in S and which arrived prior to time s cannot exceed the cost of
ordering the item types in S. Thus, the intuition is that each demand of some type i earns budget
that pays for its order Ki . After it has paid for its fixed item ordering cost, it starts contributing
to the joint ordering cost K0 .
∑ ∑
max
y(i, t, s)
(3)
(i,t)∈D s≥t
∀(i, t) ∈ D, s ≥ t :
∀S ⊆ {1, . . . , N }, s ∈ T :
∑
y(i, t, s) ≤ ∆its
∑
(i,t)|t≤s,i∈S
r≥s y(i, t, r) ≤ C(S)
(4)
(5)
y(i, t, r) ≥ 0
3. The Online algorithm
In this section we describe our online algorithm. We start with intuition. It is instructive to think
first about a much simpler setting with only a single item type. Suppose that a demand (for this
one type) arrives. If no additional demand arrives in the near future, it is best to serve this demand
right away. However, if an additional demand arrives soon enough then we would benefit from
delaying the first demand and serving both demands together. Of course, we do not know which
of the two will happen. Thus, the question is how much delay cost should we incur before making
an order. It can be shown that the optimal deterministic approach is to wait until the delay cost
incurred exactly equals the order cost. This approach results in an optimal 2-competitive algorithm
(15). In our terminology, this corresponds to an algorithm that waits until the accumulated budgets
of all demands pay for their order. However, it is not hard to show that such an algorithm will fail
in the more complex JRP studied here. Intuitively, the bad example would force such an algorithm
to incur the ordering cost K0 too often. Suppose we have many item types, with orders for each at
time 0, and their respective waiting costs increase rapidly close to their deadlines but the deadlines
are equally distributed in time. Then the previous algorithm would open an order for each demand
separately very close to its deadline and incur the joint ordering cost K0 for each demand, and the
optimal algorithm will order items in batches and will not pay K0 as often. Thus, new ideas are
needed.
Suppose that a set of types of items S have gathered an accumulated budget that may pay for
the order cost of the set of types in S. That is, the accumulated budget is at least the joint ordering
cost along with the additional fixed item order cost of each type in the set S. We certainly want
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
10
to make an order to the set of types in S. However, since this ordering already pays for the joint
ordering cost, we might want to add other types that still have not fully paid for their fixed cost.
Otherwise, we might need to pay the joint ordering cost several times while the optimal solution
joins all these demands together and pays the joint ordering cost only once. On the other hand,
it is not wise to add all the types that have not yet paid for their fixed cost, since more demands
of these types may arrive in the near future. The question is how many and which ones of these
additional “premature” types should be added to the current order.
The main novel idea that is used in our algorithm is the simulation step that uses the current
known information to decide which of the types will be added to the current joint order. In the
simulation step we virtually increase the algorithmic time to future time periods assuming that
no additional demands arrive. During this process we increase the delay cost of the demands that
have arrived and are not satisfied yet, and so additional types manage to “pay” for their order
cost. These types are added to the current order, and their corresponding demands become “half
active” (defined below). Continuing the simulation for a long time has the benefit of adding more
types to the current order that already paid for the joint order cost. However, each additional type
that is added prematurely adds to the current order cost more than its current budget. Since more
demands of that type might arrive in future times, the “future” budget that convinced us to add it
to the current order is not guaranteed. Therefore, the idea is to continue with the simulation step
as long as the extra future budget that we use is at most the joint order cost, K0 . This extra budget
exactly balances between these two options. The simulation step induces a rather unique dynamics
for how the values of the dual variables change. Unlike almost all existing primal-dual algorithms
in which the dual variables only increase, in our algorithm the value of each dual variable can both
increase and decrease.
3.1. Algorithm Description
We are now ready to formally describe our algorithm. Our online algorithm uses an algorithmic
time indicator τ that starts at time 0 and is increased continuously as time progresses. At each
discrete time s the algorithm simulates a continuous increase of the time indicator τ from time s
to s + 1. Any orders that are indicated at algorithmic time τ are actually made at time s = ⌊τ ⌋.
During any time τ , each demand can be in any of the three states:
• Active demands are demands that are still unsatisfied by the algorithm.
• Half Active demands are demands that are satisfied by the algorithm still play some role in
our algorithm. Intuitively, these demands were satisfied ”prematurely” and we want them to pay
for some other costs.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
11
• Inactive demands are demands that are satisfied by the algorithm and play no role in future
times. That is, their corresponding dual variables cannot change anymore.
Each demand (i, t) is active from its arrival time until it is satisfied at some algorithmic time
τ . At time τ the demand (i, t) may become half active for a certain time, and then it becomes
inactive forever. Let τe (i, t) be the time demand (i, t) becomes half active. Let τf (i, t) be the
algorithmic time demand (i, t) becomes inactive. If τf (i, t) > τe (i, t) then during the time interval
[τe (i, t), τf (i, t)] the demand (i, t) is half active. When a new demand arrives and is not served yet,
we set τe (i, t) = τf (i, t) = ∞. Note again that τe (i, t) and τf (i, t) are algorithmic times and do not
have to be integral.
Our proposed online algorithm maintains during each time τ a list of active (unsatisfied) demands
Aτ ⊆ D and a set Hτ ⊆ D of half active demands. These sets contain, of course, only demands that
arrived prior to time τ . At the beginning of the planning horizon A0 consists of demands that
arrived at time 0 and H0 = ∅. If the algorithm changes the status of a set of demands at time τ then
+
we denote by A−
τ and Aτ the set of active demands just before and after this change. Similarly, let
Hτ− and Hτ+ denote the set of active demands just before and after the change.
The algorithm maintains the following assignment to each dual variable y(i, t, s). Until τ becomes
s the variable is zero. If demand (i, t) is active or half active at time τ ≥ s then the variable is
increased continuously by the linear function y(i, t, s) ← (τ − s)∆its (Alternatively, dy(i, t, s)/dτ =
∆its ). The increment stops whenever the demand becomes inactive or when τ = s + 1, the earlier
of these events. From that point on the dual variable remains a constant with value min{(τf (i, t) −
s)∆its , ∆its }.
Orders are triggered when dual constraints become tight due to increments of the dual variables.
To this end, we consider at time τ any set S and any time s ≤ τ and check whether the total
sum of the dual variables that contribute to the suitable dual constraint is exactly C(S). Demands
that contribute to the constraint are demands whose type is in S and their arrival time is prior to
s. We may consider only times s that are integral (i.e. s ∈ T), since if the constraint is tight for
non-integral time τ ′ then moving backwards to time ⌊τ ′ ⌋ can only increase the total sum. This is
true since in our model no new demands arrive between time ⌊τ ′ ⌋ and time τ ′ .
When reading the algorithm description note the similarity between the dynamics of the algorithm during the simulation step and the dynamics of the algorithm during the main part. The
only difference is that demands that are being added to the order in the simulation step are marked
as half active and not inactive as in the main part of the algorithm. The formal description of the
algorithm is outlined in what follows.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
12
Inventory algorithm: Upon arrival of a demand (i, t) set τf (i, t) = τe (i, t) = ∞.
At each algorithmic time τ :
Keep the invariant that for any set of types S and time s ≤ τ :
∑
∑
(i,t)|t≤s,i∈S
r≥s
y(i, t, r) ≤ C(S).
1. For each demand that is active or half active, increase y(i, t, ⌊τ ⌋) gradually at rate
dy(i, t, ⌊τ ⌋)/dτ = ∆it⌊τ ⌋ .
2. If at time τ , there exist a set of ∑
types Sτ and time
∑ sτ such that the dual constraint that
corresponds to (Sτ , sτ ) is tight (i.e., (i,t)|t≤sτ ,i∈Sτ r≥sτ y(i, t, r) = C(Sτ )):
(a) Set all half active demands (i, t) such that there exists a variable y(i, t, r) that
appears in the constraint to be inactive. Formally, if (i, t) ∈ Hτ and also i ∈ Sτ , t ≤ sτ then
set τf (i, t) = τ .
(b) If there are no active demands that contribute to the tight constraint return to (1).
Otherwise:
i. Set all half active demands to be inactive. Note that we may change status of some
demands that do not contribute to the tight constraint.
ii. If sτ is later than the time of the previous order made by the algorithm, then set
an order at time ⌊τ ⌋ that includes all item types in the tight constraint Oτ , Sτ .
iii. If sτ is earlier than the time in which the previous order made by the algorithm
was placed, then set an order at time ⌊τ ⌋ that includes only the set of item types of demands
that are active and contribute to the tight constraint. Formally:
Oτ , {i | ∃(i, t) ∈ Aτ such that i ∈ Sτ , t ≤ sτ }
iv. Set all active demands (i, t) whose type i ∈ Oτ to be inactive.
Simulation step:
• Simulate the execution of the algorithm in future times τ (future) > τ (assuming no new
demands arrive).
• If at some time τ (future) there are no active demands left, or the accumulated value
of the dual variables y(i, t, s) from time τ until time τ (future) is at least K0 then stop the
simulation step and return to line (1).
• Otherwise: if at time τ (future) new dual constraint becomes tight (i.e., there exists a set
′
S and time s(past) such that
∑
∑
y(i, t, r) = C(S ′ )
(i,t)|t≤s(past),i∈S ′ r≥s
1. Add to the order Oτ all types in
{
}
O′ , i | ∃(i, t) ∈ Aτ (future) such that i ∈ S ′ , t ≤ s(past)
2. Set all active demands (i, t) whose type i ∈ O′ to be half active at time τ and inactive
at time τ (future) (τe (i, t) = τ , τf (i, t) = τ (future)) and continue the simulation.
Note that the set of half active demands is the set of demands that were added to the order
in the simulation step, but their corresponding dual variables (budget) may still contribute the
the value of the dual solution (in future times). It is not hard to verify that the algorithm can
be implemented efficiently. The main procedure we need is to find out at time t if there are dual
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
13
constraints that are tight. To this end, we may consider all arrival times of the currently active and
inactive demands. Then, to check if there is a tight constraint that starts at some arrival time s, we
sum up the contributions of all item types i that contribute at least Ki value to a dual constraint
that starts at time s. It is easy to verify that if there is a tight constraint that starts at time s,
then the constraint with this subset of item types is also tight.
3.2. Analysis
The idea of the analysis is to construct a primal solution whose cost is the same as the cost of the
solution obtained by the online algorithm (this is done easily by considering the behavior of the
algorithm). Next, we construct a corresponding feasible dual solution based on the variables used
by the online algorithm. We then show that the cost of the primal solution is at most three times
the cost of the dual solution. Since the cost of the dual solution is a lower bound on the optimal
offline solution, it will follow by weak duality that the online algorithm is 3-competitive.
The primal and dual solutions are defined simply. The primal solution set an order at time ⌊τ ⌋
to all the items ordered by the algorithm at the interval [⌊τ ⌋, ⌈τ ⌉]. Also we set z(i, t, s) = 1 for
any demand (i, t) and time s such that τe (i, t) ≥ s + 1 and otherwise we set z(i, t, s) = 0. Note
when a demand becomes half active it is already served and so we can set z(i, t, s) = 0 for any s
such that τe (i, t) < s + 1. The dual solution is constructed by the assignments to the dual variables
y(i, t, s) determined during the execution of the algorithm. The following Lemma proves that the
dual solution produced this way is feasible.
Lemma 1. The assignment y(i, t, s) for each demand (i, t) and time s that is maintained during
the execution of the algorithm defines a feasible dual assignment to (4)-(5).
Proof.
First, since each y(i, t, s) ≤ ∆its all constraints (4) are satisfied. Assume to the contrary
that the assignment violates one of the constraints (5). Then there exists a set S and time s such
that:
∑
∑
y(i, t, s) > C(S)
(i,t)|t≤s,i∈S r≥s
Thus, by this (false) assumption there must be a time τ during the execution of the algorithm
for which
∑
∑
y(i, t, s) = C(S).
(i,t)|t≤s,i∈S r≥s
Also, there must be some demand (i, t) with type i ∈ S that arrived prior to time s and is active
or half active at time > τ . This follows because the dual constraint is violated at time > τ . However,
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
14
by the algorithm behavior (lines (2a),(2(b)iv)), at the algorithmic time τ all active and half active
demands that contribute to the constraint become inactive, and so we are done.
In order to prove that the cost of the primal solution produced by the algorithm is at most 3
times the cost of the dual solution we need further definitions.
Along the execution of the algorithm many dual constraints become tight. Dual constraints may
become tight either in the main loop of the algorithm or in the simulation step. As discussed earlier,
some of the constraints that became tight during the simulation step may not become tight later
on during the real execution of the algorithm. We elaborate on this issue later on. Consider R to
be any constraint (5) in the dual LP that became tight during the algorithm execution. Such a
constraint is defined by (W (R), [τs (R), τe (R)]), where W (R) is the set of item types of the dual
constraint, τs (R) is the starting time of the dual constraint, and τe (R) is the algorithmic time in
which the constraint became tight. We say that variable y(i, t, s) contributes to the constraint R if
it belongs to R (i.e., i ∈ W (R), t ≤ τs (R) ≤ s ≤ τf (i, t)) and have strictly positive value. Note that
only demands that are active or half active at time s may contribute to constraint R. We next
define the set of demands that contribute to the constraint R. These are demands that (i) arrived
prior to τs (R). (ii) The type of the demand belongs to the set of types of constraint. (iii) The
demand became inactive only strictly after τs (R) (and therefore some dual variable of the demand
contributes to the constraint R. Formally,
D(R) = {(i, t) | i ∈ W (R), t ≤ τs (R), τf (i, t) > τs (R)}
Next, for each constraint R we define W̃ (R) ⊆ W (R) to be the set of types of demands that
are active or half active at the time moment when the constraint R becomes tight. Informally
there might be demands that contribute to the constraint at first, but became inactive before the
algorithmic time in which the constraint became tight. These types do not trigger any events in
the algorithm since they don’t increase anymore. The algorithm only change the status of demands
in W̃ (R). Formally,
W̃ (R) = {i′ | ∃(i, t) ∈ D(R), i′ = i, τf (i, t) ≥ τe (R)} .
Finally, we define D(W̃ (R)) to be the set of demands in D(R) of types from the set W̃ (R).
Informally, these are the demands that are “taken care” by the algorithm at time τe (R) that the
constraint become tight. Formally,
{
}
D(W̃ (R)) = (i, t) | (i, t) ∈ D(R), i ∈ W̃ (R)
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
Phase p
Phase p+1
15
Phase p
Phase p+1
Rp,1
Rp
Tight constraints that contained active demands
Ts(p)
(a)
Figure 1
Te(p)
Tf(p) Ts(p+1)
(b)
Phase division (a) and the constraint Rp,1 and Rp The dashed constraints are constraints that became
tight during the simulation step and did not cause an order when they became tight.
Next, we consider the orders made by the algorithm. Let τ1 ≤ τ2 ≤ τ3 ≤ . . . be the algorithmic
times in which the algorithm makes an order. The algorithm makes an order whenever it encounters
a tight constraint that contains active demands, i.e. in our new notation D(R) ∩ A−
τe (R) ̸= ∅. Let
R1 , R2 , . . . be the tight constraints that caused these orders. We partition the time interval into
phases. A new phase p starts whenever the starting time of Ri is later then the ending time of the
next constraint Ri−1 (i.e. τs (Ri ) > τe (Ri−1 )). The first phase starts at τs (R1 ). An example of such
a partition appears in Figure 1 where we view each constraint R as an interval between τs (R) and
τe (R).
We separate the first constraint that started each phase and other constraints that became tight
in the same phase. Note that each phase contains at least one tight constraint that triggered
the first order. Let Rp,1 be the first constraint that became tight in phase p. Let Rp be all the
other constraint that became tight during phase p. The set Rp also includes the constraints that
became tight during the simulation step of the algorithm and possibly did not become tight during
the actual execution of the algorithm due to the beginning of phase p + 1 (See Figure 1). Let
τs (p) = τs (Rp,1 ) be the start of a phase p that is equal to the starting time of the first constraint
that became tight during that phase. Let τe (p) = τe (Rp,1 ) be the time in which Rp,1 became tight.
Finally, let τf (p) be the ending time period of the phase p that is the time period in which the last
constraint that caused an order in the phase p became tight. This definition induces the following
partition of the time interval τs (p) ≤ τe (p) ≤ τf (p) < τs (p + 1) ≤ τe (p + 1) ≤ . . ..
We next want to bound the total cost of the online algorithm using the value of the dual solution.
We start with some intuition that will make the technical lemmas and the algorithm behavior more
clear. Bounding the delay cost is quite easy. In Lemma 3 we show that the delay cost incurred by
the online algorithm is at most the value of the dual solution. Actually we give a slightly better
bound (that is used later on), since we sum only dual variables of active demands. Bounding the
order cost is harder. The proof reveals the ideas behind the simulation step and the partition into
phases. The first constraint in each phase is tight and thus the total “budget” inside it is enough
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
16
to pay for both the joint order cost of the first order in the phase and the fixed order cost of all
types ordered in this first order (excluding the types that are added in the simulation step). The
main observation is that if the phase did not end after the first order, then all the constraints
that become tight during the simulation step also become tight during the actual execution of the
algorithm and with the same order. We formalize this in the following lemma:
Lemma 2. For each phase p, the constraints that become tight in the interval (τe (p), τf (p)] are
exactly the same constraints that became tight during the simulation step done by the algorithm.
Proof.
All the tight constraints that become tight during this time interval have a starting time
earlier than the ending time of the previous order; otherwise, a new phase starts by definition.
Therefore, only demands that arrived prior to the previous order (in the phase p) may contribute to
these constraints. Since the simulation step simulates exactly the events that involve demands that
have already arrived, the constraints that became tight are exactly the constraints that became
tight during the simulation step, and they become tight in the same order as in the simulation
step.
In particular, note that the constraint that became tight and caused the second order in the
phase is constraint that became tight after accumulating of value of at least K0 in the dual. This
is true for each successive order as long as the current phase did not end. The value accumulated
this way is enough to pay the joint ordering cost of each of the orders from the second to the last.
Finally, we need to pay the fixed cost of the the types that were ordered during the second to
the last order in the phase and also for the types that were added due to the simulation step in
the first order. We want to sum the dual profit only until the last order of the phase in order to
bound the number of times we use each dual variable. We prove that each type that was added
due to a constraint that actually became tight before the last order of the phase can pay for its
fixed ordering cost. The only problem is with types that were added in the last order of the phase
due to the simulation step. These types are using future tight constraints. Since the phase ended,
this future budget cannot be used since it might never become available. However, by the behavior
of the algorithm during the simulation step the total future budget that is used is bounded by at
most K0 . Therefore, we may charge this extra cost to the budget of the first tight constraint in the
phase.
Lemma 3. The total delay cost of the online algorithm is at most the dual cost:
∑
s<τe (i,t)
∑
(i,t)∈D
s=t
y(i, t, s)
(6)
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
Proof.
17
By the construction of the primal and dual solutions, each time the algorithm defines
z(i, t, s) = 1 of an active demand (i, t), then also y(i, t, s) = ∆its . Note that in this case s+1 ≤ τe (i, t).
The following more involved lemma bounds the total order costs made by the online algorithm.
Intuitively, we will eventually bound the total ordering cost in every phase p by summing (sometimes twice) the dual budget obtained only inside the time interval of phase p. This allows us to
obtain later on our bound.
Lemma 4. The total order cost of the online algorithm is at most:
∑

2 ·
p∈P
∑
s<τe (p)
∑
y(i, t, s) +
∑
∑
y(i, t, s) +
s=τe (p) (i,t)∈D
s=τs (p) (i,t)∈D (W (Rp,1 ))
Proof.
∑
s<τf (p)
∑
R∈Rp (i,t)∈D (W̃ (R))
For every order of the set S of types, we pay K0 +
∑
i∈S

s<min{τe (R),τf (p)}
∑
y(i, t, s)(7)
s=τs (R)
Ki . We prove that for each
phase p, the total sum of terms that correspond to phase p is at least the total order cost of the
algorithm during that phase. As previously observed, the accumulated value of the dual variables
between each two orders after the first order in a phase is at least K0 . Thus, the sum of all dual
variables from the time of the first order of a phase until the time of the last order in a phase fully
pays for all joint order costs from the second to the last order of the phase. Formally, if there are
∑s<τ (p) ∑
M orders during the phase then: s=τef(p) (i,t)∈D y(i, t, s) ≥ (M − 1)K0 .
The second observation is that since the first constraint in each phase p is tight then
∑
∑
s<τe (p)
∑
y(i, t, s) = K0 +
s=τs (p) (i,t)∈D(W (Rp,1 ))
Ki
(8)
i∈W (Rp,1 )
Up to now, we charged to the dual variables all joint ordering costs during the phase and also
the fixed ordering cost of types that were ordered during the first order of phase p, excluding the
types that were added to the first order due to the simulation step. We are left with the fixed
ordering cost of all types that were ordered from the second to last order of phase p and the types
that were added to the first order in the phase due to the simulation step. We claim that for each
constraint R ∈ Rp that became tight in the actual execution of the algorithm or in the simulation
step:
∑
∑
s<τe (R)
(i,t)∈D(W̃ (R)) s=τs (R)
y(i, t, s) ≥
∑
i∈W̃ (R)
Ki .
(9)
18
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
The inequality (9) means that the dual variables corresponding to active demands of the inequality R are enough to pay for item ordering costs. Assume that this is not true. Then there exists
some tight constraint R ∈ Rp such that
∑
∑
∑
s<τe (R)
y(i, t, s) <
(i,t)∈D(W̃ (R)) s=τs (R)
Ki
i∈W̃ (R)
∑
∑s<τe (R)
However, since constraint R became tight we get that
s=τs (R) y(i, t, s) = K0 +
(i,t)∈D(R)
∑
i∈W (R) Ki . Since D(W̃ (R)) contains all the demands of type W̃ (R) that contribute positive value
to the demand R we get by subtracting the two equations that:
∑
∑
∑
s<τe (R)
y(i, t, s) =
(i,t) |i∈(W (R)\W̃ (R)),t≤τs (R) s=τs (R)
∑
s<τe (R)
y(i, t, s)
(i,t)∈D(R),(i,t)∈D(
/ W̃ (R)) s=τs (R)
∑
> K0 +
Ki
i∈(W (R)\W̃ (R))
This contradicts the fact that the online algorithm holds at each time a feasible dual solution
since the dual constraint that is suitable to the set of types W (R) \ W̃ (R) and the time t = τs (R) is
violated. The online algorithm also maintains a feasible dual solution during the simulation step,
so this holds also in the simulation step.
All constraints that became tight during the simulation steps made before the last order in the
phase also became tight in the actual running of the algorithm and therefore are able to pay for
their item ordering cost by the corresponding dual variables. The only problem is with constraints
that became tight during the simulation step made in the last order of a phase. We can only make
use of the values of the dual variables until the time of the last order. The main observation is
that by the algorithm’s behavior the extra budget that is used is at most K0 . Thus, if there are M
orders during the phase we obtain
∑
Order cost ≤
∑
s<τe (p)
y(i, t, s) + (M − 1)K0
(i,t)∈D(W (Rp,1 )) s=τs (p)
+
∑
∑
∑
s<min{τe (R),τf (p)}
R∈Rp (i,t)∈D(W̃ (R))
∑
s<τe (p)
≤2
∑
+
∑
R∈Rp (i,t)∈D(W̃ (R))
∑
s<τf (p)
y(i, t, s) +
s=τs (p) (i,t)∈D(W (Rp,1 ))
∑
y(i, t, s) + K0
(10)
s=τs (R)
∑
y(i, t, s)
s=τe (p) (i,t)∈D
∑
s<min{τe (R),τf (p)}
s=τs (R)
y(i, t, s)
(11)
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
19
The first term in inequality (10) bounds the joint ordering cost K0 of the first order in the phase
and the fixed ordering cost of each of the types in the first constraint that became tight. The second
term in (10) is the joint ordering cost of all orders from the second to the last. The third term is
the fixed ordering cost of all types that were ordered in the first order due to the simulation step
and the fixed costs of types ordered in the second to last order of the phase. Note that we sum
only until the minimum between the time each constraint became tight and the last order in the
phase. Thus, we add an extra cost of K0 of the extra future budget that was used. Inequality (11)
follows directly from Equation (8).
We next prove a useful claim that helps us proving our final result. An order of an item with
type i at time s by our algorithm is always caused by some dual constraint R becoming tight. One
option is that constraint R became tight at time s ≤ τ < s + 1 and contained an active demand
of type i. Another option is that during the simulation step done at the algorithmic time τ some
constraint R became tight at time τe (R) > s and caused an order at time s. In the next Lemma
we take two successive times t1 and t2 in which the algorithm makes an order to an arbitrary type
i. We prove that the starting time τs (R) of the second constraint that caused an order of type i
must be larger than t1 . Intuitively, this means that an order to type i “resets” all the constraints
that contain type i.
Lemma 5. Let t1 , t2 be two successive times in which the online algorithm makes an order for some
type i. Let τs (R2 ) be the beginning time of the second constraint that became tight (during the real
time or during the simulation) and caused an order of type i at time t2 ≤ τe (R2 ). Then τs (R2 ) > t1
Proof.
The second constraint became tight in real time or during the simulation at time τe (R2 ) ≥
t2 . This constraint must contain at time t2 an active demand (i, t) with type i (otherwise, it doesn’t
cause an order of type i). In addition, by the properties of the dual constraints the constraint only
contains variables of demands that arrived prior to τs (R2 ). Thus, demand (i, t) is active from time
τs (R2 ) until time t2 . At time t1 ≤ t2 there was an order of type i, and so the algorithm changed the
status of all the demands of type i that arrived prior to t1 to either half active or inactive. Thus,
it is not possible that τs (R2 ) ≤ t1 .
The next lemma bounds the number of times each dual variable is used in Equation (7). This
will allow us to bound the competitive ratio of the algorithm.
Lemma 6. The total number of times each y(i, t, s) appears in Equation (7) is at most twice if
s < τe (i, t) and at most 3 times if
s ≥ τe (i, t).
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
20
Proof.
Suppose first that y(i, t, s) appears in the first constraint in some phase p. By our
definitions it means that τs (Rp,1 ) ≤ s < τe (Rp,1 ) and i ∈ W (Rp,1 ). In this case it appears with
coefficient 2. We prove that in this case it does not appear in any sum of any other constraint in
Rq for any q.
The algorithm makes an order to the types in W (Rp,1 ) at time τe (Rp,1 ). By our definition of
phases τs (Rp,1 ) ≤ s is larger than the time of the last order at phase p − 1 and thus since we sum
the variables in phase p − 1 only until τf (p − 1) < τs (Rp,1 ) ≤ s, then y(i, t, s) cannot appear in any
R ∈ Rq when q < p.
Assume now that there is another tight constraint R′ with set W ′ (R′ ) that contains type i which
became tight later than Rp,1 during the execution of the algorithm, and contains the variable
y(i, t, s). Since this constraint contains the variable y(i, t, s) then it has a beginning time τs (R′ ) ≤
s < τe (Rp,1 ). On the other hand, this constraint caused an additional order of the type i after
time τe (Rp,1 ). Thus, by claim 5 it must has a beginning time τs (R′ ) > τe (Rp,1 ) which leads to a
contradiction, and so we are done.
We therefore consider from now on only variables y(i, t, s) that do not appear in the first constraint of the phase p. Such a variable may appear at most once in the second term of Equation
(7).
We now bound the number of appearances of a variable y(i, t, s) in the third term of Equation
(7). We prove that if s < τe (i, t) then it appears at most once in a sum of some tight constraint R.
If s ≥ τe (i, t) we prove that it appears in at most 2 sums of tight constraints.
Take a variable y(i, t, s) such that s < τe (i, t). We prove that it appears at most once in a
sum of some tight constraint R. Let R be the tight constraint that contains the variable y(i, t, s)
and that caused the first order that served demand (i, t). This order occurred at time ⌊τe (i, t)⌋
and the demand (i, t) became half active at time τe (i, t). Assume to the contrary that there is
another tight constraint R′ with set W (R′ ) that contains type i, caused an order later during the
algorithm execution, and contains the variable y(i, t, s). Since this constraint contains the variable
y(i, t, s) then it has a beginning time τs (R′ ) ≤ s ≤ τe (i, t). On the other hand, this constraint caused
additional order of the type i after time τe (i, t). Thus, by claim 5 it must have a beginning time
τs (R′ ) > τe (i, t) which leads to a contradiction.
Assume now that we take a variable y(i, t, s) such that s > τe (i, t). We prove that it appears in
at most two sums of tight constraints. In particular, we prove that it can appear at most once in a
constraint R such that τs (R) < τe (i, t) and at most once in a constraint such that τs (R) ≥ τe (i, t).
Let R be a tight constraint that contains the variable y(i, t, s), has beginning time τs (R) < τe (i, t),
and that caused the first order that served demand (i, t). This order happened exactly at time
⌊τe (i, t)⌋ when the demand changed its status. Assume to the contrary that there is another tight
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
21
constraint R′ that contains type i, caused an order of type i later during the algorithm execution,
and has beginning time τs (R′ ) < τe (i, t). On the other hand, this constraint caused additional order
of the type i after time τe (i, t). Thus, by claim 5 it must have a beginning time τs (R′ ) > τe (i, t)
which leads to a contradiction.
To see that there can be at most one constraint such that τs (R) ≥ τe (i, t) that contains the
variable y(i, t, s) we note first that the demand (i, t) is half active at time s. This follows simply
because s ≥ τe (i, t) and the demand is not inactive since otherwise y(i, t, s) should be equal to
zero. The first order of type i happened when the demand changed its status at time ⌊τe (i, t)⌋.
Since we sum only until the constraint became tight or the end of the phase, the next order of
type i happened after time s. Let R be the tight constraint that contains the variable y(i, t, s),
has starting time τs (R) such that τe (i, t) ≤ τs (R) ≤ s, and that caused the first order of type i
after time s. Assume to the contrary that there is another tight constraint R′ that contains type i,
caused an order to i later during the algorithm execution, and contains the variable y(i, t, s). Since
this constraint contains the variable y(i, t, s) it must be that it has a beginning time τs (R′ ) ≤ s.
On the other hand, this constraint caused an additional order of the type i after the order time
of the constraint R. Thus, by claim 5 it must has a beginning time τs (R′ ) > s which leads to a
contradiction.
Combining Lemmas 3, 4 and 5 we obtain
Theorem 1. The algorithm is 3-competitive.
3.3. Computational Results
In this section, we present the results of computational experiments that test the typical empirical
performance of our algorithm for the joint replenishment problem with online arrival. We carried out
different scenarios of arrival parameters. Our typical input had time horizon T = 2500. Demands for
items of type i arrived as a poisson process meaning that the time between each pair of consecutive
events has an exponential distribution with parameter Λi . Recall that our algorithm has worst
case guarantee, and it does not try to learn the distribution of the input over time, so running on
longer time horizons, or changing the distribution in the middle of the process will not affect its
performance. We checked the performance of our algorithm with about 5 item types and various
values of K0 , K1 , . . . , Ki . We used mainly linear delay penalty function that had a different slope
for every item type. For such instances, we also managed to find the optimal integral solution using
CPLEX software (1). This optimum was used to compute our actual competitive ratio.
The empirical competitive ratio of our algorithm ranges in the interval [1.5, 2.2] with typical
value of less than 2. These results were obtained without any additional heuristics that we could
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
22
Time Steps
2500
2500
2500
2500
2500
Table 1
K0
Ki
10 2,3,5,8,11
10 2,3,5,8,11
20 2,3,5,8,11
20 2,3,5,8,11
10 5,8,10,12,15
Delay-penalty factor
Arrival rate
Competitive ratio
0.2 (all)
0.04 (all)
2.16
0.2 (all)
0.04, 0.03, 0.03, 0.02, 0.01
1.92
0.1,0.2, 0.3, 0.4, 0.5
0.01 (all)
1.73
0.5, 0.4, 0.3, 0.2, 0.1
0.02 (all)
1.98
0.5, 0.4, 0.3, 0.2, 0.1
0.02 (all)
1.97
The empirical competitive ratio for several randomly generated inputs. Competitive ratio was
computed with respect to the optimal offline solution obtained by CPLEX.
apply. It is not expected that an online algorithm will be able to compete perfectly with an optimal
offline solution that knows the whole input sequence. Thus, these results mean that with typical
non-adversarial input the algorithm indeed performs much better than the worst case 3 guarantee.
Table 3.3 lists several typical input parameters along with the algorithm performance.
4. Lower Bounds
Known lower bound techniques for the TCP acknowledgement problem do not extend readily to
JRP and thus we required new ideas. In the following we prove the following lower bounds.
Theorem 2. No deterministic online algorithm for the single-item case has competitive ratio less
than 2.
Theorem 3. No deterministic online algorithm for the 2-item case has competitive ratio less than
2.46.
Theorem 4. No deterministic online algorithm for the 3-item case has competitive ratio less than
2.64.
Our lower bound employs a technique that, to the best of our knowledge, has not been used in
previous related work. The technique is to drastically increase the rate at which costs accumulateat times that are, of course, unknown to the online algorithm. This allows the offline algorithm to
leave some requests unserved and ignore the additional costs so incurred. While not a particularly
realistic feature of practical problems, it adds a new trick to the offline adversary designer’s toolkit
in some problem settings.
We first illustrate a technique to be used in the multi-item case by showing a lower bound of 2
in the single-item case. The proof of Dooly et al. (15) for TCP acknowledgement applies in this
case, since different wait cost functions can be simulated by multiple TCP packets. Our technique
amounts to a new, alternate proof. Their proof achieves a lower bound of 2 by allowing the offline
solution to pay only every other acknowledgement (order cost) paid by the online algorithm, and
to pay wait costs on only half of the demands whereas the online algorithm pays wait costs on all
demands. Intuitively, we can not get a lower bound greater than 2 with this technique because it
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
23
batches only two orders that are paid separately by the online algorithm. We need to be able to
force the online algorithm to balance the order and wait costs individually for different item types,
and also to force it to pay the joint order cost for each order of each item type whereas the offline
solution pays the joint order cost only once for many orders of all item types. This will be seen in
detail in Section 4.2 below.
We will think of the adversary and the offline algorithm as a single entity; whichever term is
more natural in each context will be used. We will refer to the online algorithm simply as “online.”
The offline solution we construct will not necessarily be the optimal one, but of course it will upper
bound the optimal cost. Our lower bounds are constructed assuming time is continuous; this can
be approximated to arbitrary precision by fine granularity of discrete time steps. It will be more
convenient to express the delay cost for each order using absolute time. We write w(t) as the total
accumulated delay cost, which we call the wait cost, if an order is placed at time t.
4.1. Warmup: the single-item case
The tradeoff we must exploit, of course, is between the wait cost and the order cost. We want to
let offline choose the cheaper of the two and force online to balance them. Since each demand must
eventually be satisfied, offline needs to be able to amortize the order cost of multiple demands
in the case that the wait cost is the cheaper. We do this by collecting multiple demands into a
single order satisfying all the demands at once. This must be done after online has ordered for each
demand individually. Since offline keeps many demands open that are already satisfied by online,
we need a way to keep the wait costs for all those demand from accumulating too much. We do this
by “zooming,” making successive demands whose wait costs increase at ever-increasing rates. We
“zoom in” to a much finer time scale each time we wish offline to pay just the wait cost whereas
online must pay both wait cost and order cost.
Proof of Theorem 2.
Without loss of generality, let K = 1 be the single-item order cost. The
adversary first introduces a demand with wait cost increasing linearly with slope 1; i.e., w(t) = t.
Online waits until some time t1 and then orders, so its total cost is t1 + 1. Offline has two choices:
order the item and pay 1, in which case it may as well order at time 0 and thus pay 0 wait cost, or
pay the wait cost t1 and delay the order. Since it defers the order until some later time in the second
case, offline will pay some additional wait cost. The adversary must make this wait cost negligible.
It does this by introducing the next demand with a much greater rate of wait cost increase. For the
new demand, the wait cost increases at rate
1
ϵ
for some small ϵ; i.e., w(t) = 1ϵ (t − t1 ). Subsequent
demands will repeat this if needed, so the ith demand’s wait time grows at rate 1/ϵi−1 . Wait times
(not costs) for successive demands will decrease geometrically as will become clear. Offline will
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
24
eventually order before time t1 + 2ϵ provided ϵ ≤ 1/2, and thus pay an extra wait cost less than 2ϵ
for the first demand.
Our adversary strategy is then as follows. Initially demand an item with wait cost w(t) = t. Let
t1 be the time online orders the item. If t1 ≥ 1, offline orders at time 0 and pays 1 which is at
most half of online’s cost. Otherwise, zoom, and repeat at a time scale 1/ϵ times finer; i.e., issue
a demand at t1 with wait cost w(t) = 1ϵ (t − t1 ). In this case also offline has paid at most half of
online’s cost for the first demand, and will later pay an additional wait of no more than 2ϵ for the
first demand. Continue making demands such that w(t) = ϵ−(i−1) (t − ti−1 ), where ti denotes the
time of online’s ith order. Stop when either
1. online’s wait cost for an order is at least 1, in which case offline will order immediately after the
demand arrives and pay the order cost 1 which will satisfy the current demand and also satisfying
all outstanding demands “for free,” or
2. 1/ϵ demands have been made. In this case, we will charge equal fractions of the single order
cost 1 to each of the 1/ϵ demands.
If there are r demands, offline’s single order will come at time tr ≤ 1 +
∑r
r
i=1 ϵ .
It should be clear
that offline’s cost is less than (1 + 3ϵ)/2 times online’s cost, since each demand for which offline
pays wait cost may need to pay an ϵ share of the order cost 1, and waits no more than (1 + 2ϵ)
times as long as it does under online. Since we can make ϵ arbitrarily small, we obtain the stated
lower bound of 2.
4.2. The multiple-item case
Now we turn to the multiple-item case. Without loss of generality we assume K0 , the joint order
cost, is 1. Recall that the order cost for item type i ≥ 1 is denoted Ki .
We will use widely disparate rates of wait cost increase in two ways: we use the zooming technique
described in the previous section, and the wait cost rates for different item types will be very
different. As before, the adversary will zoom up to 1/ϵ times as necessary (we will call these rounds),
∑
and then pay a final ordering cost of 1 + i Ki which is negligible when amortized over enough
rounds.
At the beginning of each round, demands are opened for all item types. At the first time scale
(i.e., in the first round, before any zooming), each item type i will incur wait cost at some rate si .
We choose s1 = 1 and si+1 = ϵsi for i ≥ 1. In each later round of zooming, each item type’s rate of
wait cost increase will be multiplied by 1/ϵ.
Note that whenever wait cost is accumulating for type i and some higher-indexed types, the
sum of wait costs for the higher-indexed types is less than 2ϵ times that of type i. We will not
mention these wait costs for either online or offline in the following, and we will also ignore offline’s
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
25
additional wait costs for zooming and its final order cost. Thus it should be understood that each
cost in the following is approximate but within a 1 + 6ϵ factor of the actual cost, and that by
choosing a small enough ϵ the stated bounds will hold.
In each round, the adversary presents demands for all item types i, 1 ≤ i ≤ n for some n > 1, at
the beginning of the round. Our analysis below is for a single round, and the same analysis applies
to each round. In each round, the adversary will force online’s cost to be at least some factor B
times offline’s cost. Summed over all rounds, we will obtain the same factor between costs, again
with a negligible error since we defer orders to later rounds or even until after the last round.
For simplicity, we will describe just the first round, which starts at time 0.
Claim 1. For each i ≥ 1, we may assume that online algorithm orders type i no later than types
i + 1 . . . n.
Proof.
Suppose for instance that online orders type 2 at time t2 and then orders type 1 at time
t1 > t2 . The adversary will then proceed as though online ordered both 1 and 2 at time t1 . We may
assume t1 = O(1), since offline could order type 1 at time 0 and online’s wait cost s1 t1 = t1 for type
1 would imply a ratio of ω(1). Thus online’s wait cost s2 t1 for type 2 is very small since s2 = ϵ is
very small. Note that online saves a joint order cost of K0 = 1, which is much greater than s2 t1 ,
and online is thus much better off delaying the order of type 2 until t1 . Similarly, if online orders
any number of higher-indexed types before some lower-indexed type, we may delay the orders for
the higher-indexed types until that of the lower-indexed type, with negligible increase in wait costs
and saving one joint order cost, and online’s cost only decreases.
Now suppose online orders types 1, . . . , j for some j at time t1 . The tradeoff for offline (ignoring
other, more costly choices that are dominated by these two) is between
1. ordering type 1 at time 0, paying 1 + K1 , and (possibly) continuing at the current zoom level;
and
2. zooming so the order for type 1 can be deferred and paying the only wait cost t1 for item
type 1.
Note that offline obtains a significant advantage if online orders any types i > 1 at the same time as
type 1. Online pays Ki for these item types, and offline pays negligible cost. In fact, the adversary
may prefer to zoom to take advantage of this even if
it orders type 1 at time 0 (i.e., the order cost 1 + K1 for ordering type 1 at time 0 is less than
the wait cost t1 ).
4.3. The relatively simple case of 2 item types
We will now consider in detail the case of two item types to illustrate the lower bound technique.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
26
Proof of Theorem 3.
Suppose online orders both types at time tboth , paying tboth + 1 + K1 + K2 .
Offline has two choices (ignoring other, poorer options):
1. Pay tboth and zoom.
2. Order item type 1 at time 0, paying 1 + K1 , and zoom.
Now consider the case in which online orders only type 1 at t1 , planning to order type 2 at some
later time t2 . Online’s cost so far is t1 + 1 + K1 . Offline’s choices are:
1. Pay min(t1 , 1 + K1 ) and zoom, which ends the current round. In this case the demand for
type 2 is simply ignored for both online and offline, since it will eventually be ordered but with
negligible wait cost.
2. Order type 1 at time 0, paying 1 + K1 , and continue the round, waiting for online to order
type 2.
Note that offline could keep the demand for item type 1 open and continue without zooming, but
the cost would be far too high. Offline would then be paying wait cost at rate 1 + s2 compared to
the much smaller s2 for online, so we will not consider this option.
In the second case, online eventually orders item type 2 at some time t2 . Online’s total cost for
the round is now t1 + t2 s2 + 2 + K1 + K2 . Offline’s choices are
1. Pay (in total for this round) t2 s2 + 1 + K1 and zoom.
2. Order both item types at time 0, paying (in total for this round) 1 + K1 + K2 . (There is no
need to zoom to a compressed time scale for the next round in this case.)
We will now show that if we choose K1 = 0 and K2 = 0.465, the value of the resulting game (in
the limit as ϵ decreases toward 0) is approximately 2.465.
For the first case, the ratio is
tboth + 1 + K1 + K2 tboth + 1 + K2
=
.
min(tboth , 1 + K1 )
min(tboth , 1)
This is minimized at tboth = 1 with value 2 + K2 = 2.465.
Now consider the second case, and for the sake of contradiction, assume online achieves a ratio
less than 2.465. We can then lower bound t1 by considering the first subcase, i.e., offline’s first
option. The ratio is
t1 +1
min(t1 ,1)
or 1 + 1/t1 for t1 < 1. This expression is greater than 2.465 if t1 <
1/1.465 ≈ 0.683. Thus we can assume t1 ≥ 0.682.
Now consider the final case. The ratio is
t1 + t2 s2 + 2 + K1 + K2
t1 + t2 s2 + 2 + K2
=
.
min(t2 s2 + 1, 1 + K1 + K2 ) min(t2 s2 + 1, 1 + K2 )
This is minimized with t2 s2 = K2 in which case it is
t1 + 2 + 2K2
t1
=2+
.
1 + K2
1 + K2
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
27
Substituting t1 ≥ 0.682 and K2 = 0.465 we have a ratio greater than 2.465, yielding the contradiction
we needed.
4.4. More than 2 item types
Finally we are ready to describe our lower bound for the case of n > 2 item types.
Proof of Theorem 4.
For tractability, we restrict the adversary’s strategy and assume that if at
any time online orders more than one item type together, the adversary ends the current round of
the game. In our notation below, i denotes this order; i.e., online orders singly items 1, . . . , i − 1
and then orders types i and i + 1 at the same time. We allow online to know the adversary strategy
and thus assume it does not order i + 2 and higher types, since there would be no advantage.
Alternatively, we can say we are simply neglecting the costs of any higher-indexed orders, since
what we need to do is lower bound online’s cost. If online never aggregates two orders, the game
ends (no later than) when online has ordered all n item types. Recall that the adversary will repeat
these orders for many rounds, and note that we are here speaking of the game corresponding to a
single round. Note that depending on the adversary’s choices, online might not actually make all
the orders in its strategy. The adversary may end the round earlier than the ith order.
We will drop the wait times and rates of increase and instead simply denote the wait costs.
wi,j will be the wait cost for type j in the case that online chooses as its strategy to order items
1, . . . , i − 1 separately and then order i and i + 1 together. We will limit offline and the adversary
to the choices listed below. In general, offline either orders all items at time 0, or orders types
1 . . . i − 1 at time 0 and defers higher-indexed types by zooming. (Note that in either case, item
types greater than i are deferred to the next round for both offline and online; the wait costs for
those demands in the current round, and also later rounds which are much shorter, are negligible.)
Cases i = 1 and i = n are slightly different from other cases, leading to a somewhat complicated
series of subcases.
1. In case i = 1, either order type 1 at time 0 and pay 1 + K1 , or pay the wait cost w1,1 . In either
case, zoom and avoid paying any cost for type 2. Thus online’s cost is
w1,1 + 1 + K1 + K2
and offline’s cost is
min(w1,1 , 1 + K1 ).
2. If i > 1, end the round right after online orders type 1, and zoom, avoiding all order costs.
Online pays some wait cost plus the order cost:
wi,1 + 1 + K1 .
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
28
Offline pays only
wi,1 .
3. If i > 2, end the round after ℓ orders and zoom, where 1 < ℓ < i, avoiding the order cost for
type ℓ by zooming; types 1..ℓ − 1 are ordered at time 0 and no wait cost is incurred for them. We
may write online’s cost as
ℓ
∑
wi,j + ℓ +
ℓ
∑
j=1
Kj
j=1
and offline’s as
wi,ℓ + 1 +
ℓ−1
∑
Kj .
j=1
4. if 2 < i < n, allow online to order all types through i + 1 (all but i and i + 1 individually).
Offline orders types 1 . . . i − 1 at time 0 and either orders type i as well, or pays the wait cost wi,i .
Thus online pays
i
∑
wi,j + i +
i+1
∑
j=1
and offline pays
1+
Kj
j=1
i−1
∑
Kj + min(wi,i , Ki )
j=1
5. if i = n, allow online to order all types 1..n separately. Offline orders types 1 . . . n − 1 at time
0 and either orders type n as well, or pays the wait cost wn,n . Thus online pays
n
∑
wn,j + n +
j=1
and offline pays
1+
n
∑
Kj
j=1
n−1
∑
Kj + min(wn,n , Kn )
j=1
.
Complete problem statement for lower bound Our goal is to prove a lower bound of B, as large
as possible, on the competitive ratio of every (deterministic) online algorithm. From the foregoing
it should be clear that we may do so by exhibiting n and K1 , . . . , Kn such that for every sequence
{wi,ℓ } where 1 ≤ i ≤ n and 1 ≤ ℓ ≤ i, the following inequalities hold.
w1,1 + 1 + K1 + K2
≥ B · min(w1,1 , 1 + K1 )
wi,1 + 1 + K1
≥ B · wi,1
∑ℓ
j=1 wi,j
∑i
j=1 wi,j
∑n
j=1 wn,j
+ℓ+
+i+
∑ℓ
j=1 Kj
∑i+1
+n+
j=1 Kj
∑n
j=1 Kj
i = 2...n
≥ B · (wi,ℓ + 1 +
≥ B · (1 +
≥ B · (1 +
∑i−1
∑ℓ−1
j=1 Kj )
j=1 Kj
∑n−1
j=1
+ min(wi,i , Ki ))
Kj + min(wn,n , Kn ))
i = 3 . . . n, ℓ = 2 . . . i − 1
i = 2...n−1
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
29
Note we may assume min(w1,1 , 1 + K1 ) = w1,1 = 1 + K1 since it can only improve the ratio for
online. Similarly, it is not difficult to see that online’s optimal choice for each i > 1 is wi,i = Ki .
For the 3-item case, using K1 = 0, K2 = 0.641, and K3 = 0.448, we obtain a ratio of approximately
2.641. These values were found using the non-linear programming solver IPOPT (36), but the
resulting bound was checked by hand in a manner similar to the 2-item case. We omit the details
of this more tedious analysis which completes the proof of Theorem 4.
Numerical solution for increasing values of n suggests a limiting value of 2.754 ≤ B ≤ 2.755 for
this adversary.
5. Conclusions
Our main result in this work is a deterministic 3-competitive algorithm to the JRP, which is a
central problem in inventory theory and practice. We also proved a lower bound of 2.64 for any
deterministic online algorithm for the problem. One obvious question that remains open is closing
this gap.
Another question that arises is whether randomized online algorithms can provide improved
competitive ratios. The only lower bound on randomized algorithms that is currently known for
the problem is 1 + 1/(e − 1) ≈ 1.58 that holds even for the Dynamic TCP-Acknowledgement (or
equivalently the online single-item lot sizing problem) (23). However, there are indications that the
randomized competitiveness possible for the online JRP could be significantly worse. First, while
the single-item lot sizing problem is polynomially solvable, the JRP is APX-hard, even when the
delay function is in the form of deadlines (16, 30). The best offline approximation factor currently
known to the general case is only 1.8 > 1.58 (27) (and 5/3 in the case of deadlines). This implies
that any attempt to improve below these guarantees will require improving the respective results
for the deterministic models.
Moreover, our results indicate a fundamental difference between the online single-item lot-sizing
problem and the online JRP in the respective performance of deterministic online algorithms.
Specifically, there exists a 2-competitive deterministic online algorithm for the online single-item
lot-sizing problem, while no algorithm is better than 2.64 competitive for the online JRP. We
conjecture that similar trend holds for randomized algorithms. In particular, the task of designing
improved randomized online algorithms for the JRP seems rather challenging, partly because this
might require the improvement of the analysis of the corresponding offline problems. We leave that
as a major open question for future research.
To get an additional perspective on how helpful randomization may be in practice, we checked the
single item case. For this case, which is much less involved than the joint replenishment problem,
our deterministic algorithm reduces to the well known 2-competitive algorithm (15). On the other
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
30
hand, there is a very simple e/(e − 1) ≈ 1.58 competitive randomized algorithm (23). We found
out that randomization was much less effective on empirical inputs than the theoretical guarantee.
For example, on random input with K = 10, delay penalty factor 0.5, and arrival rate 0.03, the
deterministic competitive factor was 1.71 while the average competitive ratio of the randomized
algorithm (over 20 executions) was 1.46. On the same input with arrival rate 0.05 the deterministic
competitive ratio was 1.47, while the randomized competitive ratio was only slightly better, 1.45.
Acknowledgements: The authors thank the Associate Editor and the antonymous referees for
many constructive comments that improved the content and exposition of this paper. We thank
Andreas Wächter for his great help in using his non-linear programming solver IPOPT (36) and
Grzegorz Swirszcz for finding several errors in the exposition of the lower bound.
References
[1] Ilog cplex, http://www.ilog.com/products/cplex/.
[2] Shipra Agrawal, Zizhuo Wang, and Yinyu Ye. A dynamic near-optimal algorithm for online linear
programming. CoRR, abs/0911.2974, 2009.
[3] Noga Alon, Baruch Awerbuch, Yossi Azar, Niv Buchbinder, and Joseph Naor. The online set cover
problem. SIAM J. Comput., 39(2):361–370, 2009.
[4] E. Arkin, D. Joneja, and R. Roundy. Computational complexity of uncapacitated multi-echelon production planning problems. Operations Research Letters, 8:61–66, 1989.
[5] Y. Askoy and S. S. Erenguk. Multi-item inventory models with coordinated replenishment: a survey.
International Journal of Operations and Production Management, 8:63–73, 1988.
[6] S. Axsäter. Worst case performance for lot sizing heuristics. EJOR, 9(4):339–343, 1982.
[7] Nikhil Bansal, Niv Buchbinder, and Joseph (Seffi) Naor. A primal-dual randomized algorithm for
weighted paging. In FOCS ’07: Proceedings of the 48th Annual IEEE Symposium on Foundations of
Computer Science, pages 507–517, 2007.
[8] Allan Borodin and Ran El-Yaniv. Online computation and competitive analysis. Cambridge University
Press, New York, NY, USA, 1998.
[9] N. Buchbinder and J. Naor. Improved bounds for online routing and packing via a primal-dual approach.
In Proceedings of the 47th annual ieee Symposium on Foundations of Computer Science (FOCS 2006),
2006.
[10] Niv Buchbinder, Kamal Jain, and Joseph (Seffi) Naor. Online primal-dual algorithms for maximizing
ad-auctions revenue. In ESA ’07: Proceedings of the 15th Annual European Symposium, pages 253–264,
2007.
[11] Niv Buchbinder and Joseph Naor. Online primal-dual algorithms for covering and packing. Math. Oper.
Res., 34(2):270–286, 2009.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
31
[12] Niv Buchbinder and Joseph (Seffi) Naor. The design of competitive online algorithms via a primaldual
approach. Foundations and Trends in Theoretical Computer Science, 3:93–263, 2009.
[13] N. P. Dellaert1 and M. T. Melo. Heuristic procedures for a stochastic lot-sizing problem in make-to-order
manufacturing. Annals of Operations Research, 59(1):227–258, 2005.
[14] Nikhil R. Devenur and Thomas P. Hayes. The adwords problem: online keyword matching with budgeted
bidders under random permutations. In ACM Conference on Electronic Commerce, pages 71–78, 2009.
[15] Daniel R. Dooly, Sally A. Goldman, and Stephen D. Scott. Tcp dynamic acknowledgment delay
(extended abstract): theory and practice. In STOC ’98: Proceedings of the thirtieth annual ACM symposium on Theory of computing, pages 389–398, 1998.
[16] Arkin E., D. Joneja, and R. Roundy. Computational complexity of uncapacitated multi-echelon production planning problems. Operations research letters, 8:63–73, 1989.
[17] Jon Feldman, Monika Henzinger, Nitish Korula, Vahab S. Mirrokni, and Clifford Stein. Online stochastic
packing applied to display ad allocation. In ESA (1), pages 182–194, 2010.
[18] M. X. Goemans and D. P. Williamson. A general approximation technique for constrained forest
problems. SIAM Journal on Computing, 24:296–317, 1995.
[19] Qi-Ming He, E.M. Jewkes, and J. Buzacott. The value of information used in inventory control of a
make-to-order inventory-production system. IIE Transactions, 34(11):999–1013, 2002.
[20] S. Van Hoesel and A. Wagelmans. A dual algorithm for the economic lot-sizing problem. European
Journal of Operatioms Research, 52:315–325, 1991.
[21] Tim Huh, Retsef Levi, Paat Rusmevichientong, and Jim Orlin. Adaptive data-driven inventory control
policies based on Kaplan-Meier estimator. Operations Research, 59(4):929–941, 2011.
[22] K. Jain and V. V. Vazirani. Approximation algorithms for metric facility location and k-median problems
using the primal-dual schema and Lagrangian relaxation. Journal of the ACM 48, pages 274–296, 2001.
[23] Anna R. Karlin, Claire Kenyon, and Dana Randall. Dynamic TCP acknowledgement and other stories
about e/(e-1). In ACM Symposium on Theory of Computing, pages 502–509, 2001.
[24] P. Keskinocak, R. Ravi, and S. Tayur. Scheduling and reliable lead time quotation for orders with
availability intervals and lead time sensitive revenues. Management Science, 47(2):264–279.
[25] Wei-Min Lan and Tava Lennon Olsen. Multiproduct systems with both setup times and costs: Fluid
bounds and schedules. Operations Research, 54(3):505–522, 2006.
[26] R. Levi, R. O. Roundy, and D. B. Shmoys. Primal-dual algorithms for deterministic inventory problems.
Mathematics of Operations Research, 31:267–284, 2006.
[27] R. Levi, R. O. Roundy, D. B. Shmoys, and M. Sviridenko. First constant approximation algorithm for
the single-warehouse multi-retailer problem. Under revision in Management Science, extended abstracts
appeared in SODA 2005 and APPROX 2006., 2004.
Author: Online Make-to-Order Joint Replenishment
Article submitted to Operations Research; manuscript no. (Please, provide the manuscript number!)
32
[28] B. Liu, W. Cui, and C. Xin. Ordering policy for perishable commodity using online algorithm with
risk-reward. In Proceedings of 2007 International Conference on Intelligent Systems and Knowledge
Engineering (ISKE 2007), 2007.
[29] Weimin Ma and Ke Wang. Optimal online risk-tolerant ordering policy for the newsvendor with forecast.
Journal of Convergence Information Technology, 5(4):54–65, 2010.
[30] Tim Nonner and Alexander Souza. A 5/3-approximation algorithm for joint replenishment with deadlines. In COCOA, pages 24–35, 2009.
[31] S. O’Neil. Online learning for the newsvendor problem. Master’s thesis, University of Notre Dame,
2009.
[32] Shawn T. O’Neil and Amitabh Chaudhary.
Comparing online learning algorithms to stochastic
approaches for the multi-period newsvendor problem. In ALENEX, pages 49–63, 2008.
[33] Peter Sempolinski and Amitabh Chaudhary. Online algorithms for the newsvendor problem with and
without censored demands. In FAW, pages 234–249, 2010.
[34] W. van den Heuvel and APM Wagelmans. Worst case analysis for a general class of on-line lot-sizing
heuristics. Oper. Res., 2009.
[35] V. V. Vazirani. Approximation algorithms. Springer Verlag, Berlin-New York, 2001.
[36] A. Wächter and L. T. Biegler. On the implementation of an interior-point filter line-search algorithm
for large-scale nonlinear programming. Mathematical Programming, 106(1):25–57, 2006.
[37] H. M. Wagner and T. M. Whitin. Dynamic version of the economic lot sizing model. Management
Science, 5:89–96, 1958.
[38] Michael R. Wagner. Fully distribution-free profit maximization: The inventory management case. Math.
Oper. Res., 35(4):728–741, 2010.
[39] M.R. Wagner. Fully Distribution-Free Profit Maximization: The Inventory Management Case. Math.
Oper. Res., 35(4):728, 2010.