Exploring Leximin Principle for Fair Core-Selecting Combinatorial Auctions: Payment Rule Design and Implementation

1 Introduction

Combinatorial auctions (CAs) have found applications in many real-world auction problems, including procurement auctions [Sandholm, 2007] and government spectrum auctions [Cramton, 2013; Ausubel and Baranov, 2017; LeytonBrown et al., 2017]. CAs are attractive as they can produce efficient outcomes even when bidders have complex preferences on bundles of heterogeneous goods. A combinatorial auction mechanism often includes two components: 1) an allocation rule to specify the bundle of items assigned to each bidder; 2) a payment rule to specify the price a bidder should pay for his bundle. Note that an allocation rule is normally obtained by solving the NP-hard winner determination problem [Rothkopf et al., 1998]. In this paper, we will focus on the payment rules' designs and implementations.

∗The work was done during a visiting scholar program at Nanyang Technological University.

†Corresponding author

To address the truthfulness issue of bidding, where bidders are unwilling to give their real valuations of items but report false information to improve their utilities, the well-known Vickrey-Clarke-Groves (VCG) payment rule [Vickrey, 1961; Clarke, 1971; Groves, 1973] ensures that the optimal strategy for each bidder is to bid their true valuations of the items. However, the VCG payment rule still suffers from various other issues that prohibit it from real-world adoption, e.g., arbitrarily low revenue for the seller, which may cause collusion between the seller and some bidders [Ausubel et al., 2006].

The drawbacks of the VCG payment rule have motivated the development of core-selecting payment rules [Day and Raghavan, 2007], which provide a principled way to ensure that there are no opportunities for collusion between the seller and bidders. The core is a set of all possible payment outcomes where the utility of any coalition of bidders in the auction cannot be improved by engaging in collusion [Gillies, 1959]. However, the core can be exponentially large, and thus, selecting a suitable payment outcome from the core is a critical problem in core-selecting CAs. Many efforts have been devoted to solving this problem by designing some principles of selection [Day and Raghavan, 2007; Erdil and Klemperer, 2010; Day and Cramton, 2012; Lubin et al., 2015; B¨unz et al., 2018]. Among them, the minimum-revenuecore (MRC) rule is particularly popular, where it achieves the largest total incentive by selecting the core outcome that maximizes the total utilities of all bidders.

However, it is observed that the MRC rule may cause severe unfairness, since some winners may be forced to sacrifice their utilities in the MRC rule. A detailed example to illustrate this unfair phenomenon caused by the MRC rule is provided in Example 1 of this paper, where, in the optimal MRC payment outcome, a winner's utility is 0 while he could have obtained a positive utility. More importantly, this zeroutility phenomenon is not rare since nearly 30% of winners are forced to get a utility of zero on average in our data generated by CATS [Leyton-Brown et al., 2000], which simulates bidding behavior in many realistic economic environments.

To address the limitation of the MRC rule, we propose to explore the leximin principle to achieve fairness in coreselecting CAs and propose a novel bidder-leximin-optimal (BLO) payment rule that selects a core outcome based on the leximin principle which prefers to maximize the utility of the worst-off [Rawls, 2004]. Informally, the BLO rulemaximizes the minimum utility, the second minimum utility and so forth among all the bidders, which achieves egalitarian fairness. Furthermore, we analyze the BLO outcome theoretically and provide an effective algorithm to compute it. We summarize our contributions 1 as follows:

1. We investigate the unfair phenomenon of the MRC rule and propose the BLO rule to achieve fairness in the coreselecting CAs.
2. We give a theoretical analysis of the BLO rule and show that the BLO outcome is unique and Pareto optimal. Moreover, we offer that the worst-case relative ratio between a bidder's utility (resp. the total utility of all bidders) in the BLO outcome and the maximum utility among all the core outcomes is 1 |W| (resp.

1. Finally, we propose an exact algorithm named WFCGS-CR to compute the BLO outcome. Our WFCGS-CR algorithm consists of the water-filling framework, a constraint generation search subroutine, and a constraint-reuse strategy. Given the oracle access for winner determination, it is effective in time polynomial in the number of winners. Extensive experiments show that our algorithm returns fairer utility distributions and is also faster than existing algorithms of core-selecting payment rules.

