Cost Sharing under Uncertainty: An Algorithmic Approach to Cooperative Interval-Valued Games

Recently, Branzei, Dimitrov, and Tijs (2003) introduced cooperative interval-valued games. Among other insights, the notion of an interval core has been coined and proposed as a solution concept for interval-valued games. In this paper we will present a general mathematical programming algorithm which can be applied to find an element in the interval core. As an example, we discuss lot sizing with uncertain demand to provide an application for interval-valued games and to demonstrate how interval core elements can be computed. Also, we reveal that pitfalls exist if interval core elements are computed in a straightforward manner by considering the interval borders separately.


A Primer on Cooperative Interval-Valued Games
In the classical literature a cooperative game is defined by a pair äN; cå where N ã è1; : : : ; né is an index set of players and c ñ 2 N → I R is a characteristic function which assigns to every coalition S ∈ 2 N a value cäSå (with cä∅å ã 0). Let us assume that c is a cost function (``the lower the better''), but in settings where c is a benefit function the following material can be straightforwardly adapted. A solution of the cooperative game (with transferable utilities) is a distribution of the cost shares, i.e. a cost allocation i ∈ I R for every player i ∈ N. One of the most prominent solution concepts was introduced by Gillies (1959) and is known as the core. The concept of the core defines cost allocations which are efficient and coalitionally rational (stable). Formally, the set of core allocations can be specified as follows: ä1å CäN; cå ã è ∈ I R n | i∈N i ã cäNå and i∈S i ‹ cäSå for all S ⊂ N; S ã ∅é: Branzei, Dimitrov, and Tijs (2003) have studied bankruptcy situations and introduced cooperative interval-valued games in this context. Intervalvalued games can be seen as a means to handle uncertain outcomes. A theory of interval-valued games was developed by Alparslan-Gök, Tijs (2008a, 2008b) as well as by Alparslan-Gök, Miquel, and Tijs (2009). See also Branzei, Tijs, and Alparslan-Gök (2008) for a survey. A cooperative interval-valued game is defined by a pair äN; c I å where N is an index set of players as before, and c I ñ 2 N → IäI Rå is a characteristic (cost) function which assigns to every coalition S ∈ 2 N a closed interval c I äSå ã aec I äSåòc I äSåç (with c I ä∅å ã ae0ò 0ç) where IäI Rå is the set of all closed intervals in I R. It is easy to see that classical cooperative games are a special case of cooperative interval-valued games where c I äSå ãc I äSå for all coalitions S ⊆ N. It should also be remarked that vector-valued games (see Fernandez, Hinojosa, and Puerto 2002) are somewhat different to interval-valued games.
To define a core variant that applies to interval-

BuR --Business Research Official Open Access Journal of VHB Verband der Hochschullehrer für Betriebswirtschaft e.V. Volume 2 | Issue 2 | December 2009 | 206--213
valued games, the following notation turns out to be helpful. The sum of two intervals I ã aeIòĪç and J ã aeJòJç is defined to be I à J ã aeI à JòĪ àJç. The interval I is called weakly better than interval J (I J or J I), iff I ‹ J andĪ ‹J. Alparslan-Gök, Branzei, and Tijs (2008a) define the interval core of a cooperative interval-valued game as follows: ä2å C I äN; c I å ã èäI 1 ; : : : ; I n å ∈ IäI Rå n | i∈N I i ã c I äNå and i∈S I i c I äSå for all S ⊂ N; S ã ∅é: These authors, however, do not provide an algorithm to compute a core element of interval-valued games. Now we have introduced the theoretical background that is necessary for understanding our approach. Our contribution is an algorithm which can be used to compute an interval core element. Besides this, we discuss pitfalls when implementing a more simple procedure based on an already known algorithm for core element computation in cases of independent determination of interval borders. The rest of the paper is structured as follows. In Section 2 we specify the straightforward procedure with separate interval border determination that aims to find an element in the interval core (or detects that the interval core is empty). Section 3 introduces a lot-sizing problem with uncertain demand as an example for interval-valued games. Section 4 reveals that some odd situations may occur if the straightforward approach is applied and left and right interval borders are used independently to compute interval core elements. Thus, a modification of the proposed algorithm will be presented to avoid such problems. A computational study in Section 5 demonstrates that this modified algorithm is necessary in many cases and can indeed be successfully applied. Concluding remarks in Section 6 finish the paper.

