{'fraction_non_alphanumeric': 0.06343487466703095, 'fraction_numerical': 0.009869544430025272, 'mean_word_length': 3.5540435458786934, 'pattern_counts': {'":': 0, '<': 28, '<?xml version=': 0, '>': 22, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
On the convexity of step out–step in sequencing games

The main result of this paper is the convexity of step out–step in (SoSi) sequencing games, a class of relaxed sequencing games ﬁrst analyzed by Musegaas et al. (Eur J Oper Res 246:894–906, 2015). The proof makes use of a polynomial time algorithm determining the value and an optimal processing order for an arbitrary coalition in a SoSi sequencing game. In particular, we use that in determining an optimal processing order of a coalition, the algorithm can start from the optimal processing order found for any subcoalition of smaller size and thus all information on such an optimal processing order can be used.

of a job is the time the machine takes to process the corresponding job of this player. Every player has an individual linear cost function, specified by an individual cost parameter, which depends on the completion time of this job which is defined as the sum of the processing times of his own job and the jobs that are processed before his own job. There are no further restrictive assumptions such as due dates, ready times or precedence constraints imposed on the jobs. Smith (1956) showed that the total joint costs are minimal if the jobs are processed in weakly decreasing order with respect to their urgency, defined as the ratio of the individual cost parameter and the processing time.
We assume that the players are arranged in an initial order and thus the rearrangement of the initial order to an optimal order will lead to cost savings. To analyze the problem on how these cost savings should be allocated to the players, sequencing games are introduced. The value of a coalition in a sequencing game serves as a benchmark for determining a fair allocation of the optimal cost savings and represents the "virtual" maximal cost savings which this coalition can achieve by means of admissible rearrangements. Which rearrangements are admissible for a coalition is a modeling choice. The classical assumption made in Curiel et al. (1989) is that two players of a certain coalition can only swap their positions if all players between them are also members of the coalition. They show that the resulting sequencing games are convex and therefore have a non-empty core. Relaxed sequencing games arise by relaxing this classical assumption about the set of admissible rearrangements for coalitions in a consistent way.
In Curiel et al. (1993), four different relaxed sequencing games are introduced. These relaxations are based on requirements for the players outside the coalition regarding either their position in the processing order or their starting time. Slikker (2006) considered these four relaxed sequencing games in more detail by investigating the corresponding cores. In van Velzen and Hamers (2003) two further classes of relaxed sequencing games are considered. In relaxed sequencing games the values of coalitions become larger because the set of admissible rearrangements is larger than in the classical case. As a consequence, while classical sequencing games are convex, relaxed sequencing games might not be convex anymore. To the best of our knowledge there is no general convexity result with respect to specific subclasses of relaxed sequencing games.
In Musegaas et al. (2015) an alternative class of relaxed sequencing games is considered, the class of step out-step in (SoSi) sequencing games. In a SoSi sequencing game a member of a coalition is allowed to step out from his position in the processing order and to step in at any position later in the processing order. Providing an upper bound on the values of the coalitions in a SoSi sequencing game, Musegaas et al. (2015) showed that every SoSi sequencing game has a non-empty core. Also, Musegaas et al. (2015) provided a polynomial time algorithm to determine the value and an optimal processing order for an arbitrary coalition in a SoSi sequencing game. This paper shows, by means of this polynomial time algorithm, that SoSi sequencing games are convex. For proving this, we use a specific feature of the algorithm. Namely, for determining an optimal processing order for a coalition, one can use the information of the optimal processing orders of subcoalitions. More precisely, if one wants to know an optimal processing order for a coalition S ∪ {i}, then the algorithm can start from the optimal processing order found for coalition S. In particular, this helps to analyze the marginal contribution of a player i to joining coalitions S, T with S ⊆ T and i / ∈ T , and thus it helps to prove the convexity of SoSi sequencing games.
The organization of this paper is as follows. Section 2 recalls basic definitions on one-machine sequencing situations and the formal definition of a SoSi sequencing game. Section 3 identifies a number of important key features of the algorithm of Musegaas et al. (2015) that are especially useful in proving the convexity of SoSi sequencing games. In Sect. 4 the proof of convexity for SoSi sequencing games is provided.

SoSi sequencing games
This section recalls basic definitions on one-machine sequencing situations and related SoSi sequencing games.
A one-machine sequencing situation can be summarized by a tuple (N , σ 0 , p, α), where N is the set of players, each with one job to be processed on the single machine. A processing order of the players can be described by a bijection σ : N → {1, . . . , |N |}. More specifically, σ (i) = k means that player i is in position k. Let (N ) denote the set of all such processing orders. The processing order σ 0 ∈ (N ) specifies the initial order. The processing time p i > 0 of the job of player i is the time the machine takes to process this job. The vector p ∈ R N ++ summarizes the processing times. Furthermore, the costs for player i of spending t time units in the system is assumed to be determined by a linear cost function c i : [0, ∞) → R given by c i (t) = α i t with α i > 0. The vector α ∈ R N ++ summarizes the coefficients of the linear cost functions. It is assumed that the machine starts processing at time t = 0, and also that all jobs enter the system at t = 0.
The total joint costs of a processing order σ ∈ (N ) are given by i∈N α i C i (σ ), where C i (σ ) denotes the completion time of player i and is defined by A processing order is called optimal if it minimizes the total joint costs over all possible processing orders. In Smith (1956) it is shown that in each optimal order the players are processed in weakly decreasing order with respect to their urgency u i defined by u i = α i p i . The maximal total cost savings are equal to the difference in total costs between the initial order and an optimal order.
A coalitional game is a pair (N , v) where N denotes a non-empty, finite set of players and v : 2 N → R assigns a monetary payoff to each coalition S ∈ 2 N , where 2 N denotes the collection of all subsets of N . In general, the value v(S) equals the highest payoff the coalition S can jointly generate by means of optimal cooperation without help of players in N \S. By convention, v(∅) = 0.
To tackle the allocation problem of the maximal cost savings in a sequencing situation (N , σ 0 , p, α), one can analyze an associated coalitional game (N , v). Here N naturally corresponds to the set of players in the game and, for a coalition S ⊆ N , v(S) reflects the maximal cost savings this coalition can make with respect to the initial order σ 0 . In order to determine these maximal cost savings, assumptions must be made on the possible reorderings of coalition S with respect to the initial order σ 0 .
The classical (strong) assumption is that a member of a certain coalition S ⊂ N can only swap with another member of the coalition if all players between these two players, according to the initial order, are also members of S. Note that the resulting set of admissible reorderings for a coalition is quite restrictive, because there may be more reorderings possible which do not hurt the interests of the players outside the coalition.
In a SoSi sequencing game a member of the coalition S is allowed to step out from his position in the processing order and to step in at any position later in the processing order. Note that from an optimality point of view it is clear that one can assume without loss of generality that a member of S who steps out, only steps in at a position directly behind another member of the coalition S. This means that for every player outside S its set of predecessors cannot become larger and its direct follower was already a follower of him in the initial order. Hence, a processing order σ is called admissible for S in a SoSi sequencing game if the set of predecessors of player i with respect to processing order σ and F(σ, i) = { j ∈ N | σ ( j) > σ (i)} denotes the set of followers. Given an initial order σ 0 the set of admissible orders for coalition S is denoted by A(σ 0 , S). Correspondingly, Musegaas et al. (2015) defined the Step out, Step in (SoSi) sequencing game (N , v) by Note that a processing order is admissible for a coalition in a classical sequencing game if there is an equality in condition (i). Therefore, given a coalition, the corresponding set of admissible orders in a SoSi sequencing game is larger than the set of admissible orders in the corresponding classical sequencing game. As a consequence, the values of coalitions in SoSi sequencing games can become larger with respect to classical sequencing games.
The following example provides an instance of a SoSi sequencing game.
Example 2.1 Consider a one-machine sequencing situation with N = {1, 2, 3}. The vector of processing times is p = (3, 2, 1), the vector of coefficients corresponding to the linear cost functions is α = (4, 6, 5) and the initial order is σ 0 = (1 2 3). Let (N , v) be the corresponding SoSi sequencing game. Table 1 provides the values of all coalitions.
These processing orders are illustrated in Fig. 1. Hence, the value of coalition {1, 3} is given by 3 On the algorithm for finding the values of the coalitions Musegaas et al. (2015) provided a polynomial time algorithm to determine an optimal order for every possible coalition and, consequently, the values of the coalitions. For proving convexity of SoSi sequencing games, we use specific key features of this algorithm. In this section we will derive and summarize these specific features. For example, in Theorem 3.4, we will show that in determining an optimal processing order of a coalition S ∪ {i} in a SoSi sequencing game, the algorithm can start from the optimal processing order found for coalition S.
We start with recalling some definitions such as components. For S ∈ 2 N \{∅}, σ ∈ (N ) and s, t ∈ N with σ (s) < σ (t), define (s, t] are defined in a similar way.

The sets of players
A coalition S ∈ 2 N \{∅} is called connected with respect to σ 0 if for all i, j ∈ S and k ∈ N such that σ 0 (i) < σ 0 (k) < σ 0 ( j) it holds that k ∈ S. A connected coalition U ⊆ S with respect to σ 0 is called a component of S with respect to σ 0 if U ⊆ U ⊆ S and U connected with respect to σ 0 implies that U = U . Let h(σ 0 , S) ≥ 1 denote the number of components of S with respect to σ 0 . The partition of S into components with respect to σ 0 is denoted by In the same way, processing order σ 0 divides N \S into subgroups. For this, define Fig. 2 for an illustration of the subdivision of S and N \S into subgroups by means of processing order σ 0 .
Note that for given S ⊆ N it is possible that a processing order σ ∈ A(σ 0 , S) contains less components than σ 0 , because all players of a certain component with respect to S may step out from this component and join other components. For σ ∈ A(σ 0 , S) with σ 0 ∈ (N ), define modified components S σ 0 ,σ 1 , . . . , S σ 0 ,σ h(σ 0 ,S) by consists of the group of players that are positioned in processing order σ in between the subgroups S σ 0 Moreover, recall that a player is not allowed to move to an earlier component (condition (i) of admissibility), but he is allowed to move to any position later in the processing order and thus we have Since the component index of player i ∈ S with respect to σ can only be increased (due to condition (i) of admissibility), we have An illustration of the definitions of components, modified components and the index c(i, S, σ ) can be found in the following example.
Example 3.1 Consider a one-machine sequencing situation (N , σ 0 , p, α) with S ⊆ N such that S = {1, 2, . . . , 10}. In Fig. 3a an illustration can be found of initial processing order σ 0 and the partition of S into components. Next, consider processing order σ as illustrated in Fig. 3b that is admissible for S. Note that σ contains less components than σ 0 . Figure 3b also illustrates the definition of modified components. Note that there is one modified component that is empty, namely S σ 0 ,σ 3 . Since player 3 belongs to the first modified component, we have c(3, S, σ ) = 1. Moreover, since player 3 is the only player who belongs to the first modified component, we have S σ 0 ,σ 1 = {3}. Similarly, we have c(4, S, σ ) = c(2, S, σ ) = 2, and c(i, S, σ ) = 4, for all i ∈ S\{2, 3, 4}.
To find an optimal order for every possible coalition, Musegaas et al. (2015) provided a polynomial time algorithm. Given a one-machine sequencing situation (N , σ 0 , p, α) and a coalition S ∈ 2 N \{∅}, the polynomial time algorithm introduced by Musegaas et al. (2015) starts with a preprocessing step. In this preprocessing step, the players within the components of S are reordered such that they are in weakly decreasing order with respect to their urgency. This is done by setting the initial processing order σ 0 equal to the processing order σ S 0 , where σ S 0 ∈ A(σ 0 , S) is the unique urgency respecting processing order such that for all i ∈ S where a processing order σ ∈ (N ) is called urgency respecting with respect to S if (i) (σ is componentwise optimal) for all i, j ∈ S with c(i, S, σ ) = c( j, S, σ ): (ii) (σ satisfies partial tiebreaking) for all i, j ∈ S with c(i, S, σ 0 ) = c( j, S, σ 0 ): Note that (1) states that all players in S stay in their component, i.e., the partition of S into components stays the same. Moreover, condition (i) of urgency respecting states that the players within a component of S are in weakly decreasing order with respect to their urgency. Moreover, a tiebreaking rule in condition (ii) ensures that if there are two players with the same urgency in the same component of S with respect to σ 0 , then the player who was first in σ 0 is earlier in processing order σ . Note that the partial tiebreaking condition does not imply anything about the relative order of two players with the same urgency who are in the same component of S with respect to σ but who were in different components of S with respect to σ 0 . Therefore, an arbitrary urgency respecting order does not need to be unique, but σ S 0 , because of condition (1), is.
After the preprocessing step, the players in S are considered in reverse order with respect to σ S 0 and for every player the algorithm checks whether moving the player to a certain position later in the processing order is beneficial. If so, then the algorithm will move this player. The algorithm works in a greedy way in the sense that every player is moved to the position giving the highest cost savings at that moment. Moreover, every player is considered in the algorithm exactly once and every player is moved to another position in the processing order at most once. The obtained processing order after the complete run of the algorithm is denoted by σ S .
The following properties follow directly from the definition and the characteristics of the algorithm for finding the optimal processing order σ S for coalition S and will be used in this paper in order to show that SoSi sequencing games are convex.
-Property (i): after every step during the run of the algorithm, we have a processing order that is urgency respecting with respect to S. -Property (ii): if during the run of the algorithm a player is moved to a position later in the processing order, then this results in strictly positive cost savings which corresponds to the highest possible cost savings at that instance. In case of multiple options, we choose the component that is most to the left and, in that component, we choose the position that is most to the left.
-Property (iii): the mutual order between players who have already been considered will stay the same during the rest of the run of the algorithm. -Property (iv): the processing order σ S is the unique optimal processing order such that no player can be moved to an earlier component while the total costs remain the same. Also, if there are two players with the same urgency in the same component, then the player who was first in σ 0 is earlier in processing order σ S . -Property (v): if it is admissible with respect to σ 0 to move a player to a component more to the left with respect to order σ S , then moving this player to this component will lead to higher total costs.
An interesting property for the urgencies of players in an optimal order is that if it is admissible that two players switch position, then the player with the highest urgency should be positioned first. This is stated in the following proposition.
From the previous proposition together with the fact that the algorithm moves a player to the left as far as possible (see property (ii) of the algorithm), we have that if the algorithm moves player k to a later component, then the players from coalition S that player k jumps over all have a strictly higher urgency than player k.
In the following example the algorithm is applied on an instance of a SoSi sequencing game. In this example we use the concept of composed costs per time unit and composed processing times, where the composed costs per time unit α U and the composed processing time p U for a coalition U ∈ 2 N are defined by Example 3.2 Consider a one-machine sequencing situation (N , σ 0 , p, α) with S ⊆ N such that S = {1, 2, . . . , 10}. In Fig. 4 an illustration can be found of initial order σ 0 together with all relevant data on the cost coefficients and processing times (the numbers above and below the players, respectively). The completion times of the players with respect to this initial order are also indicated in the figure (bottom line in bold). In the preprocessing step the algorithm processing order σ is set to processing order σ S 0 (see Fig. 5) and we initialize Next, the players in S are considered in reverse order with respect to σ S 0 and the algorithm starts with the last player of the penultimate component, which is player 6.
Player 6: if player 6 is moved to the last component, then the position of player 6 should be behind player 7 (since the players in the components must stay in weakly decreasing order with respect to their urgencies, see property (i) of the algorithm). The resulting cost savings are Hence, we update processing order σ by moving player 6 to the position directly behind player 7 (see Fig. 6) and we set v(S) := 187 + 31 = 218.
Player 5: according to the given urgencies, player 5 should be moved to the position directly behind player 6 if he is moved to a later component. The resulting cost savings are Hence, we update processing order σ by moving player 5 to the position directly behind player 6 (see   The processing order σ after player 2 is considered in Example 3.2 Player 4: since all followers of player 4 who are members of S have a lower urgency, it is impossible to reduce the total costs by moving player 4 to a different position (see Proposition (3.1)). Hence, σ and v(S) are not changed.
Player 1: there are two components behind player 1. If player 1 is moved to a different component, then the position of player 1 should be either directly behind player 4 or directly behind player 10. The resulting cost savings are 18 and 21, respectively. Hence, player 1 is moved behind player 10 (see property (ii) of the algorithm). Processing order σ is updated (see Fig. 8) and v(S) is increased by 21, so v(S) := 269.
Player 2: like in the previous step we have again two possibilities, namely moving behind player 4 with cost savings 9 or behind player 10 with cost savings 6. Hence, it is most beneficial to move player 2 behind player 4. Processing order σ is updated (see Fig. 9) and v(S) is increased by 9, so v(S) := 278.
Player 3: there are two components behind player 3. Note that all players in the last component have a lower urgency than player 3. Therefore, it is impossible to reduce the total costs by moving player 3 to the last component. If player 3 is moved to the second component, then the position of player 3 should be directly behind player 4. The resulting cost savings are −21 and thus moving player 3 to the second component will not reduce the total costs. Hence, the order depicted in Fig. 9 is the optimal processing order σ S for coalition S obtained by the algorithm. Furthermore, v(S) = 278.
The following proposition, which will frequently be used later on, provides a basic property of composed costs per time unit and composed processing times. Namely, if every player in a set of players U is individually more urgent than a specific player i, then also the composed job U as a whole is more urgent than player i. 2 or equivalently, Proof Assume u i < u j for all j ∈ U , i.e., α i p j < α j p i , for all j ∈ U . By adding these |U | equations we get α i j∈U p j < p i j∈U α j , i.e., The following lemma compares the processing orders that are obtained from the algorithm with respect to coalition S and coalition S ∪ {i}, in case player i ∈ N \S is the only player in the component of S ∪ {i} with respect to σ 0 . This lemma will be the driving force behind Theorem 3.4, which in turn is the crux for proving convexity of SoSi sequencing games.
From the previous lemma it follows that if one wants to determine an optimal processing order of a coalition in a SoSi sequencing game, then the information of optimal processing orders of specific subcoalitions can be used. More precisely, if one wants to know the optimal processing order σ S∪{i} derived by the algorithm for a coalition S ∪ {i} with i / ∈ S and i being the only player in its component in σ 0 , then it does not matter whether you take σ 0 or σ S as initial processing order, as is stated in the following theorem.
Since the initial order will be varied we need some additional notation. We denote the obtained processing order after the complete run of the algorithm for onemachine sequencing situation (N , σ, p, α) with initial order σ and coalition S by Proof We start with proving that the minimum costs for coalition S ∪ {i} in the sequencing situation (N , σ 0 , p, α) is equal to the minimum costs for coalition S ∪ {i} in the sequencing situation (N , σ S , p, α). Then, we show that the two corresponding sets of optimal processing orders are equal. Finally, the fact that the algorithm always selects a unique processing order among the set of all optimal processing orders (property (iv)) completes the proof.
Moreover, from Lemma 3.3 we know that for all we have together with (2) that Let O(σ 0 , S ∪ {i}) and O(σ S , S ∪ {i}) denote the set of optimal processing orders for coalition S ∪{i} in sequencing situations (N , σ 0 , p, α) and (N , σ S , p, α), respectively.
Finally, since the algorithm chooses among all optimal processing orders the order in which the players are in a component to the left as far as possible and because the algorithm chooses a fixed order within the components (property (iv)), we have It readily follows from the previous theorem that all players in a component to the right of player i with respect to σ S are not moved to a different component when applying the algorithm to one-machine sequencing situation (N , σ S , p, α) and coalition S ∪ {i}. This is stated in the following proposition.
The next proposition states that all players in a component to the left of player i with respect to σ S are, if they are moved by the algorithm, moved componentwise at least as far as the original component of player i in σ 0 . As a consequence, all players that are in σ S∪{i} to the left of the original component of player i in σ 0 , are not moved by the algorithm when going from σ S to σ S∪{i} . Proposition 3.6 Let (N , σ 0 , p, α) be a one-machine sequencing situation, let S N with S = ∅ and let i ∈ N \S be such that The previous proposition follows directly from the following, more technical, lemma. This lemma shows that, when applying the algorithm to one-machine sequencing situation (N , σ S , p, α) and coalition S ∪ {i}, once a predecessor of player i with respect to σ S is considered by the algorithm, moving this player to a position that is to the left of the original component of player i in σ 0 is never beneficial.
where τ m denotes the processing order during the run of the algorithm for one-machine sequencing situation (N , σ S , p, α) and coalition S ∪ {i} just before player m is considered.
Proof See Appendix B.

On the convexity of SoSi sequencing games
for all S, T ∈ 2 N \{∅}, i ∈ N such that S ⊂ T ⊆ N \{i}, i.e., the incentive for joining a coalition increases as the coalition grows. Using recursive arguments it can be seen that in order to prove convexity it is sufficient to show (5) for the case |T | = |S| + 1 which boils down to for all S ∈ 2 N \{∅}, i, j ∈ N and i = j such that S ⊆ N \{i, j}.
The main result of this paper is the following theorem.
Theorem 4.1 Let (N , σ 0 , p, α) be a one-machine sequencing situation and let (N , v) be the corresponding SoSi sequencing game. Then, (N , v) is convex.
Before presenting the formal proof of our main result, we highlight some of its important aspects beforehand. Using (6), let S ∈ 2 N \{∅}, i, j ∈ N and let i = j be such that S ⊆ N \{i, j}.
Note that without loss of generality we can assume The first assumption is harmless because of the symmetric role of i and j in (6). The second assumption states that player i and j both are the only player in the component of S ∪ { j} ∪ {i} with respect to σ 0 . In theory this is no restriction since it is always possible to add dummy players with zero processing times and zero costs per time unit (a more formal explanation can be found in Appendix C). This assumption facilitates the comparison of the marginal contribution of player i to coalition S and the marginal contribution of player i to coalition S ∪{ j}. For example, if one determines the optimal processing order for coalition S ∪ {i} via initial processing order σ S and player i is the only player in its component of S ∪ { j} ∪ {i} with respect to σ 0 (and thus also with respect to σ S ), then the players of coalition S ∪ {i} are in every component already ordered with respect to their urgency and thus the preprocessing step of the algorithm can be skipped. As a consequence, the marginal contribution of player i to coalition S can be written as the sum of the positive cost difference of the players who are moved by the algorithm to a different component. In order to denote the different types of players that are moved, we introduce the following notation. For U ∈ 2 N \{∅} and k ∈ N such that U ⊆ N \{k} and denote the set of players who are moved to a different component during the run of the algorithm with respect to one-machine sequencing situation (N , σ U , p, α) and coalition U ∪ {k}. Since the algorithm only moves players to components that are to the right of its original component in σ U , we have As the algorithm only moves the players of the coalition U ∪{k} and all players outside this coalition are not moved, we have Moreover, from Propositions 3.5 and 3.6 it follows, respectively, that and for all l ∈ M k (U ).
In order to prove Theorem 4.1 we need to compare the marginal contribution of player i to coalition S and the marginal contribution of player i to coalition S ∪ { j}. As argued above, both marginal contributions can be written as the sum of the positive cost differences of the players who are moved by the algorithm to a different component. In order to compare those cost differences more easily, we first partition the players in M i (S), based on their position in the processing orders σ S and σ S∪{ j} , in four subsets. Second, we derive from σ S a special processing order σ in such a way that all players from M i (S) are in σ and σ S∪{ j} in the same component. The convexity proof is finished by means of adequately comparing all positive cost differences.
Proof of Theorem 4.1 Let S ∈ 2 N \{∅}, i, j ∈ N and i = j such that S ⊆ N \{i, j}.
We partition the players in M i (S), based on their position in the processing orders σ S and σ S∪{ j} , in four subsets. First, note that from (7)  - The proofs of these four claims can be found in Appendix D. Figure 10 illustrates for all four partition elements of M i (S) its position with respect to the original components of player i and player j in the four different processing orders. The solid arrows give the original components and/or the actual positions of player i and j. The dotted arrows give possible positions of player i or j. We define σ ∈ (N ) as the unique urgency respecting processing order that satisfies (ii) for all k ∈ S\M i (S): for all k, l ∈ S with c(k, σ ) = c(l, σ ): Note that conditions (i) and (ii) determine the components for the players in S. Next, the urgency respecting requirement determines the order within the components for  Fig. 11 Overview how to obtain σ S∪{i} from σ S via σ Fig. 12 The position of the players in M i (S) in σ the players with different urgencies. Finally, in case there is a tie for the urgency of two players in the same component, item (iii) states a tiebreaking rule. As a consequence, due to this tiebreaking rule, we have that σ is unique. Note that σ can be considered as a temporary processing order when going from σ S to σ S∪{i} (cf. Fig. 11). The processing order σ is derived from processing order σ S in such a way that all players from M i (S) are in σ and σ S∪{ j} in the same component. From Claim 3 and 4 it follows that the players in M i 1a (S) and M i 2 (S) are in σ S and σ S∪{ j} in the same component and thus those players do not need to be moved. Hence, only the players in M i 1b (S) and M i 1c (S) need to be moved. Hence, we start from σ S and we move all players in M i 1b (S) and M i 1c (S) to the components they are in in σ S∪{ j} . Note that since the tiebreaking rule mentioned in condition (iii) is the same tiebreaking rule as in property (iv) of the algorithm, the mutual order of the players in M i (S) is in σ the same as in σ S∪{ j} .
An illustration of the position of the players in M i (S) in σ can be found in Fig. 12. Note that since i / ∈ S ∪ { j} it follows that c(i, σ S ) = c(i, σ S∪{ j} ). Moreover, we note that σ and σ S∪{ j} are not necessarily equal to each other as the players in M j (S)\M i (S) are in σ and σ S∪{ j} in different components. However, as the players in M j (S) will be moved to a component to the right when going from σ S to σ S∪{ j} , we have for all k ∈ S ∪ { j} ∪ {i}. Now we consider the transition from σ to σ S∪{i} and its corresponding cost differences. Since the players in M i 1c (S) are in σ already in the component they are in in σ S∪{i} , only all players in M i 1a (S), M i 1b (S) and M i 2 (S) need to be moved to a component to the right when going from σ to σ S∪{i} (see also Fig. 11). We go from σ to σ S∪{i} by considering the players in M i 1a (S), M i 1b (S) and M i 2 (S) in an order reverse to the order they are in σ , i.e., the players are considered from the right to the left.
S), denote the processing order just before player k is moved by τ k and let r k denote the player that player k will be moved behind. The cost difference for coalition S ∪ {i} due to moving this player, when going from σ to σ S∪{i} , is denoted by δ k , i.e., Similarly, we can write the marginal contribution of player i to coalition S ∪ { j} as the sum of positive cost differences of the players in M i (S ∪ { j}). We go from σ S∪{ j} to σ S∪{ j}∪{i} by considering the players in M i (S ∪ { j}) in an order reverse to the order they are in σ S∪{ j} , i.e., the players are considered from the right to the left. We note that since the mutual order of the players in M i (S) is the same in σ and σ S∪{ j} , the order in which the players in M i 1a (S) ∪ M i 1b (S) ∪ M i 2 (S) are considered when going from σ to σ S∪{i} is the same as the order in which they are considered when going from σ S∪{ j} to σ S∪{ j}∪{i} . For k ∈ M i (S ∪ { j}), denote the processing order just before player k is moved by τ k and let r k denote the player that player k will be moved behind. The cost difference for coalition S ∪ { j} ∪ {i} due to moving this player, when going from σ S∪{ j} to σ S∪{ j}∪{i} , is denoted by δ k , i.e., From (12) for all k ∈ M i 1a (S) ∪ M i 1b (S) ∪ M i 2 (S) and l ∈ S ∪ { j} ∪ {i}. The following claim states that the cost savings when moving a player in M i 1a (S) ∪ M i 1b (S) ∪ M i 2 (S) when going from σ to σ S∪{i} is at most the cost savings when moving the same player when going from σ S∪{ j} to σ S∪{ j}∪{i} .
Proof The proof can be found in Appendix E.
We are now ready to prove (10). Note that a detailed explanation of the subsequent equalities and inequalities can be found after the equations.

Explanations
(i) The extra worth that is obtained by adding player i to coalition S can be split into two parts. The first part is due to the fact that player i joins the coalition and it represents the cost savings for player i in processing order σ S compared to σ 0 . The completion time of player i is reduced by the sum of the processing times of the players that jumped over player i when going from σ 0 to σ S without moving any players. The second part represents the cost savings for coalition S ∪ {i} by additionally moving players when going from σ S to the optimal processing order σ S∪{i} . (ii) The optimal processing order σ S∪{i} can be obtained from σ S via σ where some players are already (partially) moved to the right. (iii) The cost difference for coalition S ∪{i} when going from σ S to σ can be split into two parts: the cost difference for coalition S and the cost difference for player i. By the definition of σ and since i / ∈ S ∪ { j}, player i is not moved when going from σ S to σ and the completion time of player i is reduced by the sum of the processing times of the players that jumped over player i when going from σ S to σ , i.e., the sum of the processing times of the players in M i 1c (S). (iv) Processing order σ S is optimal for coalition S and thus C(σ S , S) − C(σ , S) ≤ 0. Fig. 10) and δ k > 0 for all k ∈ M i (S ∪ { j}) due to property (ii) of the algorithm. (viii) This follows from the definition of δ k .

(v) This follows from the definition of δ k . (vi) This follows from Claim 5. (vii) This follows from (M
(ix) This follows from M i 1c (S) ⊆ (P(σ S , i) ∩ F(σ S∪{ j} , i)) (cf. Fig. 10). (x) The group of players that jump over player i when going from σ 0 to σ S∪{ j} can be split into two groups: the group of players that jumped over player i when going from σ 0 to σ S and the group of players that were positioned in front of player i in σ S but jumped over player i when going from σ S to σ S∪{ j} . Hence, which proves the convexity of SoSi sequencing games.
Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.

Appendix A: Proof of Lemma 3.3
In this proof we denote c(k, S ∪ {i}, σ ) by c(k, σ ) for every k ∈ S ∪ {i} and every σ ∈ (N ). We prove the lemma with the help of the algorithm. First, note that because player i is the only player in its component in σ 0 , we have σ S 0 = σ S∪{i} 0 , i.e., the processing orders are the same after the preprocessing step of the algorithm. Therefore, if we go from σ 0 to the optimal processing orders σ S and σ S∪{i} , then the steps performed by the algorithm are the same up to the moment that player i is considered. Moreover, since the players are considered in reverse order with respect to σ S 0 , we have for all k ∈ S ∩ F(σ S 0 , i). Hence, it remains to be proven that also for the players in S ∩ P(σ S 0 , i) the lemma is true. Let player m ∈ S be the closest predecessor of player i with respect to σ S 0 for which the lemma is not true, i.e., c(m, σ S∪{i} ) < c(m, σ S ), and c(k, σ S∪{i} ) ≥ c(k, σ S ), for all k ∈ S ∩ F(σ S 0 , m) ∩ P(σ S 0 , i). We will derive a contradiction. We continue the proof as follows. We look to which component player m will be moved to by the algorithm with respect to coalition S. Then, there is a specific player who is in a component with index at least as high as the component that player m is moved to by the algorithm with respect to coalition S. We show that moving player m behind this specific player is actually more beneficial with respect to coalition S ∪ {i}, which contradicts the optimality of the algorithm.
Denote the processing order when player m is considered by the algorithm with respect to coalition S by τ S and with respect to coalition S ∪ {i} by τ S∪{i} . Let r S denote the player that player m will be moved behind with respect to coalition S according to the algorithm. Similarly, let r S∪{i} denote the player that player m will be moved behind with respect to coalition S ∪ {i} according to the algorithm. Note that in case player m is not moved by the algorithm with respect to coalition S ∪ {i}, then we define player r S∪{i} as player m. Since c(m, σ S∪{i} ) = c(r S∪{i} , τ S∪{i} ) and As we will see later be such that player m would be moved behind this player in case player m is moved to component (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) according to the algorithm with respect to coalition S . Note that playerr S is unique because the algorithm always selects a unique player per component. Note that playerr S might also be player i as in this way we make sure that playerr S also exists if c(r S∪{i} , τ S∪{i} ) = c(i, σ 0 ). 3 Note that in case players m and r S∪{i} coincide (that means that player m is not moved by the algorithm with respect to coalition S ∪ {i}), then we define playerr S as player m.
Since player m is moved behind player r S and not behind playerr S , we have due to property (v) of the algorithm that We distinguish between two cases: Hence, there are no players of coalition S in between player m and player i in σ S 0 . Then, from (14) it follows that for every k ∈ S ∩ F(τ S , m) we have Note that this implies that (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) is non-empty. We will prove that moving player m behind player r S is more beneficial than moving player m behind player r S∪{i} , i.e., we will prove that This would imply that the step made by the algorithm for player m when applied on coalition S ∪ {i} is not optimal, which contradicts the optimality of the algorithm. Hence, for Case A, it remains to prove (18). We distinguish from now on between the following four cases: Note that this case occurs if r S∪{i} = m and player i is not necessarily moved by the algorithm with respect to coalition S ∪ {i}. Then, it follows from (17) Note that this case occurs if r S∪{i} = m and player i has been moved by the algorithm with respect to coalition S ∪{i} such that τ S∪{i} (i) > τ S∪{i} (r S ). Then, using the same arguments as in Case A.1, we have Note that this case occurs if r S∪{i} = m and player i has either not been moved by the algorithm with respect to coalition S ∪ {i} or it has been moved such that τ S∪{i} (i) < τ S∪{i} (r S ). Then, using the same arguments as in Case A.1, we have

Case A.4 [i /
∈ N τ S (r S , r S ] and i ∈ N τ S∪{i} (r S∪{i} , r S ]] Note that this case occurs if r S∪{i} = m and player i has been moved by the algorithm with respect to coalition S ∪ {i} such that τ S∪{i} (r S∪{i} ) < τ S∪{i} (i) < τ S∪{i} (r S ).
Then, using the same arguments as in Case A.1, we have If we can show that α i p m − α m p i > 0, (18) follows.
Letr S be the direct predecessor of player i in τ S∪{i} . Since player i is moved behind playerr S and not behind player r S , we have due to the optimality of the algorithm that Consequently, it follows from (17) together with the fact c(r S , τ S ) = c(i, τ S∪{i} ) that we also have Therefore, together with (16), we can conclude α i Hence, there are players of coalition S in between player m and player i in σ S 0 . Therefore, due to the definition of player m, it follows that for every k ∈ S with i.e., the statement in the lemma holds for all followers of player m with respect to σ S 0 intersected with S ∩ P(σ S 0 , i). First, note that (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) is non-empty because of the following. Due to requirement (i) and (ii) of admissibility we know that the first player in (S ∪ {i}) σ 0 ,τ S∪{i} c(r S∪{i} ,τ S∪{i} ) with respect to τ S∪{i} is also the first player in (S ∪{i}) σ 0 ,σ S 0 c(r S∪{i} ,τ S∪{i} ) with respect to σ S 0 . Therefore, using (19) we know that this player also belongs to (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) . Hence, (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) is non-empty. Next, define player l ∈ S τ S (r S , r S ] as the player in S τ S (r S , r S ] who is positioned last with respect to τ S∪{i} , i.e., τ S∪{i} (l) ≥ τ S∪{i} (k) for all k ∈ S τ S (r S , r S ]. Note that player l was actually player r S in Case A because of (17). From the assumptions in (19) and (15) it follows that i.e., player l is to the right of player r S∪{i} in τ S∪{i} . We will prove that moving player m behind player l is more beneficial than moving player m behind player r S∪{i} , i.e., we will prove that This implies that the step made by the algorithm for player m when applied on coalition S ∪ {i} is not optimal, which contradicts the optimality of the algorithm. Hence, for Case B, it remains to prove (21). From the definitions of playersr S and l, together with (19), it follows that Moreover, since during the run of the algorithm player m jumps over all players in S τ S (m, r S ], Proposition (3.1) implies that for all k ∈ S τ S (m, r S ]. Below we distinguish between the following four cases: (20), we distinguish between another two cases: Sincer S ∈ (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) and thus c(r S , τ S ) = c(r S∪{i} , τ S∪{i} ), the assump- For every k ∈ S τ S∪{i} (r S∪{i} , l]\S τ S (r S , r S ] we know that k ∈ S τ S (m,r S ], because c(k, τ S ) ≤ c(k, τ S∪{i} ) by (19) and P(τ S , m) = P(τ S∪{i} , m). Hence, also k ∈ S τ S (m, r S ] and thus from (23) it follows that u k > u m . Together with Proposition 3.2 applied on the set S τ S∪{i} (r S∪{i} , l]\S τ S (r S , r S ] and player m we have where the equality follows from the assumption i / ∈ N τ S∪{i} (r S∪{i} , l]. As a consequence, > 0, proving (21).

Case B.1(ii) [c(l, τ S∪{i} ) > c(r S , τ S )]
Define Q as the set of players from S τ S (r S , r S ] who are positioned in τ S∪{i} in a component to the right of component (S ∪ {i}) σ 0 ,τ S∪{i} c(r S ,τ S ) . Since c(l, τ S∪{i} ) > c(r S , τ S ) and l ∈ S τ S (r S , r S ], we have l ∈ Q and thus Q = ∅. Select from Q only the players who have in their corresponding component in τ S∪{i} no players from S τ S (r S , r S ] in front of him and denote this set of players by Q, i.e., we select in each component a player of Q (if possible) that is most to the left in τ S∪{i} .
Set Q = {q 1 , q 2 , . . . , q |Q| } such that c(q k , τ S∪{i} ) < c(q k+1 , τ S∪{i} ) for all k ∈ {1, . . . , |Q| − 1}. Define w 1 as the first player in (S ∪ {i}) σ 0 c(r S ,τ S ) , i.e., the direct follower in τ S∪{i} of component (S ∪ {i}) σ 0 ,τ S∪{i} c(r S ,τ S ) . For k ∈ {2, . . . , |Q|}, define w k as the first player in (S ∪ {i}) σ 0 c(q k−1 ,τ S∪{i} ) , i.e., the direct follower in τ S∪{i} of component (S ∪ {i}) σ 0 ,τ S∪{i} c(q k−1 ,τ S∪{i} ) . Note that because of the definition of player l we have and and Note, for k ∈ {1, . . . , |Q|}, we have c(q k , σ 0 ) ≤ c(q k , τ S ) ≤ c(r S , τ S ). Hence, as w k is in τ S∪{i} to the right of component (S ∪ {i}) σ 0 ,τ S∪{i} c(r S ,τ S ) , we have that it is admissible to move player q k in front of w k with respect to τ S∪{i} . In other words, it is admissible to move player q k to the tail of component (S ∪{i}) σ 0 ,τ S∪{i} c(q k−1 ,τ S∪{i} ) (and the tail of component (S ∪ {i}) σ 0 ,τ S∪{i} c(r S ,τ S ) in case k = 1). Since player q k is not moved behind player w k , we have due to property (v) of the algorithm that Moreover, since q k ∈ S τ S (m, r S ] it follows from (23) that u m < u q k . As a consequence, We have Note that the second equality follows from c(r S , τ S ) = c(r S∪{i} , τ S∪{i} ), the fact that w 1 is the direct follower in τ S∪{i} of component (S ∪ {i}) σ 0 ,τ S∪{i} c(r S ,τ S ) , and the assump- For every k ∈ S τ S∪{i} (r S∪{i} , l]\R, we know that either k ∈ S τ S (m,r S ] or c(k, τ S ) ≥ c(r S , τ S ). If k ∈ S τ S (m,r S ], then also k ∈ S τ S (m, r S ] and thus from (23) we have u k > u m . Next, if c(k, τ S ) ≥ c(r S , τ S ), then because c(l, τ S ) ≤ c(r S , τ S ) we know that the swap of players k and l with respect to τ S∪{i} is admissible. Therefore, according to Proposition 3.1, we know u k ≥ u l . Moreover, since l ∈ S τ S (m, r S ], it follows from (23) that u m < u l . As a consequence, u m < u k . Together with Proposition 3.2 applied on the set S τ S∪{i} (r S∪{i} , l]\R and player m we have where the equality follows from the assumption i / ∈ N τ S∪{i} (r S∪{i} , l]. As a consequence, Case B.2 [i ∈ N τ S (r S , r S ] and i / ∈ N τ S∪{i} (r S∪{i} , l]] Note that this case occurs exactly if c(r S , τ S ) < c(i, σ 0 ) < c(r S , τ S ) and player i has been moved by the algorithm with respect to coalition S ∪ {i}, such that τ S∪{i} (i) > τ S∪{i} (l). We have (32) Then, using the same arguments as in Case B.1, we can prove (21). Namely, where we used (16) in Case B.1, we now use the above equation. Hence, player i has already been taken into account and thus for using the same arguments as in Case B.1 we can assume i / ∈ N τ S (r S , r S ] and i / ∈ N τ S∪{i} (r S∪{i} , l]. For example, analogous to Case B.1(i), Case B.2(i) goes as follows. Sincer S ∈ (S ∪ {i}) σ 0 ,τ S c(r S∪{i} ,τ S∪{i} ) and thus c(r S , τ S ) = c(r S∪{i} , τ S∪{i} ), the assumption c(l, τ S∪{i} ) = c(r S , τ S ) implies that Using exactly the same arguments as in Case B.1(i), we have As a consequence, proving (21).
Note that this case occurs exactly if c(r S , τ S ) < c(i, σ 0 ) < c(r S , τ S ) and player i has either not been moved by the algorithm with respect to coalition S ∪ {i} or it has been moved such that τ S∪{i} (i) < τ S∪{i} (l). We have > 0.
Then, using the same arguments as in Case B.1, we can prove (21).
It suffices to show that α i p m − α m p i > 0. Together with the above equation and (16), we can prove (21) by using the same arguments as in Case B.1.
We distinguish between two cases: Note that this case occurs exactly if τ S∪{i} (i) < τ S∪{i} (l). This means that player i is not necessarily moved by the algorithm with respect to coalition S ∪ {i}. Then, Hence, the swap of players i and l with respect to σ S∪{i} is admissible and thus, according to Proposition 3.1, we have u i ≥ u l . Consequently, together with (23), we have u i ≥ u l > u m . Hence, α i p m − α m p i > 0.

Case B.4(ii) [c(i, σ 0 ) < c(r S , τ S )]
Note that this case occurs exactly if player i has been moved by the algorithm with respect to coalition S ∪ {i} such that Hence, the swap of players m and l with respect to σ S∪{i} is admissible and thus, according to Proposition 3.1, we have u m ≥ u l . This is a contradiction with (23) and thus we know c(l, σ 0 ) > c(i, σ 0 ). Therefore, using (14), we have c(l, τ S ) = c(l, τ S∪{i} ) which implies l = r S . As a consequence, if k ∈ S τ S∪{i} (r S∪{i} , r S ], then also k ∈ S τ S (m, r S ] and thus from (23) we have u m < u k . With the same arguments we used for player l we can conclude c(k, σ 0 ) > c(i, σ 0 ) and thus c(k, τ S ) = c(k, τ S∪{i} ). Therefore, we have and for all k ∈ S τ S (r S , r S ]. Letr S be the direct predecessor of player i in τ S∪{i} . Since player i is in τ S∪{i} behind playerr S and not behind player r S , although this is an admissible swap, we have Consequently, it follows from (35) and (36) together with the fact that c(r S , τ S ) = c(i, τ S∪{i} ), that Moreover, since player m is moved behind player r S and not behind playerr S , we have due to property (v) of the algorithm that Therefore, we can conclude α i p i > α m p m , i.e., α i p m − α m p i > 0, which is exactly what we needed.
Case 2 [there exists a player k ∈ S σ S (m, l] with u m > u k ] Let player q ∈ S σ S (m, l] be the closest follower of player m in σ S with a smaller urgency than player m: u q < u m ≤ u k for all k ∈ S σ S (m, q). Since q ∈ S ∩ P(σ S , i) ∩ F(σ S , m), it follows from the induction assumption in (37) that α (S∪{i}) τq (q,l] As a consequence, since u q < u m , we also have α (S∪{i}) τq (q,l] p m − α m p N τq (q,l] < 0.
We distinguish between two cases: -Case 2(i): S σ S (m, q) ∩ S τ m (m, l] = ∅, i.e., all players in S σ S (m, q) have been moved by the algorithm, -Case 2(ii): S σ S (m, q) ∩ S τ m (m, l] = ∅, i.e., not all players in S σ S (m, q) have been moved by the algorithm.
We will show that since moving player q behind player l in τ q is not beneficial, moving player m behind player l in τ m is also not beneficial. Since player m is a predecessor of player q in σ S , we have with an equality in case c(q, σ S ) = c(m, σ S ). Since all players in S σ S (m, q) have been moved by the algorithm, we have if player q has also been moved by the algorithm, and if player q has not been moved by the algorithm. As a consequence, α (S∪{i}) τm (m,l] p m − α m p N τm (m,l] = α (S∪{i}) τm (m,l] < 0, if player q has not been moved by the algorithm, which proves (4).
We move player m behind player l in τ m in two stages. In the first stage, player m will be moved behind a specific player t. Then, in the second stage, player m will be moved behind player l. Using similar arguments as in Case 1 we can show that the move in the first stage is not beneficial, and using similar arguments as in Case 2(i) we can show that the move in the second stage is not beneficial. As a consequence, since cost differences have an additive structure and because the moves in both stages are not beneficial, moving player m behind player l in τ m is not beneficial. Let player t ∈ S σ S (m, q) be the closest predecessor of player q in σ S who is also a member of S τ m (m, l]. Note that due to the assumption S σ S (m, q) ∩ S τ m (m, l] = ∅, player t exists. Because player t is a predecessor of player q in σ S , we have u m ≤ u k for all k ∈ S σ S (m, t]. Therefore, using the same arguments as in Case 1, we have Since player t is a predecessor of player q in σ S and because t ∈ S τ m (m, l] (which means that player t has not been moved by the algorithm), we have with an equality in case c(q, σ S ) = c(t, σ S ). Because of the definition of player t we have if player q has been moved by the algorithm, and if player q has not been moved by the algorithm. As a consequence, by using the additive structure of cost differences, we have α (S∪{i}) τm (m,l] p m − α m p N τm (m,l] = α (S∪{i}) τm (m,t] + α (S∪{i}) τm (t,l] p m − α m p N τm (m,t] ≤ α (S∪{i}) τm (t,l]  if player q has not been moved by the algorithm. Hence, by using the additive structure of cost differences we have shown that moving player m behind player l in τ m is not beneficial.
in order to prove the convexity of SoSi sequencing games. Suppose that player i is not the only player in his component in σ 0 , i.e., Then, for example, the direct predecessor of player i in σ 0 is a member of S ∪{ j}∪{i}. We can define a different one-machine sequencing situation (N , σ 0 Hence, this new sequencing situation (N , σ 0 , p, α) is obtained from the original sequencing situation (N , σ 0 , p, α) by adding a dummy player, with processing time and costs per time unit both equal to zero, directly in front of player i such that the predecessor of player i does not belong to S ∪ { j} ∪ {i} anymore. Let (N , v) be the SoSi sequencing game corresponding to one-machine sequencing situation (N , σ 0 , p, α). Although α d = 0 and p d = 0, we can still apply the algorithm with respect to coalition S ∪ { j} ∪ {i} and initial processing order σ 0 , because player d is not a member of S ∪ { j} ∪ {i}. The mutual order of the players in N will be the same in Alg((N , σ 0 , p, α), S ∪ { j} ∪ {i}) and Alg ((N , σ Note that if also the direct follower of player i in σ 0 is a member of S ∪ { j} ∪ {i}, then we also add a dummy player directly behind player i. By adding a dummy player directly in front and behind player i, player i will be the only player in his component. Moreover, all arguments can also be applied to player j. Hence, without loss of generality we can assume that player i and j are both the only player in their component in σ 0 . and δ i = α (S∪{ j}∪{i}) In order to prove δ i ≤ δ i , we compare the two sets of players that player i jumps over in τ i and τ i . We will show that all players that player i jumps over in τ i , player i also jumps over in τ i . However, there might be some players that player i jumps over in τ i but not in τ i . It can be shown that these extra players that player i jumps over in τ i all have a higher urgency than player i and thus this results in extra cost savings. Formally, we show the following three statements: Proof of Statement 1(a) From Claim 1 it follows that c(i, σ S∪{i} ) = c(i, σ S∪{ j}∪{i} ) and thus player i will be moved in both processing orders to the same component, i.e., Moreover, by the definition of σ and since i / Hence, player i is moved in τ i and τ i from the same component and to the same component, so player i jumps in τ i and τ i over the same players outside S ∪ { j} ∪ {i}. Moreover, because σ ( j) < σ (i) and thus τ i ( j) < τ i (i), we have j / ∈ N τ i (i, r i ]. To summarize, (12) we know that player l is in τ i in a component at most as far to the right as in τ i , i.e., Moreover, from l ∈ (S ∪ {i}) τ i (i, r i ] and (50) it follows that Note that there is a strict inequality because player i is the only player in his component. Combining the previous two equations we get i.e., player l is also to the right of player i in τ i . Now suppose player l is to the right of player r i in τ i , then player l is to the right of player i in σ S∪{ j}∪{i} and thus c(l, σ S∪{i} ) ≤ c(i, σ S∪{i} ) = c(i, σ S∪{ j}∪{i} ) ≤ c(l, σ S∪{ j}∪{i} ), where the first inequality follows from l ∈ (S ∪ {i}) τ i (i, r i ] and the first equality follows from Claim 1. Therefore, it follows that the swap of player i and player l with respect to σ S∪{ j}∪{i} is admissible. From Proposition 3.1 it then follows that u i ≥ u l . However, since player i jumps over player l when going from σ to σ S∪{i} , it follows from Proposition 3.1 that u l > u i , which contradicts u i ≥ u l . Therefore l cannot be to the right of player r i in τ i , so player l is to the left of player r i in τ i . Combining this result with (51)  Note that if in Statement 1(b) we have equality, then the inequality δ i ≤ δ i follows immediately from Statement 1(a). Next, if in Statement 1(b) we have a strict subset, then The idea behind the previous strict inequality is as follows. Player i jumps in τ i over the same players as in τ i , but additionally player i jumps in τ i also over some extra players.
It follows from Statement 1(c) that these extra players all have a higher urgency and thus the jump of player i over those extra players results in cost savings.

Case 2 [k = i]
The difference with respect to Case 1 is that in this case player k is not necessarily the only player in its component, while in Case 1 player i was the only player in its component of S ∪ { j} ∪ {i} with respect to σ 0 . Another difference is that now player k might not be the first player who is moved, and thus τ k and σ , and τ i and σ S∪{ j} might differ. Note that δ k = α (S∪{i}) τ k (k,r k ] p k − α k p N τ k (k,r k ] , and δ k = α (S∪{ j}∪{i}) τ k (k,r k ] p k − α k p N τ k (k,m k ] . In order to prove δ k ≤ δ k , we compare the two sets of players that player k jumps over in τ k and τ k . We will show that all players, excluding player j, that player k jumps over in τ k , player k also jumps over in τ k . Formally, we show the following three statements (which are similar to Statements 1(a)-(c)): - Note that in the proof of Statement 1(a) and 1(c) the fact that player i is the only player in its component is not used and therefore the proofs for Statements 2(a) and 2(b) are similar.
Proof of Statement 2(b) Let l ∈ (S ∪ {i}) τ k (k, r k ]. From (13) we know that player l is in τ k in a component at most as far to the right as in τ k , i.e., c(l, τ k ) ≤ c(l, τ k ).
Combining the previous two equations we get c(k, τ k ) ≤ c(l, τ k ).
The idea behind the strict inequality is as follows. Player k jumps in τ k over the same players as in τ k , but additionally player k jumps in τ k also over some extra players. It follows from Statement 2(c) that these extra players all have a higher urgency and thus the jump of player k over those extra players results in cost savings.
Case 2(ii) [ j ∈ N τ k (k, r k ] and j ∈ N τ k (k, r k ]] It follows that The idea behind the strict inequality is as follows. All players, including player j, that player k jumps over in τ k , player k also jumps over in τ k . However, as player j belongs to coalition S ∪ { j} ∪ {i} and not to coalition S ∪ {i}, there are some extra cost savings in δ k . These extra cost savings are due to the reduction of the processing time for player j due to the jump of player k, namely α j p k . The idea behind the strict inequality is as follows. All players, excluding player j, that player k jumps over in τ k , player k also jumps over in τ k . However, as player k jumps over player j in τ k and not in τ k , the completion time of player k will increase with at least p j more in τ k than in τ k and thus the cost savings in δ k are less than in δ k .