2 RelatedWork

As a practical mechanism, core-selecting CAs and the MRC rule were proposed in [Day and Raghavan, 2007] and used in several scenarios, including selling wireless spectra [Cramton, 2013] and online advertising [Goel et al., 2015]. Then the quadratic rule [Day and Cramton, 2012] was proposed to select the MRC point nearest to the VCG point in l2distance. They also study some other reference points like allzero points. Recently, some works design the core-selecting payment rule by approximating Bayesian equilibrium of different core outcomes [Lubin et al., 2015; B¨unz et al., 2018].

Except for the incentives, fairness is an essential metric in the core-selecting mechanisms. [Lubin et al., 2015] studied the fairness measured by the Gini coefficient and proposed a fractional rule that selects a point fraction to the VCG point performs best. However, their experiments show that relaxing the MRC constraint does not change the equilibrium properties; and there are no systematic shifts in efficiency, fairness, and aggregate incentives. There are many principles to define fairness. In this paper, we adopt the leximin principle in the core-selecting CAs. The method is similar to the egalitarian core proposed by Arin [Arin and Inarra, 2001], which selects the utility distribution in the cooperative game via the leximin principle [Rawls, 2004]. The difference is that the total utility is not constant in core-selecting CAs.

1 Note that we will refer all proofs to the appendix. Our appendix and code are available at https://github.com/ha0cheng/Fair-BLO.