Computing Interval Core Elements
To compute an element in the interval core, we will make use of a procedure by Drechsel and Kimms (2007) which computes a core element. This procedure is employed as a subroutine. To see how this works we start with a reformulation of interval-valued games and the interval core. An interval-valued game can be specified by a triple äN; c I ;c I å where the notation has the same meaning as above. Two sets of extreme cost allocations can then be defined as If we choose äI 1 ; : : : ; I n å ∈ C I äN; cå and äĪ 1 ; : : : ; I n å ∈C I äN; cå then it follows immediately from the definitions of c I , I i and C I äN; c I å that äaeI 1 òĪ 1 ç; : : : ; aeI n òĪ n çå ∈ C I äN; c I å ---the reverse is true as well. C I äN; c I å andC I äN;c I å define the cores of the cooperative games äN; c I å and äN;c I å, respectively. This is along the lines of Remark 3.1 in the paper by Alparslan-Gök, Branzei, and Tijs (2008a), who state that the time complexity of algorithms for the computation of elements of the interval core is the same as the time complexity of related algorithms for computing elements of the core of a traditional game. This suggests that an element in the interval core can be easily computed if one can compute an element in the core. The procedure of Drechsel and Kimms (2007) can be applied to find core elements for the games äN; c I å and äN;c I å separately. To be self-contained, this procedure will be reviewed briefly. To ease the notation, assume that a core element of a game äN; cå shall be computed. The definition of the core specifies a constraint-satisfaction problem where the number of constraints is in the order of 2 n . Hence, Drechsel and Kimms (2007) suggested to run a row-generation procedure. The master problem is a linear program of the following form where S is a (small) subset of coalitions for which the core defining inequality is explicitly taken into account.
3. If v > 0 then stop. The game instance has an empty core.
4. Otherwise, find a coalition S ∈ S (S ã ∅) such that i∈S i > cäS å. Since S may not be unique, we suggest looking for a coalition S that violates the core defining inequality most (i.e. i∈S i á cäS å is maximized) ---subprob-lemŜPä å.
5. If no such coalition S can be found (ŜPä å has a non-positive optimum objective function value) then stop. The current values i define a core allocation.
The subproblem to be solved in Step 4 of the algorithm is the only problem-specific part in this approach. In a subsequent section we will provide the details of it by means of a specific application. It should be noted that this procedure finds a rather arbitrary element in the core (if the core is not empty). Drechsel and Kimms (2007) have discussed several modifications to the procedure which yield core elements that can be considered as more fair than an arbitrary core element. For the sake of simplicity, we will not repeat these modifications here, but we would like to emphasize that these modifications can be straightforwardly integrated into the context of interval-valued games if desired.

The Wagner-Whitin Problem
The starting point of our example is a well-known lot-sizing problem which was introduced by Wagner and Whitin (1958) and which can be described as follows: A single decision maker has to make order decisions for a single item. Given a planning horizon of T time periods, a demand d t in period t has to be met without backlogging and without shortages. In order to meet the demand in period t one may place an order in t or before. If the order is placed before, the ordered items must be stored in inventory. If a fixed cost s t is incurred whenever an order is placed in period t and a unit holding cost h t is charged for every item in stock at the end of period t, then we face the classical trade-off between saving fixed costs versus saving holding costs ---a lot-sizing problem occurs. In addition to that a unit ordering cost p t may be incurred for each item being ordered. The decision to be made is q t , the quantity to be ordered in period t. Depending on the order quantities and the demand we have Inv t units of the item in stock at the end of a period t (Inv 0 is the initial stock ---a given value).
To formulate a mixed-integer program a further decision variable x t may be used to indicate if an order is placed in period t or not, and a parameter M which represents a large number may be used for technical reasons, as we see below: ä11å Inv t ã Inv tá1 à q t á d t t ã 1; : : : ; T ä12å q t ‹ Mx t t ã 1; : : : ; T ä13å q t ; Inv t OE 0 t ã 1; : : : ; T ä14å x t ∈ è0; 1é t ã 1; : : : ; T The objective (10) is to minimize the sum of fixed and quantity-dependent ordering costs and holding costs. The inventory balance (11) states that at the end of a period we have in stock what was there at the beginning of the period plus what was ordered in that period minus period demand. If the order quantity is positive in period t then the indicator variable x t must be set to one as stated by (12). The domain of the decision variables is  (13) and (14). Note that due to Inv t OE 0 all demand must be fulfilled right on time.

