Inducing Equilibria via Incentives: Simultaneous Design-and-Play Ensures Global Convergence
Abstract
To regulate a social system comprised of self-interested agents, economic incentives are often required to induce a desirable outcome.
This incentive design problem naturally possesses a bilevel structure, in which a designer modifies the rewards of the agents with incentives while anticipating the response of the agents, who play a non-cooperative game that converges to an equilibrium.
The existing bilevel optimization algorithms raise a dilemma when applied to this problem: anticipating how incentives affect the agents at equilibrium requires solving the equilibrium problem repeatedly, which is computationally inefficient; bypassing the timeconsuming step of equilibrium-finding can reduce the computational cost, but may lead the designer to a sub-optimal solution.
To address such a dilemma, we propose a method that tackles the designer’s and agents’ problems simultaneously in a single loop.
Specifically, at each iteration, both the designer and the agents only move one step.
Nevertheless, we allow the designer to gradually learn the overall influence of the incentives on the agents, which guarantees optimality after convergence.
The convergence rate of the proposed scheme is also established for a broad class of games.
Introduction
A common thread in human history is how to "properly" regulate a social system comprised of self-interested individuals.
In a laissez-faire economy, for example, the competitive market itself is the primary regulatory mechanism [47, 16].
However, a laissez-faire economy may falter due to the existence of significant "externalities" [8, 18], which may arise wherever the self-interested agents do not bear the external cost of their behaviors in the entirety.
The right response, many argue, is to introduce corrective policies in the form of economic incentives (e.g., tolls, taxes, and subsidies) [32].
By modifying the rewards of the agents, these incentives can encourage (discourage) the agents to engage in activities that create positive (negative) side effects for the society, and thus guide the self-interests of the agents towards a socially desirable end.
For example, carbon taxes can be levied on carbon emissions to protect the environment during the production of goods and services [35].
Surge pricing has been widely used to boost supply and dampen demand in volatile ride-hail markets [37].
Lately, subsidies and penalties were both introduced to overcome vaccine hesitancy in the world’s hard-fought battle against the COVID-19 pandemic.
The goal of this paper is to develop a provably efficient method for guiding the agents in a noncooperative game towards a socially desirable outcome — e.g., the one that maximizes the social welfare — by modifying their payoffs with incentives. The resulting problem may be naturally interpreted as a Stackelberg game [50] in which the “incentive designer" is the leader while the agents being regulated are the followers.
Hence, it naturally possesses a bilevel structure [3]: at the upper level, the "designer" optimizes the incentives by anticipating and regulating the best response of the agents, who play a non-cooperative game at the lower level.
As the lower-level agents pursue their self-interests freely, their best response can be predicted by the Nash equilibrium [39], which dictates no agent can do better by unilaterally changing their strategy.
Accordingly, the incentive design problem is a mathematical program with equilibrium constraints (MPEC) [30].
In the optimization literature, MPECs are well-known for their intractability [10].
Specifically, even getting a first-order derivative through their bilevel structure is a challenge.
In the incentive design problem, for example, to calculate the gradient of the designer’s objective at equilibrium, which provides a principled direction for the designer to update the incentives, one must anticipate how the equilibrium is affected by the changes [17].
This is usually achieved by performing a sensitivity analysis, which in turn requires differentiation through the lower-level equilibrium problem, either implicitly or explicitly [25].
No matter how the sensitivity analysis is carried out, the equilibrium problem must be solved before updating the incentives.
The resulting algorithm thus admits a double loop structure: in the outer loop, the designer iteratively moves along the gradient; but to find the gradient, it must allow the lower level game dynamics to run its course to arrive at the equilibrium given the current incentives.
Because of the inherent inefficiency of the double-loop structure, many heuristics methods have also been developed for bilevel programs in machine learning [27, 29, 14].
When applied to the incentive design problem, these methods assume that the designer does not solve the equilibrium exactly to evaluate the gradient.
Instead, at each iteration, the game is allowed to run just a few rounds, enough for the designer to obtain a reasonable approximation of the gradient.
Although such a method promises to reduce the computational cost significantly at each iteration, it may never converge to the same optimal solution obtained without the approximation.
Contribution.
In a nutshell, correctly anticipating how incentives affect the agents at equilibrium requires solving the equilibrium problem repeatedly, which is computationally inefficient.
On the other hand, simply bypassing the time-consuming step of equilibrium-finding may lead the designer to a sub-optimal solution.
This dilemma prompts the following question that motivates this study: can we obtain the optimal solution to an incentive design problem without repeatedly solving the equilibrium problem?
In this paper, we propose an efficient principled method that tackles the designer’s problem and agents’ problem simultaneously in a single loop.
At the lower level, we use the mirror descent method [40] to model the process through which the agents move towards equilibrium.
At the upper level, we use the gradient descent method to update the incentives towards optimality.
At each iteration, both the designer and the agents only move one step based on the first-order information.
However, as discussed before, the upper gradient relies on the corresponding lower equilibrium, which is not available in the single-loop update.
Hence, we propose to use the implicit differentiation formula—with equilibrium strategy replaced by the current strategy—to estimate the upper gradient, which might be biased at the beginning.
Nevertheless, we prove that if we improve the lower-level solution with larger step sizes, the upper-level and lower-level problems may converge simultaneously at a fast rate.
The proposed scheme hence guarantees optimality because it can anticipate the overall influence of the incentives on the agents eventually after convergence.
Organization.
In Section 2, we discuss related work.
In Section 3, we provide the mathematical formulation of the incentive design problem.
In Section 4, we design algorithms for solving the problem.
In Section 5, we establish conditions under which the proposed scheme globally converges to the optimal solution and analyze the convergence rate.
The convergence analysis is restricted to games with a unique equilibrium.
In Section 6, we discuss how to apply our algorithms to games with multiple equilibria.
Eventually, we conduct experiments to test our algorithms in Section 7.
Notation.
We denote ⟨· , ·⟩ as the inner product in vector spaces.
For a vector form a = ( a i ) , we denote a − i =
( a j ) j ̸ = i .
For a finite set X ∈ R n , we denote ∆( X ) = { π ∈ R n + : (cid:80) x i ∈X π x i = 1 } . For any vector norm ∥ · ∥ , we denote ∥ · ∥ ∗ = sup ∥
z ∥≤ 1 ⟨· , z ⟩ as its dual norm.
We refer readers to Appendix A for a collection of frequently used problem-specific notations.  Related work The incentive design problem studied in this paper is a special case of mathematical programs with equilibrium constraints (MPEC)
[19], a class of optimization problems constrained by equilibrium conditions. MPEC is closely related to bilevel programs [10], which bind two mathematical programs together by treating one program as part of the constraints for the other.
Bilevel Programming.
In the optimization literature, bilevel programming was first introduced to tackle resource allocation problems [7] and has since found applications in such diverse topics as revenue management, network design, traffic control, and energy systems.
In the past decade, researchers have discovered numerous applications of bilevel programming in machine learning, including meta-learning (ML) [14], adversarial learning [22], hyperparameter optimization, [31] and neural architecture search [27].
These newly found bilevel programs in ML are often solved by gradient descent methods, which require differentiating through the (usually unconstrained) lower-level optimization problem [28].
The differentiation can be carried out either implicitly on the optimality conditions as in the conventional sensitivity analysis [see e.g., 2, 43, 4], or explicitly by unrolling the numerical procedure used to solve the lower-level problem [see e.g., 31, 15].
In the explicit approach, one may "partially" unroll the solution procedure (i.e., stop after just a few rounds, or even only one round) to reduce the computational cost.
Although this popular heuristic has delivered satisfactory performance on many practical tasks [29, 36, 14, 27], it cannot guarantee optimality for bilevel programs under the general setting, as it cannot derive the accurate upper-level gradient at each iteration [53].
MPEC.
Unlike bilevel programs, MPEC is relatively under-explored in the ML literature so far.
Recently, Li et al.
[25] extended the explicit differentiation method for bilevel programs to MPECs.
Their algorithm unrolls an iterative projection algorithm for solving the lower-level problem, which is formulated as a variational inequality (VI) problem.
Leveraging the recent advance in differentiable programming [2], they embedded each projection iteration as a differentiable layer in a computational graph, and accordingly, transform the explicit differentiation as standard backpropagation through the graph.
The algorithm proposed by Li et al.
[26] has a similar overall structure, but theirs casts the lower-level solution process as the imitative logit dynamics [6] drawn from the evolutionary game theory, which can be more efficiently unrolled.
Although backpropagation is efficient, constructing and storing such a graph — with potentially a large number of projection layers needed to find a good solution to the lower-level problem — is still demanding.
To reduce this burden, partially unrolling the iterative projection algorithm is a solution.
Yet, it still cannot guarantee optimality for MPECs due to the same reason as for bilevel programs.
The simultaneous design-and-play approach is proposed to address this dilemma.
Our approach follows the algorithm of Hong et al.
[21] and Chen et al.
[9], which solves bilevel programs via singleloop update.
Importantly, they solve both the upper- and the lower-level problem using a gradient descent algorithm and establish the relationship between the convergence rate of the single-loop algorithm and the step size used in gradient descent.
However, their algorithms are limited to the cases where the lower-level optimization problem is unconstrained .
Our work extends these single-loop algorithms to MPECs that have an equilibrium problem at the lower level.
We choose mirror descent as the solution method to the lower-level problem because of its broad applicability to optimization problems with constraints [40] and generality in the behavioral interpretation of games [34, 23].
We show that the convergence of the proposed simultaneous design-and-play approach relies on the setting of the step size for both the upper- and lower-level updates, a finding that echos the key result in [21].
We first give the convergence rate under mirror descent and the unconstrained assumption and then extend the result to the constrained case.
For the latter, we show that convergence cannot be guaranteed if the lower-level solution gets too close to the boundary early in the simultaneous solution process.
To avoid this trap, the standard mirror descent method is revised to carefully steer the lower-level solution away from the boundary.
Problem Formulation
We study incentive design in both atomic games [39] and nonatomic games [45], classified depending on whether the set of agents is endowed with an atomic or a nonatomic measure.
In social systems, both types of games can be useful, although the application context varies.
Atomic games are typically employed when each agent has a non-trivial influence on the rewards of other agents.
In a nonatomic game, on the contrary, a single agent’s influence is negligible and the reward could only be affected by the collective behavior of agents.
Atomic Game.
Consider a game played by a finite set of agents N = { 1 , . .
. , n } , where each agent i ∈ N selects a strategy a i ∈ A i ⊆ R d i to maximize the reward received, which is determined by a continuously differentiable function u
i : A = (cid:81) i ∈N A i
→ R .
Formally, a joint strategy a ∗ ∈ A is a Nash equilibrium if
[Equation]
Suppose that for all i ∈ N , the strategy set A i is closed and convex, and the reward function u i is convex in a i , then a ∗ ∈ A is a Nash equilibrium if and only if there exists λ i , . . .
, λ n > {+
+} such that [
[Equation]
for all
[Equation]
[Equation]
Example 3.1 (Oligopoly model) .
In an oligopoly model, there is finite set N = { 1 , . . . , n } of firms, each of which supplies the market with a quantity a i ( a i ≥ 0 ) of goods.
Under this setting, we have
A = R n + .
The good is then priced as p ( q ) =
p 0 − γ · q , where p 0 , γ > 0 and q = (cid:80) j ∈N a i it the total output.
The profit and the marginal profit of the firm i are then given by
[Equation]
respectively, where c i is the constant marginal cost 2 for firm i .
Nonatomic Game.
Consider a game played by a continuous set of agents, which can be divided into a finite set of classes N = { 1 , . .
. , n } .
We assume that each i ∈ N represents a class of infinitesimal and homogeneous agents sharing the finite strategy set A i with |A
i | =
d i .
The mass distribution for the class i is defined as a vector q i ∈ ∆( A i ) that gives the proportion of agents using each strategy.
Let the cost of an agent in class i to select a strategy a ∈ A i given q = ( q 1 , . .
. , q n ) be c ia ( q ) .
Formally, a joint mass distribution q ∈ ∆( A ) = (cid:81) i ∈N ∆( A i ) is a Nash equilibrium, also known as a Wardrop equilibrium [51], if for all i ∈ N , there exists b i such that
[Equation]
The following result extends the VI formulation to Nash equilibrium in nonatomic game: denote c i ( q )
=
( c ia ( q )) a ∈A i , then q ∗ is a Nash equilibrium if and only if [11] [Equation] all q ∈ ∆( A ) .
[Equation]
Example 3.2 (Routing game) .
Consider a set of agents traveling from source nodes to sink nodes in a directed graph with nodes V and edges E .
Denote N ⊆ V × V as the set of source-sink pairs,
A i ⊆ 2 E as the set of paths connecting i ∈ N and E ia ⊆ E as the set of all edges on the path a ∈ A i .
Suppose that each source-sink pair i ∈ N is associated with ρ i nonatomic agents aiming to choose a route from A i to minimize the total cost incurred.
Let q ia ∈ ∆
( A i ) be the proportion of travelers using the path a ∈ A w , x e ∈ R + be the number of travelers using the edge e and t e ( x e ) ∈ R + be the cost for using edge e .
Then we have x e = (cid:80) i ∈N (cid:80) a ∈A i ρ i · q ia · δ eia , where δ eik equals 1 if e ∈ E ia and 0 otherwise.
The total cost for a traveler selecting a path a ∈ A i will then be c ia
[Equation]
Incentive Design.
Despite the difference, we see that an equilibrium of both atomic and nonatomic games can be formulated as a solution to a corresponding VI problem in the following form
[Equation]
where v i and X i denote different terms in the two types of games.
Suppose that there exists an incentive designer aiming to induce a desired equilibrium.
To this end, the designer can add incentives θ ∈ Θ ⊆ R d , which is assumed to enter the reward/cost functions and thus leads to a parameterized v iθ ( x ) .
We assume that the designer’s objective is determined by a function f : Θ × X
→ R .
Denote
S ( θ ) as the solution set to (3.3).
We then obtain the uniform formulation of the incentive design problem for both atomic games and nonatomic games
[Equation]
If the equilibrium problem admits multiple solutions, the agents may converge to different ones and it would be difficult to determine which one can better predict the behaviors of the agents without additional information.
In this paper, we first consider the case where the game admits a unique equilibrium.
Sufficient conditions under which the game admits a unique equilibrium will also be provided later.
We would consider the non-unique case later and show that our algorithms can still become applicable by adding an appropriate regularizer in the cost function.
Stochastic Environment.
In the aforementioned settings, v iθ ( x ) is a deterministic function.
Although most MPEC algorithms in the optimization literature follow this deterministic setting, in this paper, we hope our algorithm can handle more realistic scenarios.
Specifically, in the real world, the environment could be stochastic if some environment parameters that fluctuate over days.
In a traffic system, for example, both worse weather and special events may affect the road condition, hence the travel time v iθ ( x ) experienced by the drivers.
We expect our algorithm can still work in the face of such stochasticity.
To this end, we assume that v iθ ( x ) represents the expected value of the cost function.
On each day, however, the agents can only receive a noised feedback (cid:98) v iθ as an estimation.
In the next section, we develop algorithms based on such noisy feedback.
Algorithm
We propose to update θ and x simultaneously to improve the computational efficiency.
The game dynamics at the lower level is modeled using the mirror descent method.
Specifically, at the stage k , given θ k and x k , the agent first receives v iθ k ( x k ) as the feedback.
After receiving the feedback, the agents update their strategies via
[Equation]
where D ψ i ( x ik , x i ) is the Bregman divergence induced by a strongly convex function ψ i .
The accurate value of ∇ f ∗ ( θ k ) , the gradient of its objective function, equals
[Equation]
which requires the exact lower-level equilibrium x ∗ ( θ k ) .
However, at the stage k , we only have the current strategy x k .
Therefore, we also have to establish an estimator of ∇ x ∗ ( θ k ) and ∇ f ∗ ( θ k ) using x k , the form of which will be specified later.
Remark 4.1 .
The standard gradient descent method is double-loop because at each θ k it involves an inner loop for solving the exact value of x ∗ ( θ k ) and then calculating the exact gradient.
4.1 Unconstrained Game
We first consider unconstrained games with X i =
R d i , for all i ∈ N .
We select ψ i ( · ) as smooth function, i.e., there exists a constant H ψ ≥ 1 such that for all i ∈ N and x i ,[-x i 
 2 X i ,-]
[Equation]
Example of ψ i satisfying this assumption include (but is not limited to) ψ i ( x i ) =
( x i )
⊤ Q i x i / 2 , where Q i ∈ R d i × R d i is a positive definite matrix.
It can be directly checked that we can set
H ψ = max i ∈N δ i , where δ i is the largest singular value of Q i .
In this case, the corresponding
Bregman divergence becomes D ψ i ( x i , x i ′ ) =
( x i − x i ′ ) ⊤ Q i ( x i − x i ′ ) / 2 , which is known as the squared Mahalanobis distance.
Before laying out the algorithm, we first give the following lemma characterizing ∇ θ x ∗ ( θ ) .
Lemma 4.2.
When X i =
R d i and ∇ x v θ ( x ∗ ( θ )) is non-singular, it holds that
[Equation]
Proof.
See Appendix B.2 for detailed proof.
For any given θ ∈ Θ and x ∈ X , we define
[Equation]
Although we cannot obtain the exact value of ∇ f ∗ ( θ k ) , we may use (cid:98) ∇ f ( θ k , x k ) as a surrogate and update θ k based on (cid:98) ∇ f ∗ ( θ k , x k ) instead.
Now we are ready to present the following bilevel incentive design algorithm for unconstrained games (see Algorithm 1).
Input: θ 0 ∈ Θ , x 0 ∈ X = R d , where d = (cid:80) i ∈N d i , sequence of step sizes ( α k , { β ik } i ∈N ) .
For k = 0 , 1 , . . .
do:
Update strategy profile x
[Equation]
for all
[Table]
∈ [Table] , where [Table]
ik
[Table]
[Table] [Equation] In Algorithm 1, if θ k and x k converge to fixed points ¯ θ and ¯ x , respectively, then ¯ x = x ∗ (¯ θ ) is expected to be satisfied.
Thus, we would also have (cid:98) ∇ f (¯ θ, ¯ x ) = ∇ f ∗ (¯ θ ) .
Thus, the optimality of ¯ θ can be then guaranteed.
It implies that the algorithm would find the optimal solution if it converges.
Instead, the difficult part is how to design appropriate step sizes that ensure convergence.
In this paper, we provide such conditions in Section 5.1.
4.2 Simplex-Constrained Game
We then consider the case where for all i ∈ N , x i is constrained within the probability simplex
[Equation]
where 1 d i ∈ R
d i is the vector of all ones.
Here we remark that any classic game-theoretic models are simplex-constrained.
In fact, as long as the agent faces a finite number of choices and adopts a mixed strategy, its decision space would be a probability simplex [39].
In addition, some other types of decisions may also be constrained by a simplex.
For example, financial investment concerns how to split the money on different assets.
In such a scenario, the budget constraint can also be represented by a probability simplex.
In such a case, we naturally consider ψ i ( x i ) =
− (cid:80) j ∈
[ d i ] [ x i ] j · log[ x i ] j , which is the Shannon entropy.
Such a choice gives the Bregman divergence D ψ i ( x i , x i ′ )
= (cid:80)
j ∈ [ d i ] [ x i ] j · log([ x i ′ ] j / [ x i ] j ) , which is known as the KL divergence.
In this case, we still first need to characterize ∇ θ x ∗ ( θ ) , which also has an analytic form.
Specifically, if we define a function h θ ( x ) = ( h iθ ( x i ))
i ∈N that satisfies
[Equation]
then for any θ , x i ∗ ( θ ) satisfies x i ∗ ( θ ) =
h θ ( x i ∗ ( θ ))
Implicitly differentiating through this fixed point equation then yields ∇ x ∗ ( θ ) = ∇ θ h θ ( x ∗ ( θ )) · ( I − ∇ x h θ ( x ∗ ( θ )))
− 1 .
Then, similar to (4.3), we may use
[Equation]
to approximate the actual gradient ∇ f ∗ ( θ ) and then update θ k based on ∇ f ∗ ( θ k ) instead.
Remark 4.3 .
The mapping h θ ( x ) has an analytic expression, which reads
[Equation]
Hence, both ∇ x h θ ( x ) and ∇ θ h θ ( x ) can also be calculated analytically.
In addition to a different gradient estimate, we also modify Algorithm 1 to keep the iterations x k from hitting the boundary at the early stage.
The modification involves an additional step that mixes the strategy with a uniform strategy
d i /d i , i.e., imposing an additional step
[Equation]
upon finishing the update (4.4), where ν k +1 ∈ (0 , 1) is a the mixing parameter, decreasing to 0 when k → ∞ .
In the following, we give the formal presentation of the modified bilevel incentive design algorithm for simplex-constrained games (see Algorithm 2). games
Input: θ 0 ∈ Θ x 0 ∈ X step sizes ( α k , β ik } i ∈N )
≥
[Equation]
for all i ∈ N , where (cid:98) v ik is an estimator [Table] k (
[Table]
x k ) . [Table] parameter
[Equation]
[Table] x [Table] [Equation]
Similar to Algorithm 1, at the core of the convergence of Algorithm 2 is still the step size.
This case is even more complicated, as we need to design α k , β k , and ν k at the same time.
In this paper, a provably convergent scheme is provided in Section 5.2.
Before closing this section, we remark that the algorithm can be easily adapted to other types of constraints by using another h θ ( x ) to model the game dynamics.
Particularly, the projected gradient descent dynamics has very broad applicability.
In this case, the algorithm for calculating ∇ θ h θ ( x ) and ∇ x h θ ( x ) is given by, for example, Amos and Kolter [2].
The additional step (4.6) then becomes unnecessary as it is dedicated to simplex constraints.
Convergence Analysis
In this section, we study the convergence of the proposed algorithms.
For simplicity, define
[Equation]
ψ i (cid:0) x i , x i ′ (cid:1) .
We make the following assumptions.
Assumption 5.1.
The lower-level problem in (3.4) satisfies the following conditions.
The strategy set
X i of agent i is a nonempty, compact, and convex subset of R d i .
For each i ∈ N , the gradient v iθ ( · ) is H u -Lipschitz continuous with respect to D ψ , i.e., for all i ∈ N and x, x ′ ∈ X , ∥ v iθ ( x ) − v iθ ( x ′ )
∥ 2 ∗ ≤ H 2 u · D ψ ( x, x ′ ) .
(3) There exist constants ρ θ , ρ x > 0 such that for all x ∈ X and θ ∈ Θ , ∥∇ θ v θ ( x ) ∥ 2 < ρ θ , and ∥ [ ∇ x v θ ( x )] − 1 ∥ 2 ≤ 1 /ρ x .
For all θ ∈ Θ , the equilibrium x ∗ ( θ ) of the game is strongly stable with respect to D ψ , i.e., for all x ∈ X , (cid:80) i ∈N λ i · ⟨ v iθ ( x ) , x i ∗ ( θ ) − x i ⟩ ≥
D ψ ( x ∗ ( θ ) , x ) .
Assumption 5.2.
The upper-level problem in (3.4) satisfies the following properties.
(1) The set Θ is compact and convex.
The function f ∗ ( θ ) is µ -strongly convex and ∇ f ∗ ( θ ) has 2 -norm uniformly bounded by M .
The extended gradient (cid:101) ∇ f ( θ, x ) is (cid:101) H -Lipschitz continuous with respect to D ψ , i.e., for all x, x ′ ∈ X , ∥ (cid:101) ∇ f ( θ, x ) − (cid:101) ∇ f ( θ, x ′ )
∥ 22 ≤ (cid:101) H 2 · D ψ ( x, x ′ ) .
Assumption 5.3.
Define the filtration by F θ 0 = { θ 0 } , F x 0 = ∅ , F θk = F θk − 1 ∪ { x k − 1 , θ k } , and
F xk = F xk − 1 ∪ { θ k , x k } .
We assume (1) the feedback (cid:98) v k is an unbiased estimate, i.e., for all i ∈ N , we have E [ (cid:98) v ik | F xk ] =
v iθ k ( x k ) ; (2) The feedback (cid:98) v k has bounded mean squared estimation errors, i.e., there exists δ u > 0 such that E [ ∥ (cid:98) v ik − v iθ k ( x k ) ∥ 2 ∗ | F xk ] ≤ δ 2 u for all i ∈ N .
Below we discuss when the proposed assumptions hold, and if they are violated, how would our algorithm works.
Assumption 5.1 includes the condition that x ∗ ( θ ) is strongly stable.
In this case, it is the unique Nash equilibrium of the game [34].
It is also a common assumption in the analysis of the mirror descent dynamics itself [13].
We provide sufficient conditions for checking strong stability in Appendix B.1.
We refer the readers to Section 6 for an explanation of how to extend our algorithm when this assumption is violated.
Assumption 5.2 includes the convexity of the upper-level problem, which is usually a necessary condition to ensure global convergence.
Yet, without convexity, our algorithm can still converge to a local minimum.
Assumption 5.3 becomes unnecessary if we simply assume that the environment is deterministic.
In this case, the accurate value of v iθ ( x ) is available.
Yet, if the noises are added to the feedback, assuming that the noisy feedback is unbiased and bounded is still reasonable.
5.1 Unconstrained Game
In this part, we establish the convergence guarantee of Algorithm 1 for unconstrained games.
We define the optimality gap ϵ θk and the equilibrium gap ϵ xk +1 as
[Equation]
We track such two gaps as the convergence criteria in the subsequent results.
Theorem 5.4.
For Algorithm 1, set the step sizes α k = α/ ( k + 1) , β k = β/ ( k + 1) 2 / 3 , and β ik = λ
i · β k with constants α > 0 and β > 0 satisfying
[Equation]
where H ∗ = ρ θ /ρ x .
Suppose that Assumptions 5.1-5.3 hold, then we have
[Equation]
Proof.
See Appendix C for detailed proof and a detailed expression of convergence rates.
5.2 Simplex-Constrained Game
In this part, we establish the convergence guarantee of Algorithm 2 for simplex constrained games.
We still define optimality gap ϵ θk as ϵ θk = E (cid:2) ∥ θ k − θ ∗ ∥ 22 (cid:3) .
Yet, corresponding to (4.6), we track (cid:101) ϵ xk + as a measure of convergence for the strategies of the agents, which is defined as
[Equation]
where (cid:101) x ∗ ( θ k ) =
(1 − ν k ) · x ∗ ( θ k ) + ν k · 1 /d i .
We are now ready to give the convergence guarantee of Algorithm 2.
Theorem 5.5.
For Algorithm 2, set the step sizes α k = α/ ( k +1) 1 / 2 , β k = β/ ( k +1) 2 / 7 , β ik = λ
i · β k , and ν k = ν/ ( k + 1) 4 / 7 with constants α > 0 and β > 0 satisfying
[Equation]
where (cid:101) H ∗ =
(1 + d ) ρ θ /ρ x .
Suppose that Assumptions 5.1-5.3 hold.
If there exists some constant
V ∗ > [-
-]0 such that ∥ v θ ( x ∗ ( θ )) ∥ ∞ ≤ V ∗ for any θ ∈ Θ , we then have
[Equation]
Proof.
See Appendix D for detailed proof and a detailed form of the convergence rates.
Extensions to Games with Multiple Equilibria
We then briefly discuss how to apply our algorithms when the lower-level game has multiple equilibria.
Case I : If the function v θ ( x ) =
( v iθ ( x ))
i is strongly monotone in the neighbourhood of each equilibrium, then all equilibria are strongly stable in a neighbourhood and hence isolated [38].
In this case, our algorithms can be directly applied as ∇ x v θ ( x ) is non-singular in these neighborhoods.
It is commonly believed that the most likely equilibrium is the one reached by the game dynamics [52]; our algorithm naturally converges to this one.
Case II : If the function v θ ( x ) =
( v iθ ( x ))
i is monotone but not strongly monotone, then the equilibrium set is a convex and closed region [34].
This case is challenging, as the matrix ∇ x v θ ( x ) needed to be inverted would become singular.
Nevertheless, we can simply assume the agents are bounded rational [42, 1, 33].
The bounded rationality would result in a quantal response equilibrium for predicting the agents’ response.
We refer the readers to Appendix F for a detailed explanation (with numerical examples for illustration).
Here we briefly sum up the key takeaways: (1) it is equivalent to add a regularizer η i · (log( x i + ϵ ) + 1) to v iθ ( x ) for some η i > 0 and ϵ ≥ 0 ; (2) as long as θ > 0 , the strong stability condition in Assumption 5.1 would then be satisfied, hence a unique equilibrium would exist; (3) as long as ϵ > 0 , the Lipschitz continuous condition in Assumption 5.1 will also not be violated.
In a nutshell, the bounded rationality assumption can simultaneously make our model more realistic and satisfy the assumptions in Section 5.
Numerical Experiments
In this section, we conduct two numerical experiments to test our algorithms.
Pollution Control via Emission Tax.
We first consider the oligopoly model introduced in Example 3.1.
We assume that producing a i units of output, firm i would generate e i =
d i a i units of emissions.
We consider the following social welfare function [44]
[Equation]
[-P ni =
 d i a i ,-] where the first term is the consumers’ surplus, the second term is the total production cost, and the third term is the social damage caused by pollution.
