Finding and verifying the nucleolus of cooperative games

The nucleolus offers a desirable payoff-sharing solution in cooperative games, thanks to its attractive properties—it always exists and lies in the core (if the core is non-empty), and it is unique. The nucleolus is considered as the most ‘stable’ solution in the sense that it lexicographically minimizes the dissatisfactions among all coalitions. Although computing the nucleolus is very challenging, the Kohlberg criterion offers a powerful method for verifying whether a solution is the nucleolus in relatively small games (i.e. with the number of players n≤15\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$n \le 15$$\end{document}). This approach, however, becomes more challenging for larger games because of the need to form and check a criterion involving possibly exponentially large collections of coalitions, with each collection potentially of an exponentially large size. The aim of this work is twofold. First, we develop an improved version of the Kohlberg criterion that involves checking the ‘balancedness’ of at most (n-1)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$(n-1)$$\end{document} sets of coalitions. Second, we exploit these results and introduce a novel descent-based constructive algorithm to find the nucleolus efficiently. We demonstrate the performance of the new algorithms by comparing them with existing methods over different types of games. Our contribution also includes the first open-source code for computing the nucleolus for games of moderately large sizes.


Introduction
Cooperative games model situations where players can form coalitions to jointly achieve some objective.Assuming that it is more beneficial for the players to work together, a natural question is how to divide the reward of the collaboration among the players in such a way that ensures the stability of the grand coalition, i.e. avoiding any subgroup of players to break away in order to form their own coalition and increase their total payoff.Solution concepts in cooperative games provide the means to achieve this.
In a cooperative game (with transferable utilities), each coalition of players is associated with a value, a real number that represents what that coalition could achieve by working together, independently of other players.We are looking for a stable allocation of the value associated with the grand coalition, that includes every player in the game.A natural requirement from such an outcome is to allocate exactly the grand coalition value, and to do that individually rationally, i.e. each player should receive at least her stand-alone value.There are games where no such outcome exists, however, for our purposes in particular, we consider games where at least one individually rational outcome exists.
Applying the same concept to all groups of players, coalitionally rational outcomes form the core, guaranteeing to every coalition at least the amount that they could achieve by breaking away from the grand coalition.In this sense, core outcomes can be considered stable.However, it is possible that no payoff vector satisfies this condition, and a core outcome might not exist.Furthermore, in the appealing case of a non-empty core, one might find multiple core payoffs, offering possibly different levels of stability.
There are other solution concepts which provide outcomes that are, in a certain sense, as stable as possible.The first such solution concept is called the least core, which minimizes the worst level of dissatisfaction, i.e. the difference of what a coalition could achieve on their own and the amount allocated to the coalition, among all the coalitions.Note that least core payoffs always exist, but such a payoff vector might still not be unique.
Least core outcomes minimize the worst (largest) dissatisfaction level among all coalitions over the set of efficient payoff vectors, that allocate exactly the grand coalition value.Since there might be multiple of such outcomes, we might be interested in minimizing the second (third, etc.) largest dissatisfaction level of the remaining coalitions among these outcomes.By lexicographically minimizing the non-increasingly ordered dissatisfactions of all coalitions, we arrive at one of the most widely known solution concepts in cooperative game theory, the nucleolus, which is the 'most stable' individually rational outcome.In this paper we are focusing on the computation and the verification of the nucleolus.
The nucleolus was introduced in 1969 by Schmeidler [1] as a solution concept with attractive properties: it always exists (in a game with individually rational outcomes), it is unique, and it lies in the core, if the core is non-empty.Despite the desirable properties that the nucleolus has, its computation is, however, very challenging because the process involves the lexicographical minimization of 2 n excess values, where n denotes the number of players.While there is a few classes of games whose nucleoli can be computed in polynomial time (e.g.[2][3][4][5][6][7]), it has been shown that finding the nucleolus is NP-hard for many classes of games, such as the utility games with non-unit capacities [6] and the weighted voting games [8].
While finding the nucleolus is very difficult, Kohlberg [9] provides a necessary and sufficient condition for a given imputation to be the nucleolus, which we will describe in the next section.This set of criteria is particularly useful for relatively small games (e.g. less than 10 players).The verification of it, however, becomes time consuming when the number of players exceeds 15, and becomes computationally extremely demanding when the number of players exceeds 20, even if we have an educated guess on the nucleolus based on the structure of a game.This is because the criterion involves the formation of collections of (tight) coalitions from all 2 n possible coalitions and iteratively verifying if unions of these collections are 'balanced' in a way to be described in details in Sect.2.2.The first aim of our work is to resolve these issues and propose a new improved set of criteria for verifying the nucleolus.
Kopelowitz [10] suggested using nested linear programming (LP) to compute a closely related solution concept, the kernel of a game.This encouraged a number of researchers to focus on the computation of the nucleolus using LPs, rather than sharpening the Kohlberg criterion. 1For example, Kohlberg [12] presents a single LP with O(2 n !) constraints which later on is improved by Owen [13] to O(4 n ) constraints (at the cost of having larger coefficients).Puerto and Perea [14] recently introduced a different single-LP formulation with O(4 n ) constraints and O(4 n ) decision variables and with coefficients in {−1, 0, 1}.The nucleolus can also be found by solving a sequence of LPs.However, either the number of LPs involved is exponentially large [15,16] or the sizes of the LPs are exponential [17][18][19][20].Our second aim is to directly solve the lexicographical minimization problem via introducing a new descent-based approach.We compare our method with classical sequential LP methods (primal and dual sequences as described in [17]), the prolonged simplex method of [18], and the simplex implementation for finding the nucleolus from Derks and Kuipers [19].
The four key contributions of our work are: • We present a new set of necessary and sufficient conditions for a solution to be the nucleolus in Sect.3.1.The number of collections of coalitions to be checked for balancedness is at most (n − 1) (instead of exponentially large as in the original Kohlberg criterion).• We derive a new lexicographical descent algorithm for finding the nucleolus in Sect. 4. The new algorithm is distinguished from existing methods in that we directly solve the lexicographical minimization problem by iteratively finding improving directions through the balancedness checking procedure within the improved Kohlberg criterion.• We demonstrate the performance of the proposed methods through numerical tests on various types of games in Sect. 5. • We develop the first open-source code for computing the nucleolus of moderately large sizes in [21].For completeness it also includes the implementation of algorithms from [17][18][19].
In addition, we provide further contributions such as: • The balancedness condition is essentially equivalent to solving a linear program with strict inequalities-a somewhat undesirable situation in mathematical programming.We provide an efficient tool for checking the balancedness condition in Sect.3.3, requiring solving less number of LPs.
• While checking the Kohlberg criterion, we might end up having to store collections of exponentially large number of coalitions.We provide a method for reducing the storage size of these collections to at most (n − 1) coalitions in Sect.3.2.