A Cooperative Lot-Sizing Problem
Cooperative versions of the Wagner-Whitin-related problem where several players (the set N) may act together have been studied by Chen and Zhang (2007), Drechsel and Kimms (2007), Guardiola, Meca, and Puerto (2006), and Van den Heuvel, Borm, and Hamers (2007). A model formulation closely related to the single-player model shown above can be given, simply by replacing the demand value d t with the total demand of all players d t äNå ã i∈N d it where d it denotes the demand of player i in period t. The characteristic function value cäSå for S ⊆ N is defined to be the optimum objective function value (10) using d t äSå as the demand in (11). As shown by Drechsel and Kimms (2007) one can apply the row-generation procedure for finding a core element in the game äN; cå to handle instances with up to 150 players. The subproblem that has to be solved in Step 4 of the procedure is the following optimization problem.
SubproblemŜPä å: ä16å Inv t ã Inv tá1 à q t á i∈N d it z i t ã 1; : : : ; T ä17å q t ‹ Mx t t ã 1; : : äs t x t à h t Inv t à p t q t å ä19å q t ; Inv t OE 0 t ã 1; : : : ; T ä20å x t ∈ è0; 1é t ã 1; : : Note that a coalition S to be considered in the master problem is found if the optimum objective function value of the subproblem is positive. S is defined by the values of the z i variables (z i ã 1 indicates i ∈ S ) and cäS å ã o. Note also that Drechsel and Kimms (2007) have tested other subproblem formulations, and that selecting a coalition S by means of subproblemŜPä å turned out to require fewer iterations of the row-generation procedure and less total computation time than other selection rules. It should be emphasized that the proposed rowgeneration approach to compute a core element is very general and can be applied whenever the characteristic function is implicitly given, i.e. characteristic function values result from an optimization problem. Drechsel and Kimms (2008), for instance, have shown that for much more complex lot-sizing situations with capacity constraints and transshipments among the players basically the very same approach is applicable. Only the subproblem needs to be reformulated, because this is the problem-specific part of the algorithm. How to formulate such subproblems for different applications cannot be specified in general, but it requires no more skills than formulating the underlying optimization problem as a mathematical program. As a side remark, it should be emphasized that many operations management planning problems have to be solved repeatedly with a rolling horizon. Lot sizing is one example. Our example is therefore stylized by ignoring (uncertain demand) data beyond the period T and we admit that our focus is confined to interval-valued data. We also do not consider the possibility to condition future lot-sizing decisions on realized past demands like in stochastic dynamic optimization procedures. To the best of our knowledge, such simplifying assumptions are also made by all authors who have considered cost sharing based on multi-period optimization problems. Hence, one should be aware of the fact that dynamic settings where uncertainty is not revealed at once and the consequences on cost sharing have not been studied yet.

Cooperative Lot-Sizing with Uncertain Demand
A source for uncertainty in a lot-sizing problem is the demand of a player. Let us assume that for each player i the demand in a certain period is specified by an interval aed it òd it ç instead of a single number d it . Consequently, the total demand d t äNå in a period t falls into the interval aed t äNåòd t äNåç ã ae i∈N d it ò i∈Nd it ç. From these interval borders we can derive characteristic functions c I andc I by inserting d t äSå andd t äSå, respectively, into (11) for S ⊆ N. With this in mind, we can compute an element in the interval core as described in a previous section.