To maximize social welfare, an authority can impose emission taxes on the productions.
Specifically, whenever producing a i units of output, firm i could be charged π i · a i , where π i is specialized for the firm i .
In the experiment, we set n = 100 , p 0 = 100 , γ = 1 , τ = 10 , and d i = 10 − exp( c i )
+ ϵ i , where { c i } 100 i =1 are evenly spaced between 1 and 2 and { ϵ i } 100 i =1 are the white noises.
Under this setting, c i and e i are negatively correlated, which is realistic because if a firm hopes to reduce their pollution by updating their emission control systems, the production cost must be increased accordingly. Through this small numerical example, we hope to illustrate that the single-loop scheme developed in this paper is indeed much more efficient than previous double-loop algorithms. To this end, we compare our algorithm with two double-loop schemes proposed by Li et al. In both approaches, the lower-level equilibrium problem is solved exactly first at each iteration.
But afterwards, the upperlevel gradients are respectively obtained via automatic differentiation (AD) and implicit differentiation (ID).
To make a fair comparison, the same hyperparameters — including the initial solutions, the learning rates, and the tolerance values for both upper- and lower-level problems — are employed for the tested algorithms (double-loop AD, double-loop ID, and our algorithm).
Table 1 reports statistics related to the computation performance, including the total CPU time, the total iteration number, and the CPU time per iteration.
The results reveal that all tested algorithm take a similar number of iterations to reach the same level of precision.
However, the running time per iteration required by our algorithm is significantly lower than the two double-loop approaches.
Hence, in general, our scheme is more efficient.
[Table]
Second-Best Congestion Pricing .
We then consider the routing game model introduced in Example 3.2.
To minimize the total travel delay, an authority on behalf of the public sector could impose appropriate tolls on selected roads [49].
This problem of determining tolls is commonly known as the congestion pricing problem.
The second-best scheme assumes that only a subset of links can be charged [48].
Specifically, we write π ∈ R |E| + as the toll imposed on all the links and E toll as the set of tollable links.
We model total cost for a traveler selecting a path a ∈ A as
[Equation]
where we add an extra term (log( q ia ) + 1) to characterize the uncertainties in travelers’ route choices [20, 5].
It results in a quantal response equilibrium, as discussed in Section 6.
We test our algorithm on a real-world traffic network: the Sioux-Falls network (See Lawphongpanich and Hearn [24] for its structure).
We select 20 links (11, 35, 32, 68, 46, 21, 65, 52, 71, 74, 33, 64, 69, 14, 18, 39, 57, 48, 15, 51) for imposing congestion tolls.
We run Algorithm 2 to solve the problem and compare 4 different settings on the selection of step sizes.
Setting A: α k = α/ ( k + 1) 1 / 2 , β k = β/ ( k + 1) 2 / 7 , and ν k = ν/ ( k + 1) 4 / 7 .
It ensures convergence according to Theorem 5.5.
Setting B: α k = α/ ( k + 1) 1 / 2 , β k
= β/ ( k + 1) 1 , and ν k = ν/ ( k + 1) 4 / 7 .
It only increases the decreasing rate of the step size in the inner loop.
Setting C: α k = α/ ( k + 1) 1 , β k
= β/ ( k + 1) 1 , and ν k = ν/ ( k + 1) 1 .
It assumes that all step sizes decrease based on the classic O (1 /k ) rate.
Setting D: α k = α/ ( k + 1) 1 / 2 , β k
= β/ ( k + 1) 2 / 7 , and ν k
= 0 .
It does not adopt the mixing step proposed in our paper.
We add white noise to the costs received by the agents based on Gaussian distributions and run our algorithm under each setting with 10 times.
The mean value of upper-level optimality gaps and lower-level equilibrium gaps are reported in Figure(the shadowed areas are plotted based on "mean ± std" area over all sampled trajectories).
[Figure]
Below we summarize a few observations. First, without the mixing step proposed in our paper, the algorithm does hit the boundary too early.
The algorithm fails after just a few iterations.
It verifies our earlier claim that directly extending previous methods [21, 9] designed for bilevel optimization problems to MPECs is problematic.
Second, the step size given by Theorem 5.5 ensures the fastest and the most stable convergence.