As for the pricing algorithms, given access to the separation oracle of winner determination, one can use the Ellipsoid algorithm [Gr¨otschel et al., 1981] to optimize convex objectives (e.g., bidders' total utility) exactly over the core polytope in polynomial time. However, this approach is rather slow in practice, and Core Constraint Generation (CCG) algorithm [Day and Raghavan, 2007] was proposed as an effective heuristic algorithm to solve such an optimization problem, which is commonly used in core-selecting CAs [Day and Cramton, 2012; Cramton, 2013; B¨unz et al., 2015].

However, it is hard to formulate a global objective for the BLO rule, making it difficult to use the above algorithms directly. Then, Fast Core algorithm [Niazadeh et al., 2022] was proposed to compute an approximate Pareto optimal outcome in the rich advertisement, which can be used to compute an approximate BLO core outcome. Instead of the approximate algorithm, we focus on the exact algorithm. Moreover, the experiments show that our exact algorithm is much faster than Fast Core.

3 Preliminaries

Combinatorial auctions are specifically designed for domains where bidders can have complex preferences over bundles of heterogeneous items. Formally, let N = {1, . . . , n} be a set of bidders and s be the seller. Let M = {a, b, c, . . .} be the set of items with |M| = m. Each bidder i has a valuation function vi : 2M → R which specifies the bidder's valuation for every possible bundle of items S ∈ 2M . Unless stated otherwise, bidders will only need to give their values for bundles in which they are interested, and all other bundles will be given values 0. Also, we assume that vi(∅) = 0 (∀i ∈ N).

A CA consists of two steps: step 1 computes an item allocation outcome, and step 2 computes an item payment outcome. An allocation rule specifies the bundle of items ai assigned for each bidder i, where ai ∈ 2M and ai ∩ aj = ∅ (∀i ̸= j), and a payment rule specifies the price pi that the bidder i should pay for his bundle ai. Obviously, pi must be 0 if ai is empty.

Let πi denote the utility of an auction participant i ∈ N ∪ {s}. If i is the bidder, we assume that his utility is quasilinear, i.e., πi = vi(ai) - pi. If i is the seller s, his utility is πs = ∑i∈N pi, which is also known as the revenue. The social welfare is the summation of all participants' utility:

One can observe that the social welfare does not depend on the payment, and an allocation rule can be computed by maximizing the social welfare as follows:

Note that the above optimization problem is also known as the winner determination problem. Let w({vi(·)}i∈N) be the maximum social welfare given the valuation function profile {vi(·)}i∈N . Once we have a social welfare maximizing allocation {ai|i ∈ N, ai ∩ aj = ∅, ∀i ̸= j} by solving the winner determination problem, in step 2, we need to decide the price pi for each allocated item bundle ai(i ∈ N).

The simplest payment rule is the so-called pay-as-bid payment rule, where a winner i(ai ̸= ∅) pays the price pi = vi(ai) for buying the item bundle ai. However, the pay-asbid payment rule suffers from the truthfulness issue, where bidders are unwilling to report the true valuation functions but strategically give false information instead. Therefore, in step 2, the famous VCG mechanism is proposed to offer bidders incentives to ensure that bidding truthfully is the dominant strategy. Unfortunately, VCG can lead to very low or even zero revenue, which is unstable and may cause collusion between the seller and some bidders.

3.1 Core-selecting Payment Rules

The weaknesses of VCG payment rule have motivated the development of core-selecting payment rules, which provide a principled way to ensure that the revenue of the auction is high enough such that there are no opportunities for collusion.

Formally, let S ⊆ N ∪ {s} denote a coalition of participants.Then, if s ̸∈ S, the social welfare of S must be 0 since the auction cannot happen without the seller's participation; If s ∈ S, the social welfare of S can be computed as follows:

The coalition characteristic function, F : 2N∪{s} → R, which indicates the optimal social welfare of each coalition S is then defined as follows:

The core is the set of all possible outcomes where the total utility of any coalition cannot be improved by engaging in collusion [Gillies, 1959]. The definition is given as follows:

Definition 1 (Core). The core of a CA is a set of outcomes satisfying the following two conditions:

• Efficiency:

• Coalitional rationality:

Note that the efficiency condition requires that the allocation outcome must be optimal, namely, the allocations are obtained by solving the winner determination problem. It is possible that there is more than one optimal allocation, and we break ties by selecting a random optimal allocation {a∗i }i∈N . Denote by W the winner set, i.e., W = {i|a∗i ̸= ∅}. On the other hand, the coalitional rationality condition guarantees that the maximum social welfare that any coalition S

could get (i.e., RHS of the inequality) is not larger than what the coalition can already get under the current outcome (i.e., LHS of the inequality). Finally, a core-selecting CA selects a social welfare maximizing allocation and picks a payment outcome in the core.

If coalition S does not include the seller, then F(S) = 0. Thus the corresponding constraints of coalitional rationality can be summarized as follows:

If s ∈ S, substitute Eq.5 into Eqs.6 and we can arrange the constraints as follows:

where w(S) is the abbreviation of w({vi(·)}i∈S). Eqs.7 and Eqs.8 form the complete core constraint set, which includes 2N +N constraints in total. We use the utility to analyze in the following discussion and each bidder's payment price is mapped by pi = vi(a∗i ) - πi.

3.2 Minimum-Revenue-Core Payment Rule

Core-selecting CAs are not guaranteed to be truthful [Goeree and Lien, 2016]. To maximize the incentives of truthful bidding, the Minimum-Revenue-Core rule (MRC) is proposed as a fundamental principle to select the core outcomes [Day and Raghavan, 2007; Day and Milgrom, 2008; Day and Cramton, 2012]. The MRC rule maximizes the total utility of all bidders, which can be computed as follows:

where U is the core of the related CA.

Unfortunately, we observe that the MRC rule could suffer from severe unfairness of utility distribution, where some winners' utilities are forced to be zero. This unfair phenomenon largely dues to the fact that the MRC rule emphasizes the total utility and ignores individuals' utilities. We will illustrate this unfair utility distribution phenomenon in the following example.

Example 1. Consider a CA with 5 bidders and 3 items. Let N = {1, 2, 3, 4, 5} be the set of bidders and M = {a, b, c} be the set of items. Table 1 gives the valuation functions of all bidders. By solving the winner determination problem, we have that the winners are bidders 1, 2, and 3, thus the maximum social welfare is that w(N) = v1({a})+v2({b})+ v3({c}) = 6 according to Eq.1. Similarly, w({3, 4, 5}) = 4 and the corresponding constraint is π1 + π2 ≤ 6 - 4 = 2. The other constraints are obtained similarly. After removing the redundant constraints, the core of this example is shown as follows:

According to the MRC rule, the unique utility distribution is {2, 0, 2}. Bidder 2 must sacrifice all of his utility even though he could have obtained a positive utility in other core outcomes (e.g., {1, 1, 1}). In this case, bidder 2 would prefer bidding untruthfully to get more utility. For example, he can bid the value 1 for the item b, which leads to a utility of 1 in the MRC rule.

Extending this example to the general case, we have the following lemma:

Lemma 1. Assuming that bidders bid truthfully, in the worst case, |W| - 2 winners may get zero utility in the MRC rule, even though there exists some core outcome that assigns them with positive utilities, where |W| is the winner size.

Moreover, we observe that the unfair phenomenon often happens in a wide range of domains and datasets when using the MRC rule. To address this issue, we will explore and propose a novel payment rule to achieve fairness.

4 Bidder-Leximin-Optimal Payment Rule

We propose to adopt the leximin principle to achieve fairness in core-selecting CAs, where the leximin principle prefers the utility distribution with a larger utility for the worst-off.

Definition 2 (Leximin Dominance). Let x, y ∈ Rn be two real vectors. x leximin dominates y if the following holds:

• There exists some integer 0 ≤ k ≤ n - 1 such that the k-smallest elements of both vectors are equal, and the (k+1)-smallest element of x is larger than the (k+1)- smallest element of y.

We denote the leximin-dominant relation by "≻Lex", and then a Bidder-Leximin-Optimal (BLO) core outcome is defined as follows:

Definition 3 (Bidder-Leximin-Optimal). Given a core U of a CA, a utility outcome π ∈ U is bidder-leximin-optimal if and only if it is not leximin dominated by any utility outcome π′ in the core, i.e.,

̸

The BLO payment rule follows the leximin principle to give priority to those who are worst-off. It selects a core outcome that is BLO rather than a core outcome that maximizes the total utility of bidders. In order to illustrate the advantage of the BLO payment rule over the MRC payment rule, we consider the following example.

Example 2. Let us recall the CA problem in example 1. The unique MRC utility outcome is π = {2, 0, 2} for the winners. On the other hand, the BLO utility outcome is π′ = {1, 1, 1} under the core constraints in Eqs.10. One can observe that π′ is a fairer utility distribution than π.

4.1 Theoretical Analysis of the BLO Payment Rule

This section provides three theoretical results for the BLO payment rule. First, the following theorem establishes that the BLO outcome is unique and Pareto optimal.

Theorem 1. The BLO outcome always exists, and it is unique and Pareto optimal, where no bidders can improve their utilities without harming other bidders' utilities.

We then consider a lower bound of a bidder's utility in the BLO core outcome.

Theorem 2. Assuming that bidders bid truthfully, given the BLO outcome {πBLO i }i∈N, we have the following tight lower bound:

where π∗ i is the maximum utility for bidder i in the core.

The above lower bound shows that a bidder's utility is always larger than zero in the BLO outcome, unless it is zero in every core outcome's utility distribution. Regarding the total utility of the BLO outcome, it is clear that it cannot be better than that of an MRC outcome, because the total utility of an MRC outcome is maximum. The following result shows the ratio between the BLO outcome and the MRC outcome in terms of their total utility.

Theorem 3. Assuming that bidders bid truthfully, given the BLO utility outcome {πBLO i }i∈N, we have the following tight lower bound:

where {πMRC i }i∈N is an MRC outcome.

One can observe that the relative ratio is 1 if the size of the winner set is 1 or 2, but the relative gap grows linearly with the winner set size |W|. Besides, the BLO outcome has a better guarantee than the general Pareto optimal outcome, which has a tight relative ratio guarantee of 1 |W |-1 2 .

5 An Exact Algorithm for the BLO Payment Rule

In this section, we propose an exact algorithm, named WFCGS-CR, to compute the BLO payment outcome. The WFCGS-CR algorithm is a water-filling (WF) algorithm to increase all active winners' utilities uniformly in an interactive manner until reaching the BLO outcome, and a constraint generation search (CGS) subroutine is adopted to compute the maximum utility increment at each water-filling iteration. Moreover, we offer a constraint-reuse (CR) strategy to accelerate the CGS by setting a better initialization with the history of constraints. We will elaborate on each component of our WF-CGS-CR below.

Since core-selecting CAs involve solving the winner determination problem, existing works [Day and Raghavan, 2007; Day and Cramton, 2012] often assume that there is a so-called winner determination oracle to solve this problem automatically. We will follow such an assumption in this paper and introduce the concept as follows:

2 More detail in the appendix.

Definition 4 (WD). Let WD be an oracle with this inputoutput relation:

Input: submitted bid profile {bi(·)}i∈N, where bi : 2M →R is bidder i's reported valuation function 3 .

Output: a winner set W and maximum social welfare w({bi(·)}i∈N) under the submitted bids.

In other words, we do not dig into the winner determination solving but only regard it as a black-box interface. Any stateof-the-art winner determination method can be used in this way. Oracle complexity is defined as the query time to the oracle in the worst case, which is the primary analysis aspect for the algorithms in this paper.

5.1 Water-filling Algorithm

Water-filling algorithm was first proposed in [Niazadeh et al., 2022] to compute an approximate Pareto optimal outcome. Different from the original version, we develop the algorithm for the exact BLO outcome.

Given a utility distribution in the core, we have two kinds of winners: the active winner and the frozen winner. The active winner has the potential to increase his utility, while the frozen winner can not increase the utility further. Our waterfilling algorithm starts from the all-zero utility distribution and the initial active winner set W (i.e., the original winner set). Then, at the t-th iteration, it does the following:

• Run the search subroutine to return the maximum utility increment ∆πt and the frozen winner set W t f .
• Generate the next utility distribution by increasing each active winner's utility by ∆πt and generate the next active winner set by removing W t f from the current active winner set W t a .

The iteration stops when the active winner set becomes empty, i.e., no one can increase his utility anymore. The pseudo-code is shown in Alg.1.

A search subroutine is adopted to find the maximum utility increment and the frozen winner set at each iteration. Formally, given that the current utility distribution {πt i }i∈N is in the core, the optimization problem for the search subroutine can be formulated as follows:

where {πt i +∆π}i∈W t a means increasing the utilities of winners in W t a by ∆π while the other winners' utilities remain unchanged. After the utility increment, some winners' utilities can not increase anymore, i.e., the frozen winner set at this iteration. Then we have the following lemma:

Lemma 2. Given that the results computed by the search subroutine are correct, the water-filling algorithm returns the BLO outcome.

5.2 Constraint Generation Search Subroutine

A naive method to solve the problem (P0) is obtaining all the core constraints, but it needs to query the winner determination oracle exponential times according to Eqs.8. To avoid Algorithm 1 Water-filling algorithm for finding the exact BLO outcome

3 We regard the bidders' reported valuation functions as their true valuation functions in the computation part.

Input: bid profile {bi(·)}i∈N.

Output: the BLO outcome.

• 1: Step t ← 1
• 2: W,w(N) ←WD({bi(·)}i∈N)
• 3: Initialize the utility distribution {πt i }i∈N as all-zero
• 4: Initialize the active winner set W t a as W
• 5: while W t a is not empty do
• 6: Run the search subroutine to return the maximum utility increment ∆πt and the frozen winner set W t f
• 7: Generate the next utility distribution:

• 8: Generate the next active winner set:

• 9: Step t ← t +1
• 10: return {πt i }i∈N

this, in this section, we first formulate the problem (P0) to an equivalent mathematical format and then solve it through the constraint generation search.

Optimization Problem Formulation

In the original format (P0), the restriction condition is to ensure the utility distribution is still in the core, in other words, satisfying all the core constraints. According to Eqs.8, the constraints can be written as:

If W t a ⊆ S, then |W t a \S| = 0, and the corresponding constraints can be ignored. Thus, we can arrange the remaining constraints as follows:

where S ⊆ N and W t a ̸⊆ S. Every such constraint provides an upper bound for ∆π. Denote by ∆πS the upper bound corresponding to S, i.e., RHS in Eq.13. Thus, finding the maximum utility increment satisfying all the core constraints is equivalent to finding the minimum upper bound above. Problem (P0) is equivalent to the following optimization problem:

Let S∗ be one of the optimal coalitions for problem (P1), thus ∆πt = ∆πS∗ . After the increment, the corresponding core constraint of S∗ would be tight for the new utility distribution {πt+1 i }i∈N, thus we have

According to Eq.14, bidders belonging to N\S∗ cannot increase their utilities without violating this constraint, i.e., they are frozen. Therefore, the frozen winner set W t f is W t a \S∗ at this iteration. Problem (P1) is actually a nesting optimization problem with a fractional format since w(S) is corresponding to the winner determination problem. Thus it is intractable to solve directly, and we propose to use the constraint generation method that only considers the most useful constraints.

Constraint Generation Search

Generally speaking, CGS starts from an upper bound of the utility increment, then reduces the upper bound iteratively through generated constraints until it is the minimum.

Formally, CGS initializes the upper bound ∆¯π as ∞ and the frozen winner set as W t a . It checks whether this upper bound is the minimum by the following equation:

where {˜πi}i∈N is the utility distribution by setting the utility increment as ∆¯π and wB is the maximum social welfare under the truncated bid profile {max(bi(·) - ˜πi, 0)}i∈N. If Eq.15 is satisfied, the current upper bound ∆¯π is the minimum, and CGS will return the result. Otherwise, a smaller upper bound is computed by

The corresponding frozen winner set is updated by

where B is the winner set under the truncated bid profile {max(bi(·) - ˜πi, 0)}i∈N. If the new frozen winner set satisfies | ¯Wf | = 1, then this upper bound is the minimum. Otherwise, CGS will start a new iteration with the smaller upper bound. The oracle complexity of CGS is given as follows:

Lemma 3. Constraint generation search requires at most |W t a | queries to the oracle WD to solve the optimization problem (P1).

Assume that the iteration number of the water-filling algorithm is T. Naturally, since W = W 1 a ⊃ ... ⊃ W T a = ∅, the query time of the CGS subroutine in the water-filling algorithm is at most |W| + (|W| - 1) + ... + 1 = |W|(|W|+1) 2 .

5.3 Constraint-reuse Strategy

To avoid CGS starting from the naive upper bound ∞, we propose the constraint-reuse strategy to set a better initialization through the history of constraints.

Formally, we store the binary tuple (W S f ,∆πS ) in the stored constraint set C, where W S f is the frozen winner set if S is an optimal coalition, i.e., W S f =W t a \S. Then in each CGS subroutine, we first update each binary tuple C based on the new utility distribution and active winner set. The recurrence formula is given as follows:

Algorithm 2 Constraint generation search with the constraint-reuse strategy

Input: bid profile {bi(·)}i∈N, maximum social welfare w(N), current utility distribution {πt i }i∈N, active winner set W t a , last utility increment ∆πt-1 , constraint set C.

Output: the maximum utility increment ∆πt and the frozen winner set W t f .

/*Constraint-reuse Strategy*/

• 1: Initialize ∆¯π ←∞; ¯Wf ←W t a
• 2: for (W S f ,∆πS ) in C do
• 3: C←C\ {(W S f ,∆πS )}
• 4: if W S f ∩W t a ̸= ∅ then

/*Constraint Generation Search*/

• 8: while True do
• 9: Generate the utility distribution by upper bound ∆¯π:

• 13: C←C∪ {( ¯Wf ,∆¯π)}
• 14: if | ¯Wf | = 1 then break
• 15: return ∆¯π, ¯Wf

Above all, we have introduced the three components of the WF-CGS-CR algorithm and the runtime guarantee is shown as follows:

Theorem 4. The WF-CGS-CR algorithm requires at most |W |(|W |+1) 2 +1 queries to oracleWD and an additional time complexity O(|W|5 ) to obtain the BLO outcome, where |W| is the winner size.

By adopting this formula, we transfer each binary tuple (W S f ,∆πS ) to a new binary tuple ( ´W S f ,∆´πS ) before CGS. Eventually, the minimum upper bound in the constraint set is computed and serves as the initial upper bound for CGS. Besides, each new binary tuple is stored in the constraint set if ´W S f is not empty. The complete pseudo-code for the CGS subroutine is shown in Alg.2. Note that this strategy would increase some extra computation complexity that is minor since the winner determination oracle is the main timeconsuming part.

6 Experiments

In the experiments, we use the CATS (Combinatorial Auction Test Suite) [Leyton-Brown et al., 2000] as the CA instance generator. Same as [B¨unz et al., 2015], we choose six representative CATS distributions: Arbitrary, Decay(L4), Matching, Paths, Regions, and Scheduling. For each distribution, we generate 50 CA instances with 64 goods and 1000 bids. All the experiments were run on a high-performance computer with a 3.10GHz Intel core and 16GB of RAM. Besides, the winner determination problem is transformed into a format of integer programming, solved by the solver CPLEX 20.1.0 [Manual, 1987]. The following payment rules are implemented for the comparison:

• VCG: the VCG payment rule, where each winner's utility is πV CG i = w(N) -w(N \ {i}).
• MRC: the MRC payment rule that selects one core outcome with the maximum total utility of bidders [Day and Raghavan, 2007].
• MRC-VCG: a quadratic payment rule that selects the MRC point nearest to the VCG point in l2-distance [Day and Cramton, 2012].
• MRC-Zero: a quadratic payment rule that selects the MRC point nearest to the all-zero point in l2-distance [Day and Cramton, 2012].
• Fast Core: the approximate BLO payment rule implemented through the water-filling algorithm with the binary search [Niazadeh et al., 2022].

We use the state-of-the-art Core Constraint Generation (CCG) algorithm to compute all the MRC outcomes above [Day and Raghavan, 2007]. Unfortunately, it has no theoretical guarantee for the query time; in other words, its oracle complexity may be exponential. Instead, the oracle complexity of Fast Core is O(|W| log |W| ϵ ), where ϵ is the parameter representing the approximate gap. Same as [Niazadeh et al., 2022], ϵ is set as 0.01 in our experiments.

6.1 Experimental Results

The auction results are shown in Table 2. We can see that core-selecting payment rules enhance the seller's revenue compared to the VCG payment rule. Among the coreselecting payment rules, the BLO rule achieves a fairer utility distribution with a tiny reduction of the total utility (i.e., from 173.65 to 147.17). Moreover, the MRC rules produce an unfair utility distribution, with nearly 30% winners obtaining zero utility, which impairs the incentives for bidders. Instead, the BLO rule has only 1.69% zero-utility winners on average, thus providing a guarantee for the worst-off. Fast Core achieves approximate fairness, but there are still 12.71% zero-utility winners.

The average run time results are shown in Table 3, where WF-CGS represents our algorithm without the constraintreuse strategy. Note that we include the run time for computing VCG prices for the MRC rules since it serves as the initial point in the CCG algorithm [Day and Raghavan, 2007]. As we can see, the WF-CGS-CR algorithm performs the best among all the core-selecting algorithms, which is even close to the VCG algorithm. Moreover, the constraint-reuse strategy is effective in our experiments, especially in the distribution of Paths.

7 Conclusion

In this paper, we propose the BLO payment rule to address the unfair issue with the MRC rule. The BLO payment rule adopts the leximin principle to select the core outcome, prioritizing the worst-off bidders. Furthermore, we theoretically analyze the BLO rule and propose the WF-CGS-CR algorithm to compute the exact BLO outcome. Our algorithm has the quadratic oracle complexity and achieves the best run time in the experiments, even close to VCG.

Compared with the MRC rule, the BLO rule has the following advantages: (1) the BLO outcome is unique, avoiding the problem of core outcome selection; (2) the BLO outcome achieves leximin fairness and thus avoids the unfair phenomenon caused by the MRC rule; (3) given the winner determination oracle access, the BLO outcome is computed effectively in time polynomial in the winner size. Therefore, the BLO rule could serve as an alternative payment rule for the core-selecting CAs.

Acknowledgements

This research was supported by the National Natural Science Foundation of China (Grant No. 62192783, U1811462), the Collaborative Innovation Center of Novel Software Technology and Industrialization at Nanjing University. The work of Shufeng Kong was partially supported by the "Hundred Talents Program" of Sun Yat-sen University. The work of Caihua Liu was partially supported and funded by the Humanities and Social Sciences Youth Foundation, Ministry of Education of the People's Republic of China (Grant No.21YJC870009). Bo An is supported by the National Research Foundation, Singapore under its Industry Alignment Fund - Pre-positioning (IAF-PP) Funding Initiative. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not reflect the views of National Research Foundation, Singapore.