4.1``Pay Less for More''
As some researchers have pointed out already (see, e.g., Young 1985), core allocations are not monotonic. This effect causes some problems in the context of interval cores as we will show by means of an example. Consider an example with n ã 3 and T ã 6. Let the demand be d it ã 10 andd it ã 15, respectively, for all i and t. Suppose the following cost data: holding cost coefficients h t ã 5 for all t, setup cost coefficients s t ã 100 for all t, and production cost coefficients p t ã 1 for all t. The characteristic functions c I andc I are provided in Table 1. Apparently, we havec I äSå OE c I äSå in this example. This, by the way, is always true for lot-sizing problems (with non-negative cost data), because additional demand cannot decrease the (total) cost to fulfill the demand. Since the characteristic functionsc I and c I define core cost allocations i äc I å and i äc I å, respectively, we would expect that i äc I å OE i äc I å is true for all players i. In other words, we would expect that increasing the demand of a player does not lead to a lower cost assignment, i.e. the principle of monotonicity holds. But this is not true in general. For example, äc I å ã ä210; 510; 60å is a core cost allocation for the game äN; c I å. On the other hand, äc I å ã ä165; 615; 90å is a core cost allocation for the game äN;c I å. As we can see, a lower cost share would be assigned to player 1 (165 instead of 210) although his demand increased from 10 to 15 in every period. Young (1985) has discussed the issue of monotonicity and showed that the Shapley value is the unique symmetric allocation procedure that is (strongly) monotonic. But using the Shapley value as an interval border is not consistent with the idea of the interval core, because the Shapley value need not be in the core if the game is not concave (see Shapley 1971). As a consequence of the phenomenon we may observe intervals I i ã aeI i òĪ i ç with I i >Ī i . This, by the way, is not valid for lot-sizing problems only, but to all kinds of applications, because the non-monotonicity of core allocations is problem independent.

Pitfalls
It seems to be plausible to interpret an element from the interval core as a promise to the players such that if äI 1 ; : : : ; I n å ∈ C I äN; c I å is chosen in advance, an ex post (i.e. after the uncertainty has been resolved) core cost allocation with i ∈ I i can be found, because the two extreme scenarios have been considered to define the interval core. Hence, the problem of finding a core element ex post seems to be of the following form: ä23å C| äI 1 ;:::;Inå äN; cå ã è ∈ I R n | i∈N i ã cäNå and i∈S i ‹ cäSå for all S ⊂ N; S ã ∅ and i ∈ I i é: Note that this interpretation is meaningful iff the underlying (ex post) characteristic function c is monotone over the interval defined by c I and coincides with c I andc I at the interval borders. This interpretation, however, is wrong as we will show be means of the example from Subsection 4.1. Recall that in the example the following intervals were computed: I 1 ã ae210ò 165ç, I 2 ã ae510ò 615ç, and I 3 ã ae60; 90ç. Assume that ex post the following demand data can be observed: d 1t ã 15 for all t, d 2t ã 10 for all t, and d 3t ã 15 for all t. As we can see from Table 1, this leads to cäè1éå ã 615, cäè2éå ã 510, and cäè3éå ã 615. The cost of the grand coalition is cäè1; 2; 3éå ã 840. The definition of C| äI 1 ;:::;Inå äN; cå requires 2 ã 510. Hence, 1 à 3 ã 840 á 510 ã 330. But this is not possible, because of 1 ‹ 210 and 3 ‹ 90. Hence, the described approach leads to unreasonable results.

A Proper Definition of Interval-Valued Cores
To avoid such problems with interval cores, we need proper intervals, i.e. we need to compute interval borders i äc I å and i äc I å such that i äc I å ‹

BuR --Business Research Official Open Access Journal of VHB Verband der Hochschullehrer für Betriebswirtschaft e.V. Volume 2 | Issue 2 | December 2009 | 206--213
i äc I å comes out. Such a result can be reached be computing the values i äc I å and i äc I å simultaneously by solving a modified master problem MP I äS;Så: ä24å min v àv This master problem can be solved by the iterative row-generation algorithm as follows: 1. Define small initial sets S andS, e.g. S ãS ã èè1é; : : : ; ènéé.
3. If v àv > 0 then stop. The game instance has an empty interval core.

Otherwise:
(a) Find a coalition S ∈ S (S ã ∅) such that i∈S i äc I å > c I äS å. Since S may not be unique, we suggest looking for a coalition S that violates the core defining inequality most (i.e. i∈S i äc I åác I äS å is maximized) ---subproblemŜPä äc I åå. Update S ã S ∪ èS é, if such a coalition S was found.
(b) Find a coalitionS ∈S (S ã ∅) such that i∈S i äc I å >c I äS å. SinceS may not be unique, we suggest looking for a coalition S that violates the core defining inequality most (i.e. i∈S i äc I åác I äS å is maximized) ---subproblemSPä äc I åå. UpdateS ãS ∪ èS é, if such a coalitionS was found.
5. If neither S norS can be found then stop.
The current values i äc I å and i äc I å define an interval core element.