Notations
Let n be the number of players and N = {1, 2, . . ., n} be the set of all the players.A coalition S is a subset of players; i.e. S ⊆ N .The characteristic function v : 2 N → R maps each coalition to a real number v(S) (such that v(∅) = 0).An outcome in a game is a payoff vector (payoffs, for short) x = (x 1 , x 2 , . . ., x n ) of real numbers, with x i (i ∈ N ) being the share of player i.We focus on profit games and assume that it is more desirable to have higher shares.All our results can be extended to cost games through transforming the characteristic function to the corresponding profit game.Let us denote x(S) = i∈S x i .Given the total payoff v(N ), efficient outcomes x, also called preimputations, satisfy i∈N x i = v(N ).Let us denote by PI the set of these: PI = {x ∈ R n : x(N ) = v(N )}.The set of imputations, denoted by I, contain efficient outcomes that satisfy individual rationality; that is, The core of the game is the set of all efficient payoffs x such that no coalition has an incentive to break away, i.e. x(S) ≥ v(S) for all S N .
For each outcome x, the excess value of a coalition S is defined as d(S, x) := v(S) − x(S), which can be regarded as the level of dissatisfaction the players in coalition S have with respect to the proposed payoff vector x.Then the least core is defined as follows: the set of preimputations {x ∈ PI : d(x, S) ≤ * ∀S N , S = ∅} form the least core, where * is the smallest value such that the set is nonempty.
For any imputation x, let (x) = ( 1 (x), 2 (x), . . ., 2 n (x)) be the vector of all the 2 n excess values at x sorted in a non-increasing order; i.e. i (x) If we only require x and ν to be preimputations, we arrive at the definition of the prenucleolus, which can be seen as the most stable efficient outcome.In this paper every result is focusing on the nucleolus, hence throughout the paper we consider only games with non-empty imputation set.However, the aim is to develop algorithms applicable to a general class of games, thus we make no further assumptions on the characteristic function.Moreover, with suitable modifications, every result can be applied to the prenucleolus, making them applicable to every cooperative game (with transferable utilities).
For each collection Q ⊆ 2 N , let us denote the size of Q by |Q|.We associate each collection Q with a weight vector in R |Q| with each element denoting the weight of the corresponding coalition in Q.Throughout this paper, we use bold font for vectors and italic font for scalars.Whenever it is clear from context, we are going to omit the argument x from maximal dissatisfaction levels k , tight sets T 0 and T k , collection of tight sets H k , and so on (the latter notions introduced in Sect.2.2).
For S ⊆ N , let us denote by e(S) the characteristic vector of S in {0, 1} n whose ith element is equal to one if and only if player i is in coalition S. With this, for all x ∈ R n , we have x(S) = i∈S x i = x T e(S).Furthermore we can consider (linear) spans and the rank of collections: coalition S is in the linear span of collection Q if its characteristic vector e(S) is in span({e(T ) : T ∈ Q}) and rank(Q) := rank({e(T ) : T ∈ Q}).Next, we formally define the concept of balancedness.

(S).
Remark 1 We make the following observations about balancedness: (a) Balancedness implies T 0 -balancedness for any T 0 , while for T 0 = ∅ the two concepts are equivalent.(b) All results in this paper are concerned with the nucleolus.These results and the corresponding algorithms to be described can be adapted for the prenucleolus by setting T 0 = ∅.