Computational Study
To test the proposed algorithm from Section 4.3 we have implemented it with AMPL/CPLEX version 10.0.0 on an Intel Celeron PC with 2 GHz. We used random instances taken from Test Bed 1 in Drechsel and Kimms (2007) to define the game äN; c I å: random integers were drawn with uniform distribution from certain intervals (d it ∈ ae0; 20ç, s t ∈ ae0; 200ç, h t ∈ ae0; 10ç, and p t ∈ ae0; 15ç), T ã 6, and n ∈ è5; 10; 15; 20; 25; 30é. For each number of players, a total of 15 random instances was constructed which gives a total of 6 ¦ 15 ã 90 instances. These instances are provided as an electronic companion to this paper as part of the online version. 1 The files are in ASCII format and can be used by the commercial software CPLEX. The game äN;c I å was constructed by copying the parameter values from the corresponding game äN; c I å.
Only demand values were chosen differently in the following way. Suppose d it is the chosen demand in the corresponding game äN; c I å. The demand d it for the game äN;c I å is a random integer drawn with uniform distribution from aed it ; 20ç. The average number of iterations (as well as the minimum/maximum number of iterations over 15 random instances) for the algorithm can be seen in Table 2. The table presents the results regarding number of iterations for the two subproblemsŜP andSP that are part of Step 4 of the algorithm. The numbers differ for most of the instances ---of course, the bigger number also denotes the total number of needed iterations. Note that in the worst case the number of iterations could have been in the order of 2 n which practically never happens from our experience. The maximum computational time (measured in CPU-seconds) to determine an element in the interval-valued core was less than a minute for all instances n ‹ 20 and not more than five minutes for the larger instances.
To compare the computational burden with the straightforward approach from Section 2 ---the  one which may lead to the problems discussed in Section 4.2 ---we also provide the average number of iterations of the straightforward approach in Table 3. As one can see the straightforward approach terminates much faster on average (the run-time effort was less than one minute for each instance). Hence it might be worthwhile to run the straightforward approach first and test if the computed interval borders indeed show the odd behaviour discussed in Section 4.2. If this is not the case, then we have found an interval core element. Otherwise, we need to run the algorithm from Section 4.3 which is necessary in most cases as we can see in Table 4. Table 4 shows the number of instances in the test bed (a total of 15 instances per value of n) where the algorithm from Section 2 yields an improper interval for at least one player.

Conclusions
In recent years a new class of cooperative games, namely interval-valued games, has been invented to handle situations with an uncertain outcome. The range of the outcome is specified by a closed interval. A theory for interval-valued games has been developed and solution concepts from classical cooperative game theory have been adapted to this new setting. The core which is one of the most prominent solution concepts in classical cooperative game theory evolved to become the interval core. Remark 3.1 in a paper by Alparslan-Gök, Branzei, and Tijs (2008a) states that the time complexity of algorithms for computing elements of interval cores equals the time complexity of corresponding algorithms for computing core elements in a traditional game. This statement suggests to compute an element in the interval core by making use of a procedure to find a core element. However, such an algorithm has not been provided by these authors. Our contribution is to provide a general mathematical programming approach which can be used to compute an element in the interval core by making use of a procedure to find core elements proposed by Drechsel and Kimms (2007) as a subroutine. The approach is general, because the characteristic function values which define the lower and upper bounds of the outcome interval may result from solving general optimization problems. We have demonstrated that interval-valued games are a consequence of uncertain parameter values of the optimization problem where the uncertainty of these parameter values is specified by intervals. With the aid of a lot-sizing example we have demonstrated the applicability of our approach by means of a small computational study. In addition to providing an algorithm we have also contributed to the discussion of interval cores by pointing to a pitfall. A phenomenon known as non-monotonicity exists, i.e. players may be better off in a cooperation, if their standalone situation is getting worse (in terms of objective function values). In the lot-sizing example, for instance, we have demonstrated that a player with more demand than before (increasing costs) may receive a lower cost share than before. A straightforward interpretation of an interval core element in the sense of cost limits that will be assigned to certain players is not possible if the interval core element is not selected with care. To get out of this problem, we proposed a modified algorithm which yields an element from the interval core without such deficits.