Algorithmic view of the Kohlberg criterion
We first formalize the concept of balancedness and summarize the main results of Kohlberg [9] from an algorithmic viewpoint.For any efficient payoff distribution x ∈ PI, Kohlberg [9] first defines the following sets of coalitions: T 0 (x) = {{i}, i = 1, . . ., n : where for each k ≥ 1, Here, T k (x) includes all coalitions that have the same excess value k (x) and 1 (x) > 2 (x) > • • • , while T 0 (x) contains the players for which x is on the boundary of violating individual rationality.We call T k (x) the set of 'tight' coalitions in the sense that coalition S belongs to T k (x) if and only if the constraint v(S) − x(S) = k (x) is active/tight.In the followings, the terms 'collection of coalitions' (collection for short) and 'subset of the power set 2 N ' are equivalent and are used interchangeably.
For any collection of coalitions Q, let us define The first key result in Kohlberg [9] that will be exploited in this work is the following lemma: This result allows the author to define two sets of equivalent properties regarding a sequence of collections (Q 0 , Q 1 , . ..): The main result of [9] can be summarized in the following theorem: Theorem 1 (Kohlberg [9]) For games with a non-empty imputation set, the followings are equivalent: (a) x is the nucleolus; (b) (T 0 (x), T 1 (x), . ..) has Property I; (c) (T 0 (x), T 1 (x), . ..) has Property II.
For the sake of completeness, in Online Appendix A of the e-companion [22] we provide a proof of Theorem 1 slightly different than the one in [9].To appreciate the practicality of the Kohlberg criterion and for convenient development later, we present the algorithmic view of the criterion in Algorithm 1.
Algorithm 1: (Original) Kohlberg algorithm for verifying if a payoff vector is the nucleolus of a cooperative game.
Stop the algorithm and conclude that x is not the nucleolus end end 5. Conclude that x is the nucleolus.
In this algorithm, we iteratively form the tight sets T j ( j = 0, 1, . ..) until either all the coalitions are included, and we conclude that the input payoff vector is the nucleolus (i.e.stopping at Step 5), or stop at a point where the union of the tight coalitions is not T 0 -balanced (in Step 4), in which case we conclude that the payoff vector is not the nucleolus.

An improved Kohlberg criterion
The Kohlberg criterion, as described in Sect.2.2, offers a powerful tool to assess whether a given payoff distribution is the nucleolus by providing necessary and sufficient conditions.These conditions can be used in relatively small or well-structured games, where a potential candidate for the nucleolus can be easily identified and where checking the balancedness of the corresponding tight sets can be done easily (possibly analytically).For larger games, it is inconvenient to apply the Kohlberg criterion as it could involve forming and checking the balancedness of exponentially large number of subsets of tight coalitions (this is the case when the while loop in Algorithm 1 takes an exponentially large number of steps), each of which could be of exponentially large size.This section aims to resolve these issues.

Bounding the number of iterations to (n − 1)
The key idea to check the Kohlberg criterion in a more efficient way is to note that, once we have obtained and verified the T 0 -balancedness of ∪ k j=1 T j , we do not have to be concerned about those coalitions that belong to span(∪ k j=1 T j ).In brief, this is because once a collection is T 0 -balanced, its span is also T 0 -balanced as formalized in the following lemma: Lemma 2 For any collection T 0 ⊆ 2 N , the following results hold: We provide a proof of Lemma 2 in Online Appendix E of [22].With these results, we can provide an improved Kohlberg algorithm as shown in Algorithm 2.
Algorithm 2: Improved Kohlberg Algorithm for verifying if a payoff vector is the nucleolus.
Input: Game (N , v), imputation x ∈ I; Output: Conclude if x is the nucleolus or not; 1. Initialization: Set H 0 = {N }, T 0 = {{i} : and hence the algorithm (i.e. the while loop) terminates in at most (n − 1) iterations.Here, we also note that the algorithm terminates at either Step 4 or Step 5 with complementary conclusions.
Proving that the algorithm correctly decides whether an impuation is the nucleolus is equivalent to showing that (a) if x is the nucleolus then the algorithm correctly terminates at Step 5, and (b) if the algorithm terminates at Step 5, then the input payoff vector must be the nucleolus.
Part (a): We first note that, although the sequences of T k and H k generated from Algorithm 2 are generally different from those in Algorithm 1, these are the same in the initialization and the first iteration; that is, T 0 , T 1 , H 0 , H 1 are the same in both algorithms.Therefore, if x is the nucleolus, then T 1 must be T 0 -balanced as a direct result from the Kohlberg criterion described in Theorem 1.Thus, the algorithm goes through to Step 3 at k = 1.Suppose, for the purpose of deriving a contradiction, that the algorithm goes through to Step 4 instead of Step 5, for some index k > 1; that is (∪ k j=1 T j ) is not T 0 -balanced.By Lemma 1, there exists y ∈ R n such that y(S) ≥ 0, ∀S ∈ ∪ k j=0 T j ; y(N ) = 0; y(S ) > 0, for some S ∈ ∪ k j=1 T j .
(1) Notice, however, that ∪ k−1 j=1 T j is T 0 -balanced by the construction in Step 3 of the previous iteration.Therefore, S / ∈ H k−1 since otherwise Lemma 1 is violated.Thus, S ∈ T k and hence (1) leads to that is, for all coalitions in T k , the corresponding excess values for (x + y) are not greater than that of x with at least one strict inequality for some coalition S .Thus, where for each collection of coalitions Q, Q is the non-increasingly ordered excess values with respect to only those coalitions in Q.Since H k−1 is T 0 -balanced by the construction in Step 3 of the previous iteration, span(H k−1 ) is also T 0 -balanced by Lemma 2. Thus, y(S) = 0, ∀S ∈ span(H k−1 ) and From ( 2) and ( 3) we have Note that ( 4) also holds if we scale y by any positive factor δ, i.e.
For all S / ∈ (span(H k−1 ) ∪ T k ) we have v(S) − x(S) < k .Thus, there exists δ > 0 small enough such that x + δy is an imputation and that Results ( 5) and ( 6) imply that the |span(H k−1 ) ∪ T k | largest excess values at x are lexicographically larger than those at (x + δy).As a result, (x) is lexicographically larger than (x + δy) considering all coalitions, which means x is not the nucleolus, i.e. we have arrived at a contradiction.
Part (b): If the algorithm bypassed Step 4 and went to Step 5, then (∪ k j=1 T j ) is T 0balanced for all k until rank(H k−1 ) = n.Let z be the nucleolus; then by its definition, its worst excess value should be no larger than the worst excess value of x, which is equal to 1 .Thus, the excess value of z over any coalition, including those in T 1 , must be at most 1 ; i.e.
Notice that (z − x)(N ) = 0 and (z − x)(S) ≥ 0, ∀S ∈ T 0 by the construction of T 0 and because z ∈ I. Then since T 1 is T 0 -balanced, we have by Lemma 1 that (z − x)(S) = 0 for all S ∈ T 1 .Using a similar argument, given that x and z are lexicographically equivalent on span(T 1 ) and since z is the nucleolus, we also have Again, given that We can continue and use an induction argument to show that x is the nucleolus.

Remark 2
Step 2 in both Algorithms 1 and 2 still involves comparing vectors of exponential lengths.The key finding in Theorem 2, however, is to show that Step 2 of Algorithm 2 is not repeated more than (n − 1) times (instead of possibly exponential in the original Kohlberg criterion described in Algorithm 1).There are structured games such as weighted voting games, network flow games and coalitional skill games in which Step 2 can be executed efficiently.We refer the readers to [20] for details.
We demonstrate the effectiveness of Algorithm 2 in Sect. 5. Before that, let us discuss how to resolve some other computationally demanding tasks of our algorithm.

Reducing the sizes of the tight sets
When checking the Kohlberg criterion we might end up having to store an exponentially large number of coalitions.The computational requirements of checking T 0 -balancedness depend entirely on the size of the tight sets we encounter.Therefore, it is of particular interest to find compact representations of large tight sets.We provide a method for reducing the size of H k to at most (n − 1).This is achieved by replacing tight sets with their compact representations.

Lemma 3
The following statements hold: ω S e(S) The proof of Lemma 3 is provided in Online Appendix G of [22].Lemma 3b allows us to represent each H k by a collection R k of size rank(H k ) ≤ n with the following updating procedure.We need to have span As a result we can modify Algorithm 2 to be an Improved Kohlberg Algorithm with compact representation (denoted by I K Acr in the numerical results of Sect.

5). In Step 3 we can
without changing balancedness whatsoever.This means we replace all tight sets T k and store only a representative R k of their union for the subsequent steps.Accordingly, as R k−1 is a collection of coalitions with full rank, the stopping criterion can be simplified to checking the cardinality of the representative set R k−1 .The correctness of the algorithm can be proven very similarly to Theorem 2 using Lemma 3b.

A fast algorithm for checking balancedness
According to the Kohlberg criterion, to check T 0 -balancedness of T we need to check for the existence of γ ∈ R Solymosi and Sziklai [24, Lemma 3] provide an approach by solving |T | linear programs as follows.For each C ∈ T , let Then T is T 0 -balanced if and only if q * C > 0, ∀C ∈ T .Notice, however, that the collection T appearing in the Kohlberg criterion could be exponentially large, and hence solving all the |T | linear programs is not practical for larger games.Solymosi [17] (see Routine 3.2) presents a faster approach that involves at most rank(T ) linear programs.We improve upon these results by exploiting the knowledge of a T 0 -balanced subcollection in T to reduce the upper bound of rank(T ) in [17].
Exploiting Lemma 3, we can formulate an efficient algorithm that checks T 0balancedness of a collection T ⊆ 2 N with a known T 0 -balanced subcollection Q T (possibly Q = ∅) by finding the largest balanced subcollection within T , as described in Algorithm 3. When we check the T 0 -balancedness of (∪ k j=1 T j ), through (R k−1 ∪ T k ) exploiting Lemma 3 and using Algorithm 3, (R k−1 ∪ T k ) and R k−1 play the role of T and Q respectively.In this case, when we initialize U as span(Q) ∩ T , the set U essentially equals its representative set.However, this is not necessary the case any more when we perform the update in Step 4 of Algorithm 3.Moreover, Algorithm 3 can be used for general Q, not necessarily only those that are equal to their own representative set.Both cases can be easily treated by replacing U with its representative set in the corresponding occurrences (Steps 1 and/or 4 of Algorithm 3), not effecting balancedness and hence the outcome of the algorithm.In the following, we establish the improvement in the number of iterations required by our balancedness-checking subroutine, Algorithm 3.

Theorem 3 Collection T is T 0 -balanced if and only if Algorithm 3 terminates at
Step 5 with U = T , and the algorithm terminates after at most (rank(T ) − rank(Q)) iterations.
Proof The while loop terminates as rank(U ) keeps increasing via the construction of U in Steps 1 and 4; that is, the set U is enlarged by adding coalitions outside its span, starting from rank(Q).Thus, the algorithm terminates at either Step 3 or 5 and we need to prove that the corresponding conclusions from the output U are correct.Also, notice that since span(U ) ∩ T = U , we have U T if rank(U ) < rank(T ). 3f the algorithm terminates at Step 3, then ω * = 0 or ( 9) is infeasible and hence T is not T 0 -balanced, as otherwise we should have found a feasible ω * = 0.If the algorithm terminates at Step 5 then, prior to that, we have rank(U ) = rank(T ) in order for the while loop to terminate.The construction of U in Step 4 ensures that U is a T 0 -balanced set by Lemmas 2b, c and 3b.Thus, T = span(U ) ∩ T is also T 0 -balanced by Lemma 2c.

Nucleolus-defining coalitions and characterization sets
We conclude the first part of this article on the improved Kohlberg criterion by linking it with an important development in the nucleolus literature on the characterization set introduced by Granot et al. [23] and the B-nucleolus by Reijnierse and Potters [25].
A cooperative game G(N , v) is represented by (2 n − 1) coalitional values and although the nucleolus is defined as a function of all these values, i.e. lexicographical minimization of all the (2 n − 2) excess values, Granot et al. [23] and Reijnierse and Potters [25] show that the nucleolus can be determined by a subset of coalitions in the sense that lexicographical minimization with those coalitions as admissible ones will determine the nucleolus.Reijnierse and Potters [25] show that there exists a characterization set in every game with a size of at most 2(n − 1) coalitions.Although the authors emphasize that identifying this characterization set (or the B-set) would be as hard as finding the nucleolus itself, the result is still quite striking since this essentially means that we can ignore (2 n − 2(n − 1)) other coalitional values in calculating the nucleolus.The authors also show that the characterization set or the B-nucleolus can be identified efficiently in a number of games, including the assignment games, the balanced matching games, standard tree games, etc.We first define the characterization set.Definition 4 For a collection of coalitions F ∈ 2 N , the F-nucleolus of the game G(N , v), denoted as ν(N , F, v), consists of imputations that lexicographically minimizes the excess values of coalitions in F.
We now investigate how the improved Kohlberg criterion is linked to the concepts in [23,25].We prove that the set of coalitions generated from the improved Kohlberg criterion form 'special' characterization sets.We first identify the set of coalitions which are critical in defining the nucleolus.Definition 5 A coalition S is nucleolus-defining in game G(N , v) if a small perturbation on its coalitional value can lead to a change in the nucleolus.Formally, for all δ > 0, there exists | | < δ such that ν(N , ṽ) = ν(N , v), where ṽ(S) = v(S) + and ṽ(S ) = v(S ) for all N ⊃ S = S.All remaining coalitions are called nonnucleolus-defining.

Theorem 4
The set of all nucleolus-defining coalitions is precisely ∪ k r =1 T r , where T r , r = 1, . . ., k are the collections of coalitions generated by the improved Kohlberg Algorithm 2 on the nucleolus x.
Proof We prove two parts: (a) for all j ≤ k, each S ∈ T j is a nucleolus-defining coalition and (b) all the remaining ones are non-nucleolus-defining.
Let S 0 ∈ T j for some 1 ≤ j ≤ k.Suppose on contradiction that S 0 is nonnucleolus-defining, i.e. there exists > 0 and small enough such that if we change v(S 0 ) to v(S 0 ) + the nucleolus of the new game is still x.By setting 0 < < j−1 − j 4 we have j < v(S 0 ) − x(S 0 ) < j−1 .Therefore the tight sets for x are T 1 , . . ., T j−1 , {S 0 }, T j \S 0 , T j+1 , . . ., T k .Here, note that both ∪ j−1 i=1 T i and ∪ j−1 i=1 T i ∪S 0 are balanced due to x being the nucleolus (according to the Kohlberg criterion).By Lemma 1, there exists α > 0 and β > 0 such that e(N ) β S e(S).Thus, We note, however, that S 0 ∈ span(∪ k j=1 T j ) since span(∪ k j=1 T j ) has full rank.This means there exists a smallest index r ∈ {1, . . ., k} such that S 0 / ∈ ∪ r j=1 T j while S 0 ∈ span(∪ r j=1 T j ).This construction leads to v(S 0 ) − x(S 0 ) > r > j , ∀ j < r .Let us set δ = v(S 0 ) − x(S 0 ) − r .Then for any | | < δ, if we change v(S 0 ) to v(S 0 ) + the nucleolus of the new game is still x because according to Algorithm 2, all the steps still lead to the same collection of coalitions ∪ k j=1 T j .
While all characterization sets lead to the same unique nucleolus, it can be more desirable if the subset of excess values generated from the restricted game can carry more information about the worst excess values in the original game.For example, consider a game with three players where v({1, It can be verified that both {{1}, {2}, {3}} and {{1, 2}, {2, 3}, {3, 1}} form characterization sets.However, the former characterization set contains all non-nucleolus-defining coalitions while the latter contains all nucleolus-defining ones.It can be seen that the excess values generated from the latter provide more information on the most unhappy coalitions.
We define a meaningful characterization set as one that contains nucleolus-defining coalitions only.Following the result from Theorem 4, the next corollary provides us a method to construct these characterization sets.

Corollary 1 A meaningful characterization set can be constructed as
Theorem 4 and Corollary 1 are related to the results in Granot et al. [23] and Reijnierse and Potters [25], however, we show exactly how some characterization sets are constructed.We skip the proof of Corollary 1 for brevity as it is quite straightforward based on the result of Theorem 4 and it shares analogies with the proof on the size of characterization sets in Reijnierse and Potters [25], which makes use of the nested LP sequence.

Lexicographical descent algorithm for finding the nucleolus
Our improved Kohlberg criterion allows us to formulate a constructive algorithm that not only verifies whether a given imputation is the nucleolus, but also gives means to find it, in case the given candidate is not the desired payoff.This new algorithm fits into a general iterative descent framework as follows: • Starting from any imputation x ∈ I we perform a (local) optimality test.
• If x fails the test, we generate an improving direction y and step size α (here, 'improving' is w.r.t. the lexicographical ordering of the corresponding dissatisfactions).• We update x = x+αy and repeat the procedure until no further improving direction is found.
In this scheme, the optimality test is derived from the new Kohlberg criterion developed in Sect.3, improving directions are generated using duality, while step sizes are found exactly to guarantee necessary and sufficient change in the imputation and its tight collection of coalitions.
Our new algorithm also fits somewhat into the simplex framework for linear programming: improving directions are chosen using considerations similar to reduced costs, and the step size provides the pivoting rule through a sort of minimal ratio test.Indeed, we are moving on the facets of polytopes in Maschlers scheme, but not necessarily from vertex to vertex, like most traditional simplex implementations do.

Finding improving directions
Algorithm 3 not only handles the tedious strict positivity constraints related to balancedness, it essentially finds the largest T 0 -balanced subcollection in T , starting from a previously identified (possibly empty) balanced subcollection Q. Suppose that Algorithm 2 with compact representation (Algorithm 1 of [22]) terminates in Step 4, which happens precisely when Algorithm 3 exits with ω * = 0 or ( 9) is infeasible, while rank(U ) < rank(T ).In the former case, we found the largest T 0 -balanced subcollection U in T , but since T \U = ∅, T is not T 0 -balanced.In the latter case, there is no T 0 -balanced subcollection in T (more precisely, the largest one is the empty set).In both cases we know that precisely the collection T \U = ∅ is responsible for the lack of T 0 -balancedness.
Recall that in iteration k of Algorithm 2 (with compact representation), when we check T 0 -balancedness with Algorithm 3 and we get the output U .For sake of simplicity we use T as (R k−1 ∪ T k ) and U as the corresponding output from Algorithm 3.
If T is not T 0 -balanced, it is possible to generate an improving direction y, such that moving from x to (x + αy) will fulfill all of the following three objectives: (a) not changing the excess of coalitions in span(R k−1 ), (b) remaining in the imputation set and not increasing the excess of coalitions in U , (c) decreasing the excess of coalitions in T \U .
In other words, the change from x to (x + αy) will increase the satisfaction of the most dissatisfied unbalanced coalitions, while maintaining the excess of the already settled balanced coalitions.In this subsection we focus on how to generate an improving direction while Sect.4.2 is devoted to the calculation of the optimal step size.
Note that the preceding result holds for any Q ∈ T \U .While the corresponding y might differ for different Q, we can take the average (or sum) of all these to arrive at a common, normalized y in {y ∈ R n : y(Q) ≥ 1, ∀Q ∈ T \U , y(P) ≥ 0, ∀P ∈ T 0 , y(S) = 0, ∀S ∈ U ∪ {N }} (11) Furthermore, Lemma 3b shows that whenever we iteratively check whether a collection of coalitions ∪ k j=1 T j satisfies T 0 -balancedness for all k or not, it is sufficient to require strict positivity from the weights of the current new set of coalitions T k , if we already found that the collection is T 0 -balanced up to level (k − 1).The lemma is not only useful to make checking of balancedness easier, as shown in Sect.3.3, it also yields an improved system via (11).In iteration k, if T is not T 0 -balanced, then in (11) we can require y(Q) = 0 from all coalitions Q ∈ ∪ k−1 j=1 T j ∪{N } and still get a feasible system.Additionally, because for all is non-empty as well.We call vectors y in (12) improving directions.Since improving directions are defined through a feasible set of constraints, there could be many different improving directions, and we have the freedom to choose an objective function to optimize over that set.The following section determines the optimal step size, also shedding light on the most suitable objective function to choose.

Step size
A feasible point y in ( 12) is an improving direction in the sense that moving along y from our current point (which is not the nucleolus) improves the satisfaction of the coalitions that are currently worst off and causing the lack of balancedness, while still maintaining the satisfaction of previously checked balanced subcollections and ensuring that we stay in the imputation set for small enough step size.When determining a suitable step size α > 0 for a given improving direction y, we naturally want to choose α large enough in order to avoid small steps that do not result in changes in T , since T is not T 0 -balanced.Also, we want to increase α only until we experience a change in T (or in T 0 ) in the hope that the new collection is T 0 -balanced.
Suppose that, at iteration k, we are currently at imputation x.For all coalitions S, the change of excess as we move in direction y with step size α is
We are essentially interested in the tightness of coalitions measured as the difference of their excess from the maximal dissatisfaction, that is how far they are from being tight.Specifically, we are interested in the change of their tightness
This brings us back to the practical question of how to choose improving directions from the cone determined by (12).Since every feasible point of that set is an improving direction we can use, we have the freedom to choose an objective function to optimize over this set.In order to control min S∈T k \U y(S) as well as to make the bound we used in ( 13) sharp, we choose to minimize S∈T k \U y(S).
Recall that when we check the T 0 -balancedness of ∪ k j=1 T j in iteration k, we choose y solving min Thus, for every optimal solution y of I D(T 0 ; T k ; U ), we have y( S) = 1.As we increase α from 0, we see that the tightness of coalition S decreases if y(S) > 1, the tightness does not change if y(S) = 1, and it increases if y(S) < 1.By increasing tightness we mean that the difference k (x+αy)−d(S, x+αy) decreases.Let us denote the collection of coalitions with increasing tightness as J = {S / ∈ span(R k−1 ) ∪ T k : y(S) < 1}, the coalitions that are candidates to enter the tight set as we make a step.
We know that d(S, x) < k (x) for all coalitions S / ∈ span(R k−1 ) ∪ T k .Hence, there exists α > 0 sufficiently small such that Rearranging these terms, we get d(S, x) + α(1 − y(S)) ≤ k (x).Candidates of coalitions satisfying the latter relation with equality for large enough α are in collection J , thus we increase α until we reach equality for some coalition in J .However, we also need to bound α such that we stay in the imputation set.Taking both constraints into account, and introducing N 0 = { j ∈ N \T 0 : y j < 0}, the optimal step size is the smallest step size for which we experience either {v(S) − (x + αy)(S)} or T 0 = {{i} : . . .
. . .In Fig. 1, the dissatisfaction of coalitions in J increases (relative to the moving target of k (x + αy)), again with varying speed depending on y.The coalition first meeting argmin S∈T k \U {y(S)} enters the tight set. 5

Lexicographical descent algorithm
Now that we have all necessary elements at our disposal, we formulate the new algorithm for calculating the nucleolus of a cooperative game.
Algorithm 4: Algorithm computing the nucleolus of a cooperative game.Algorithm 4 starts with an arbitrarily chosen imputation.If, at the current point, the tight set T k fails to pass a balancedness requirement related to the Kohlberg criterion, we generate an improving direction and a step size.
Beside the descent-based nature of the algorithm as presented in the preceeding sections, Algorithm 4 also shares some similarities with the simplex method for linear programming, as finding an improving direction y and a suitable step size α in Step 3 of the algorithm is similar to a pivot step in the simplex algorithm.Inside the while loop the algorithm keeps 'pivoting' until T 0 -balancedness is achieved, while the iterations of the loop correspond to solving LPs in the sequential LP formulation of the nucleolus (cf.[17]).The overall algorithm can also be interpreted as an active-set or column generation approach, because checking the balancedness of a collection of (primal) tight coalitions is nothing else than solving relaxed dual programs in the aforementioned LP sequence (cf.[19]).

Example 1 Consider the 3-player game v with coalition values
and v(N ) = 12.For readability, during this example we use superscripts to distinguish between different imputations, while subscripts of maximum dissatisfaction levels k and tight sets T k are used to keep track of iterations.We are using Algorithm 4 to find the nucleolus ν from a starting imputation x 0 = [1,4,7].
First, we find that our distance to the boundary of the core is 1, hence 1 (x 0 ) = 1.Also, currently the largest infeasibility among core inequalities belongs to constraint It is easy to see that the current tight set T 1 (x 0 ) is not T 0 (x 0 )-balanced.In the algorithm we run into an infeasible system when checking the balancedness, so we can find improving directions by solving I D(T 1 (x 0 ); T 0 (x 0 ); {N }), for example y = [−1, 0, 1].
Notice that we measure the distance from the boundary with a special signed distance; in the interior of the core the distance from the boundary is understood to be negative.Thus, we can move even further along the direction after reaching the core, until we can not decrease the distance any more.This happens precisely when the distances from both constraints (x 3 ≥ 5) and (x 1 + x 2 ≥ 6) are −0.5, that is when x 1 = [2.5, 4, 5.5], 1 (x 1 ) = −0.5,T 1 (x 1 ) = {{1, 2}, {3}} and T 0 (x 1 ) = ∅.This is similar to a pivot step in a simplex-like algorithm, where coalition {3} enters the basis.According to (14), the step size chosen in direction y is α = 1.5.After this step, we find that T 1 (x 1 ) is T 0 (x 1 )-balanced, therefore we expand R 0 with an arbitrary element of T 1 (x 1 ) as rank(R 0 ∪ T 1 (x 1 )) = 2.By doing so we lift those inequality constraints that limit the decrease; that is, throughout the remaining execution of the algorithm those constraints remain satisfied with equality at the current largest excess level of 1 (x 1 ) = −0.5.
The set of imputations having the coalitions in T 1 (x 1 ) being tight at 1 = −0.5 actually form the least core of the game.At the current point x 1 , among constraints not in span(R 1 ), we are closest to violating x 1 + x 3 ≥ 7 with 2 (x 1 ) = −1.Also we have that T 0 remains empty at x 1 and the tight set T 2 (x 1 ) = {{1, 3}} is not T 0balanced, so we find an improving direction parallel to the set of least core payoffs.That is, the unique solution of I D(T 2 (x 1 ); T 0 ; R 1 ) is y = [1, −1, 0], and we can take a step size of α = 1/4 until coalition {2, 3} becomes tight as well.The resulting point is x 2 = [2.75,3.75, 5.5] with largest excess 2 (x 2 ) = −1.25,T 0 = ∅ and tight set In the followings we establish results regarding the convergence of Algorithm 4 and its connection to sequential LP methods.The results also justify why we call Algorithm 4 a lexicographical descent method.
Lemma 4 Suppose that at iteration k, Algorithm 4 goes through to Step 3 and updates x to (x + αy).Then we have (x + αy) < L (x).Furthermore, Proof Let us start by noting that by the definition of y solving I D(T 0 ; T k ; U ) and α in ( 14), the new point (x + αy) ∈ I if x ∈ I. Additionally x(S) = (x + αy)(S) for all S ∈ span(R k−1 ), also due to y solving I D(T 0 ; T k ; U ).As a result, both (x) and (x + αy) contain (and start with) the same excess values for coalitions S with excess d(S, ν) ≥ k−1 (ν).Therefore, in order to make the lexicographical comparison, it is sufficient to focus on the truncated ordered excess vectors over the set 2 N \span(R k−1 ), i.e. between 2 N \span(R k−1 ) (x) and 2 N \span(R k−1 ) (x + αy).

Remark 3 We have the following observations by Lemma 4:
• Lemma 4 justifies naming Algorithm 4 lexicographical descent.Starting from an arbitrary imputation, we follow a trajectory of imputations by generating improving directions and step sizes, with the corresponding ordered vector of excesses keep strictly lexicographically decreasing in every step of the trajectory.The only other 'descent' method [19] that we are aware of for general cooperative games does not have this property.• Due to the strict lexicographical descent, during Algorithm 4 we never circulate in the imputation set x ∈ I.
. . .• Furthermore, Algorithm 4 is connected to the classical sequential LP methods by Lemma 4b: as soon as we have U ∩ T k = ∅, that is, we have found a balanced (sub)collection in the new tight set, we have solved the k-th LP of the sequence due to primal-dual feasibility.Notice, however, that even in that case we could make a further step in the lexicographical descent, since the original tight set was not balanced, allowing us to find the interior of the optimal facet of the LP.
Theorem 5 Algorithm 4 stops after a finite number of steps.The while loop is executed at most (n − 1) iterations before finding the nucleolus ν.
Proof We start by showing the iteration limit of the while loop.Note that rank(R k ) increases in every iteration as ∅ = T k ⊆ 2 N \span(R k−1 ), and since rank(R 0 ) = 1 the algorithm terminates in at most (n − 1) iterations for the while loop.Thus, for finite convergence to ν, we only need to show that, within a single iteration, a finite number of steps from x to (x + αy) is sufficient to reach a T 0 -balanced tight set, which gets the algorithm out of the current iteration.For that purpose let us fix that iteration to be k, and for notational ease, for the remainder of the proof we omit the iteration subscripts k; i.e.T is used in place of T k , and so on.
According to Lemma 4, as soon as U ∩ T = ∅, we reached a T 0 -balanced tight set U ∩ T itself.Therefore we suppose that U ∩ T = ∅.
Since T ⊆ 2 N \span(R), the possible tight sets we can encounter is finite, among which there exists T 0 -balanced as well, for instance T (ν).Thus, the only way not to reach a T 0 -balanced tight set is to encounter an infinite series of tight sets T = (T 1 , T 2 , . . ., T m , T 1 , T m+1 . . .), among which none is T 0 -balanced.Here, we use the superscripts to denote the different steps that we encounter under the same iteration k.Again because of the finitely many tight sets, we guaranteed to revisit at least one tight set infinitely many times.W.l.o.g., let that one be T 1 and suppose that we first revisit it after taking m steps.Let us denote the corresponding improving directions, step sizes and maximal dissatisfactions we encounter at each tight set as (y 1 , y 2 , . . .), (α 1 , α 2 , . . . ) and ( 1 , 2 , . . ., m , m+1 , . . .), respectively.
Let us suppose that the starting tight set T 1 corresponds to the imputation x 1 = x.By Lemma 4 we have 1 > m > m+1 and x + m j=1 α j y j ∈ I. Thus, we generate improving direction y 1 solving the LP min Note that, here we assume T 1 ∩ U = ∅ and hence we obtain a simpler version of I D(T 0 ; T 1 ; U ). Since m j=1 α j y j (S) = 1 − m+1 is constant through S ∈ T 1 , β m j=1 α j y j is feasible in I D(T 1 ) for large enough β > 0, thus we have m j=1 α j y j 1 − m+1 is optimal in I D(T 1 ).As a result, y 1 (S) = 1 for all S ∈ T 1 as y 1 is also an optimal solution of I D(T 1 ).Consequently all coalitions remain tight, while some coalition must join, based on the definition of the step size, hence T 1 T 2 .
Note that it is not always the case that T 1 is followed by the same T 2 .However, since T 2 is pooled from the finite power set, there must be at least one set T 2 such that the subsequence (T 1 , T 2 ) is repeated infinitely many times with T 1 T 2 .Using the same line of arguments, we arrive at longer repeated subsequences T 1 T 2 . . .T j for as large j as we wish.This is impossible because the size of T j is bounded.Thus, the series of tight set T is finite under each iteration.As the number of iterations is bounded by (n − 1), the algorithm converges in finitely many steps.

Remark 4
We have the following observations by Theorem 5: • During Algorithm 4, not only in the imputations, but we never circulate in the tight set space either.• Note that requiring a finite number of steps is enough to achieve the result claimed above.Numerical experiments indicate that Algorithm 4 executes a very small number of steps, see Sects.5.1 and 5.2.

Remark 5
The (n −1) linear programs in Maschlers scheme [26], the (n −1) iterations in the improved Kohlberg criterion for verifying the nucleolus (Algorithm 2), the upper bound of n iterations in the balancedness checking algorithm (Algorithm 3), and finally the (n − 1) iteration in our lexicographical descent algorithm as stated in Theorem 5 is due to the fact that all of these algorithms are designed to increase the rank of the collection of tight coalitions considered.While eventually in an implementation of Maschler's scheme (e.g.[18]) the same collection of tight coalitions is found as in our lexicographical descent method, the trajectory how the two different methods reaches this point is different, as evidenced by the different number of iterations required (cf.Sect.5).
Finally we note that Algorithm 4 can be easily adapted to the case when we have a characterization set F ⊆ 2 N at our disposal, by simply changing the search space in k (x) and T k (x) from S / ∈ span(R k−1 ) to S / ∈ span(R k−1 ) ∪ 2 N \F .The computational bottleneck of Algorithm 4 is performing Step 2 and computing the step size in Step 3.However, given a characterization set F of polynomial size as an additional input, the algorithm runs in polynomial time.That characterization set is available, if we restrict our attention, for example to the class of assignment games [2], to balanced matching games [25], to standard tree games [27], among many other classes [23].

Numerical results
In the following subsections we present numerical results assessing the performance of the algorithms described above.Both the different versions of Kohlberg Algorithms (Algorithms 1, 2 and 1 of [22]) and the constructive algorithm (Algorithm 4) have been tested on 4 different types of games, the player set size ranging from 5 to 30.For games with n ≤ 25, fifty instances were generated from each type, and we report averages of computational time in seconds, number of iterations, pivot steps and subroutines (wherever applicable), as well as number of coalitions saved from storage by compact representation sets.Similarly, for games with n > 25, ten instances were generated from each type.In each category the corresponding minimal values are highlighted with bold (wherever applicable).
For the sake of completeness the Kohlberg algorithms are tested with 4 solution points including the nucleolus, a random imputation, a point in the least core and in the least-least core (an element of the least core with T 0 -balanced (T 1 ∪ T 2 )).For brevity, we only present here results for the solution being the nucleolus.Results for the other three solutions are presented in Online Appendix H of [22].The original and improved Kohlberg algorithms 1 and 2 are denoted with Kohlberg and IKA respectively, while Algorithm 1 of [22] that includes the compact representation is denoted with IKAcr.The lexicographical descent Algorithm 4 (denoted BFN) is compared to 4 methods: SP (SD) are the primal (dual) nested LP algorithms due to Solymosi [17], DK is Derks and Kuipers [19]'s algorithm, while PRA denotes the prolonged simplex algorithm by [18].
All algorithms were implemented in C++ and computations were carried out on a desktop PC with Intel Core i5-2500 3.30 GHz CPU and 16 Gb RAM. 6 All the LPs involved are solved with CPLEX 12.7.1'sprimal simplex method (with default settings 7 ).Time limitations were set with 12 hours for n ≤ 25, 15 hours for n ≤ 28, and 18 hours for n > 28.All of the codes (along with the test instances) used to produce these results are available for free access at the GitHub repository [21].

Type and II games
Type I and II games both appear in [18,28].The characteristic function for type I is given by v({i}) = 0 for all i ∈ N , v(N ) is a random integer between 100(n − 2) and 100n, while v(S) is a random integer between 1 and 100|S| for all other (non-empty) coalitions S. Type II games are generated as v({i}) = 0 for all i ∈ N and v(S) is a random integer between 1 and 50n for all other (non-empty) coalitions S.
In terms of the verifying Kohlberg algorithms we can start with the general observation that the classical Kohlberg algorithm is only usable up to a limited size.From Tables 1, 2, 3 and 4 we find that games of size n = 15 provide already a challenge that Algorithm 1 can not tackle, as it runs out of time.
For the remaining two algorithms IKA and IKAcr, the differences in performance do not seem to be significant.The advantage of having a compact representation only affects a small number of coalitions most of the time, with the notable exception of one type I game with 30 players.This is a random game with quite substantially larger tight set T 1 (x) than the other games considered.However, as both IKA and IKAcr terminate after performing only 1 iteration, the advantage of a compact representation is not realised during any subsequent iterations.On the contrary, the small additional workload necessary for finding this compact representation appears to provide a slight disadvantage in computation time.
Turning to constructive algorithms, we can start with a general observation similar to the one made on verification algorithms.Considering the results presented in Tables 5 and 6, one finds that classical sequential LP formulations can not solve games with n = 25 players or more; while SP runs out of memory, SD does not finish within reasonable time restrictions.It is of little surprise, considering that these methods handle exponential sized (either in rows or columns) LPs.As impressive the prolonged simplex method by [18] is, it suffers more having exponential number of both rows and columns, thus running out of memory already at 20 players.This is the case for all types of games considered, as Tables 7 and 8 also confirm.
Regarding the number of iterations needed, we see from Tables 5 and 6 that type I and II games barely distinguish between primal (BFN, SP) and dual methods (DK, SD, PRA), the latter requiring at least as many iterations as the former, by nature.Even though the main advantage of primal methods, i.e. having a smaller number of iterations, is barely realised in these types of games, BFN still produces the best computing times, outperforming DK for every size of games, while the latter becomes unusable at n = 30.Furthermore, while BFN requires less pivots at the price of invoking subroutine Algorithm 3, this seems to be rarely rewarded with fewer number of iterations, at least for type I and II games.

Type III and IV games
Derks and Kuipers [19] were interested in games where the number of iterations grows more or less linearly with the number of players, and so they introduced type III games as v(S) = 0 for all |S| < n − 2, v(S) = 1 with probability 0.9 for n − 2 ≤ |S| < n and v(N ) = 1.According to Table 7 the authors were obviously  successful in terms of generating games where their (dual) method struggles, whereas for primal methods these games can be considered as trivial.As a result, it is no wonder that the computation times of DK are magnitudes higher compared to those of BFN.
In order to test the methods on games, which distinguish between the number of iterations required by primal and dual methods more realistically, that is games that are 'somewhere between types I-II and III', we introduce type IV games as v({i}) = 0 for all i ∈ N and v(S) is a random integer between 1 and n for all other (non-empty) coalitions S.
Both IKA and IKAcr solve type III games extremely easily, making them hard to compare with each other. 8Their performance for type IV games show a similar behaviour as games of types I and II.
Tables 7 and 8 show that as soon as the required number of iterations at least moderately distinguishes between primal and dual methods, the difference in computational time between BFN and DK greatly increases.

Limitations of our algorithm
We now study the bottleneck of the lexicographical descent algorithm in attempt to find games that our proposed method struggles with.The performance of Algorithm 3 as the balancedness subroutine of Algorithm 4 depends on the size of the tight set, so we now look for games with extremely large tight sets.From a verification point of view we expect that the compact representation of tight sets carries an improvement in these games, therefore also providing significant distinguishment between Algorithms 2 and 1 of [22].
For our purposes we adopt the United Nations (UN) Security Council voting mechanism into weighted voting games with arbitrary size, where there are 5 big (veto) players and the rest (originally 10) are small.Formal description and results for the verification algorithms can be found in Online Appendix H.3 of [22].
Our attempts to find a game our method struggles with were somewhat successful, meaning that while we have a sizeable advantage in computation time over other algorithms for n ≤ 26, this advantage vanishes at n = 27, until eventually BFN runs out of memory for n = 28.This is due to the fact that these games have extremely large tight sets, which severely affects BFN through Algorithm 3 with a very large |T | of exponential size, while by the nature of [19]'s method this does not affect DK.
It should be noted that finding the nucleolus of these games is trivial, i.e. one can easily find analytically that the 5 veto players share the total payoff of 1 amongst themselves in an egalitarian way, while all the small players get 0. Therefore anyone interested in finding the nucleolus of such a game would never turn to any of the aforementioned algorithms.Instead, since these games are of a very peculiar nature from an algorithmic perspective, they carry a theoretical interest from a computational point of view.For games with structures like this, we expect further improvement by   exploiting the structure in a similar way to [20].However, within the scope of this paper, we want to provide a like-for-like comparison and hence leave further improvements for future research.

Comparing Kohlberg algorithms on different solutions
Finally, we consider further numerical tests of the various Kohlberg algorithms (Algorithms 1, 2 and 1 of [22]) that verify whether a particular solution of a game is the nucleolus or not.We test these algorithms on four kinds of solutions: a random imputation, an element each of the least core and the least-least core (i.e.T 1 ∪ T 2 is T 0balanced), and the nucleolus.Results for the latter were presented above in Sects.5.1 and 5.2, while we cover the former three in Online Appendix H of [22].
Naturally, our expectations are that random imputations are probably in no relation with the nucleolus, therefore should be rejected straight away, while as we 'go deeper' into the least core, more effort is needed to reject solutions that are not the nucleoli themselves.
As a general observation, our first expectation is met, regardless of the type of the game.Tables 1, 2, 7, 8 and 11 of [22] show that all of the algorithms reject random solutions without any significant effort (and therefore we omit these cases from further analysis).Our other expectations seem to be met as well, as we clearly notice increases in time, iterations and subroutine calls when moving towards more involved solutions.
Another observation is that the original Kohlberg algorithm is again not able to solve instances with more than 10 players as soon as we consider a solution from the least core, or more than 15 players and the least-least core in case of the UN Security Council game cf.Tables 12-13 of [22].Thus, as before, algorithms IKA and IKAcr provide the only option for most games and the solutions to be verified.Hence, in our further analysis we again restrict ourselves to comparing these two algorithms, with the details provided in Online Appendix H of [22].

Conclusion
In this paper, we present both an Improved algorithmic approach for verifying whether a payoff vector is the nucleolus and a novel constructive method for finding it.In the first part, we develop an Improved Kohlberg criterion in which the number of iterations is bounded by at most (n − 1) instead of possibly exponentially large in the original Kohlberg criterion.This also comes with introducing representative sets for more efficient storage of the coalitions and a faster algorithm for checking balancedness.In the second part, we develop a novel descent-based algorithm for computing the nucleolus that exploits the new and Improved Kohlberg criterion.We compare the performance of our new algorithms with existing methods and demonstrate their effectiveness through numerical testing with a number of games proposed in the literature.Finally, we provide our algorithms, as well as the relevant literature's in an online open-source code repository, which we believe is an important step forward, that the cooperative game theory community can build upon.

Figure 1
captures how the tight set changes as we move from x to (x +αy).At x, the largest dissatisfaction outside of the already settled span(R k−1 ) belongs to coalitions k (x + αy)
(a) The first component of both truncated ordered excess vectors is a value corresponding to a tight coalition S ∈ T k (x).Since y(S) ≥ 1 for all S ∈ T k (x) and α > 0, we have that k (x + αy) < k (x) (as Fig. 1 demonstrates) and therefore (x + αy) < L (x) in this case.(b) However, if U ∩ T k = ∅, then we have y(Q) = 0 for all Q ∈ U since y is a solution of I D(T 0 ; T k ; U ), hence k (x) = k (x + αy) = d(Q, x) for Q ∈ U .Note that at Step 3 of Algorithm 4, we have T k \U = ∅.Since y(S) ≥ 1 for all S ∈ T k \U , we also have U ∩ T k (x) = T k (x + αy) T k (x), as Fig. 2 demonstrates.Consequently,

Fig. 2
Fig. 2 Changes of tight coalitions at a pivot step when U = ∅

2 3 4
Original and improved Kohlberg algorithms on type II games and nucleolus solution Original and Improved Kohlberg algorithms on type III games and nucleolus solution Original and Improved Kohlberg algorithms on type IV games and nucleolus solution The while-loop in Algorithm 2 terminates after at most (n − 1) iterations and it correctly decides whether a given imputation is the nucleolus.Proof First, by the construction in Step 2 of the algorithm, T k ∩ span(H k−1 ) = ∅ and hence, by Step 3, we have that rank(H

Table 1
Original and improved algorithms on type I games and nucleolus solution

Table 5
Computing the nucleolus of type I games