The Power of Menus in Contract Design
Abstract
We study the power of menus of contracts in principal-agent problems with adverse selection (agents can be one of several types) and moral hazard (we cannot observe agent actions directly). For principal-agent problems with types and actions, we show that the best menu of contracts can obtain a factor more utility for the principal than the best individual contract, partially resolving an open question of Guruganesh et al. (2021). We then turn our attention to randomized menus of linear contracts, where we likewise show that randomized linear menus can be better than the best single linear contract. As a corollary, we show this implies an analogous gap between deterministic menus of (general) contracts and randomized menus of contracts (as introduced by Castiglioni et al. (2022)).
1 Introduction
The principal-agent problem studies a setting where one party (the principal) wishes to incentivize a second party (the agent) to exert effort on behalf of the principal. The agent has different potential actions they could take (e.g., levels of effort they exert), each of which stochastically results in one of several outcomes. The principal cannot directly observe the agent’s action (“moral hazard”) but they have preferences over the different outcomes and would like to incentivize the agent to take a favorable action for the principal. To accomplish this, the principal can offer the agent a contract – a mechanism describing how the principal will reward the agent contingent on the ultimate realized outcome. Principal-agent problems arise in a wide variety of different disciplines (e.g., law, insurance, employment) and the development of contract theory has proven to be an invaluable tool in the economics literature for the analysis of such problems.
Over the past few years, there has been a surge of activity in the application of computational methods to contract theory (much in the same way that computational methods have been successfully applied to mechanism design and auction theory). Many of these papers take the perspective of understanding the power of one class of contracting mechanisms as it compares to another. For example, in Dütting et al. (2019), the authors show that in principal-agent settings with actions, the optimal general contract obtains at most times as much utility as the optimal linear contract (a much simpler subclass of contracts where the principal promises to share a fixed proportion of their utility with the agent), and that there are cases where this is tight. This methodology has been applied to many variants of the principal-agent problem (e.g. variants with combinatorially structured actions and outcomes).
One particularly interesting variant of the principal-agent problem introduces private information (or “adverse selection”) to the problem instance. In this setting an agent may be one of several types (unknown to the principal), and their relevant properties (e.g., the probability they induce a certain outcome by playing a specific action) may differ from type to type, and this allows us to model the uncertainty the principal may have over the agent they are contracting (and capture a much more realistic set of problems).
In the typed principal-agent problem, there are (at least two) natural classes of mechanisms to compare. One option is to, as before, offer a fixed single contract to the agent. However, with the presence of types, the principal also has the option to offer the agent a menu of different contracts (from which the agent selects their favorite). Is it ever in the principal’s interest to do this? This question was originally proposed by Guruganesh et al. (2021), who showed there exist instances where it is strictly beneficial to offer a menu over a single contract. However, Guruganesh et al. (2021) were only able to show that the gap in power between menus and single contracts lies somewhere between (for a setting with actions and types) and . This gap (and even the question of whether it is super-constant) remains open to this day.
Making things even more interesting, Castiglioni et al. (2022) recently showed that there is a third, even more powerful class of mechanisms where the principal offers the agent a menu of randomized contracts (i.e., the agent selects a distribution over contracts and receives a contract randomly drawn from this distribution). Although much is known about the computational properties of such mechanisms111Intriguingly, while single contracts and ordinary menus are computationally hard to optimize in the typed setting, there exist efficient algorithms to find the best menu of randomized contracts., essentially nothing is currently known about the power of such mechanisms – either in comparison to ordinary menus or to individual contracts.
1.1 Our results
In this paper we pin down more closely the power of menus in contract design. We begin by significantly closing the gap present between single contracts and menus of (deterministic) contracts present in Guruganesh et al. (2021). In particular, Guruganesh et al. (2021) prove that in any principal-agent problem with actions and types, the profit of the best menu of contracts is at most larger than the profit of the best individual contract. However, the only lower bound they provide (and the only lower bound known to date) is that there are menus of contracts that outperform individual contracts by a constant factor. In our first two theorems, we show that both the dependence on and in the upper bound are asymptotically tight.
Theorem 1.1 (Restatement of Theorem 3.1).
There exists a principal-agent problem with types and actions where the profit of the optimal menu of (deterministic) contracts is at least larger than the profit of the optimal single contract.
Theorem 1.2 (Restatement of Theorem 3.2).
There exists a principal-agent problem with types and actions where the profit of the optimal menu of (deterministic) contracts is at least larger than the profit of the optimal single contract.
We remark that both the optimal menu of deterministic contracts and the optimal single contract are known to be computationally intractable and thus can be tricky to work with. Previous approaches to show such gaps (such as Guruganesh et al. (2021)) worked via adding gadgets to equate the value of one class to the value of welfare and the value of the other side to the value of linear contracts. Our proof introduces some novel elements that help bar single contracts from doing as well as menus, and does not attempt to reduce to welfare versus linear contracts.
We then switch our attention to the setting of linear contracts. Linear contracts are an important subclass of contracts in which the principal gives the agent a fixed percentage of the principal’s total reward. Linear contracts are commonly used in practice, and much of the recent algorithmic work in contract theory has been focused on better understanding linear contracts in a variety of settings.
At first, it may not seem that menus of linear contracts are particularly useful – given a menu of different fixed percentages, it is always in an agent’s interest to choose the highest fixed percentage (and thus the principal could simply have offered that single linear contract). However, this assumes that we are offering the agent a menu of deterministic linear contracts. This is not the case for menus of randomized linear contracts (in the same sense as the menus of randomized general contracts of Castiglioni et al. (2022)) which do have the potential to outperform a single linear contract. The interaction between the principal and the agent for a menu of randomized linear contracts proceeds as follows:
-
1.
The principal begins by constructing a menu of randomized linear contracts. Each menu item is a distribution over transfer coefficients , where a specific represents the linear contract where the principal offers an fraction of their reward to the agent.
-
2.
The agent (with a randomly drawn type) selects a single distribution from this menu.
-
3.
The principal then samples a linear contract from and reveals it to the agent.
-
4.
The agent observes the linear contract and then takes an action in response. An outcome occurs, the principal receives some reward , gives to the agent, and keeps .
It turns out that randomized menus of linear contracts are in general more powerful than individual linear contracts. In particular, we show that there exist principal-agent problems where the principal can obtain a strictly larger profit by offering a menu of randomized linear contracts than by offering a single linear contract (see Example 4.1).
We then demonstrate how to find the optimal randomized menu of linear contracts by solving a single linear program with variables and constraints (Theorem 4.4). In the course of doing so, we also prove the following facts about the structure of randomized menus of linear contracts, which may be of independent interest. First, we prove that without loss of generality, all randomized linear contracts in the optimal menu have identical support, and this support has size at most (see Lemma 4.2). Secondly (and much more counterintuitively), this optimal support sometimes contains contracts where the principal is guaranteed to lose money; i.e., sometimes it is necessary to include linear contracts with in the menu to achieve the optimal profit for the principal. We give one example of this in Lemma 4.3.
Finally, we attempt to characterize the gap in power between menus of randomized linear contracts and individual linear contracts. An upper bound immediately results from the gap of Guruganesh et al. (2021) between a single linear contract and the maximum achievable welfare in a principal agent problem. We prove a tight lower bound for one specific regime of and (specifically, where and have roughly the same magnitude).
Theorem 1.3 (Restatement of Theorem 4.7).
There exists a principal-agent problem with types and actions where the profit of the optimal menu of randomized linear contracts is at least as large as the profit of the optimal individual linear contract.
Combining Theorem 1.3 with the facts that (i) there are some principal-agent problems where any contract can be equivalently written as a linear contract and (ii) deterministic menus of linear contracts are equal in power to individual linear contracts, we immediately obtain an analogous gap between menus of (general) deterministic contracts and menus of (general) randomized contracts.
Corollary 1.4 (Restatement of Corollary 4.8).
There exists a principal-agent problem with types and actions where the profit of the optimal menu of randomized contracts is at least as large as the profit of the optimal menu of deterministic contracts.
It is natural to ask whether it is possible to strengthen Theorem 1.3 to understand how this gap scales individually with and . That is, how large is the gap between these two types of mechanisms in the regime where there are a constant number of types but the number of actions for each type grows large (analogous to Theorem 1.1) or in the regime where there is a fixed number of actions per type, but the number of different types of agents grows large (analogous to Theorem 1.2)? We do not resolve this question in this paper – however, we make the following related observation: if every type has exactly one non-null action (e.g., every type decides between working and not working), the ratio in the revenue achieved between menus of randomized linear contracts and a single linear contract is at most a (universal) constant.
Theorem 1.5 (Restatement of Theorem 4.6).
In any principal-agent problem where each type of agent has one null action (guaranteeing the principal zero utility) and one non-null action, the profit of the best single linear contract is at least a constant fraction of the profit of the best menu of randomized linear contracts.
1.2 Related work
The principal-agent problem has a long history in economics, stemming back to the foundational papers of Holmström (1979) and Grossman and Hart (1983). Our paper fits into a recent line of work applying techniques from algorithmic mechanism design to contract theory (Alon et al., 2021, Castiglioni et al., 2021, 2022, Dütting et al., 2019, 2020, 2021, Guruganesh et al., 2021, Cohen et al., 2022).
Of these, the most closely relevant are a handful of recent works that consider the intersection of contract theory with private information (“contracts with types”). We build most directly off of Guruganesh et al. (2021), which introduced the problem of determining the gap in power between single contracts and menus of contracts, and Castiglioni et al. (2022), which introduced the concept of menus of randomized contracts and demonstrated they can be computed efficiently. Other works in this space include Alon et al. (2021), which studies a one-dimensional subclass of the typed principal-agent problem where the type simply scales the cost, and Castiglioni et al. (2021), which studies the computational hardness and power of optimal single contracts in the typed principal-agent setting. Also of note is the recent paper of Gan et al. (2022), which provides a revelation principle for general principal-agent problems which implies (among other things) that menus of randomized contracts are the most general possible mechanisms for our setting.
We briefly mention that the theme of more powerful mechanisms (menus / randomized menus in particular) outperforming simpler mechanisms is a common theme throughout many other parts of algorithmic game theory (for example, the classic work of Briest et al. (2010), which proves that randomization is essential to get approximately revenue-optimal mechanisms for selling multiple goods). These settings generally lack the property of moral hazard (i.e., hidden actions) inherent to the contract design setting, and hence these existing results and techniques do not seem to transfer over to the principal-agent problem.
2 Preliminaries
We introduce the typed principal-agent problem following the notation of Guruganesh et al. (2021). In this problem, there are different types of agent (drawn from a known prior distribution), each of which has actions which result in one of possible outcomes. When the agent of type takes action they incur a cost for the agent (regardless of their type) and cause outcome to occur with probability . When outcome occurs, the principal receives a reward . Notably, the principal can only observe the eventual outcome and cannot observe the type of the agent or the action taken by the agent (the hidden-action model with private information). We write , , and to denote the collections of costs, outcome probabilities, and rewards respectively. Together, the tuple completely specifies a typed principal-agent problem instance.
We further always make the assumption that there exists a null action with zero cost () which deterministically results in a null outcome with zero reward for the principal (; other actions may also lead to the null outcome with some probability). In this way we model the possibility for an agent to opt out of participating entirely.
We consider three classes of contracting mechanisms for the principal (and their linear variants, which we define later): (i) single contracts, (ii) menus of deterministic contracts, and (iii) menus of randomized contracts. We discuss these in order.
Single contracts
A contract is simply an -dimensional vector with non-negative entries. For each , specifies the amount the principal promises to transfer to the agent in the case that outcome occurs. In response to a contract , the agent of type chooses the action that optimizes their utility, namely
We call the principal’s net expected utility from offering contract their profit from offering contract . The principal’s profit from an agent of type is given by
and their overall expected profit is given by
We are interested in the largest profit obtainable for the principal via a single contract. We write to denote this maximal profit for the principal agent problem .
Menus of deterministic contracts
In the presence of types, the principal can sometimes obtain additional profit by offering the agent a menu of individual contracts (from which the agent picks the contract that maximizes their expected utility). By the revelation principle, it suffices to specify a single contract for each type, and we can write a general menu of deterministic contracts in the form , where an agent who reports their type to be receives the contract . Such a menu is “incentive-compatible” (IC) if no type has an incentive to misreport their type as a different type :
(1) |
Unless otherwise stated, we restrict our attention to incentive-compatible menus of deterministic contracts. As with single contracts, we write to denote the expected profit for the principal from offering the menu of deterministic contracts , and we write to be the profit of the best menu of deterministic contracts.
Menus of randomized contracts
Deterministic menus can be generalized further by offering distributions over contracts instead of individual contracts. This class of mechanisms was proposed by Castiglioni et al. (2022), and works as follows. The principal offers the agent a menu of distributions over contracts (from which the agent picks the distribution that maximizes their expected utility, with randomness in both which contract gets chosen and which outcome occurs). By the revelation principle, it suffices to specify a distribution for each type, and we can write a general menu of randomized contracts in the form , where an agent who reports their type to be receives the distribution . The principal then draws a contract from and relays it to the agent, who takes an action in response. Such a menu is “incentive-compatible” (IC) if no type has an incentive to misreport their type as a different type :
We restrict our attention to incentive-compatible menus of randomized contracts. As before, we write to denote the expected profit for the principal from offering the menu of randomized contracts , and we write to be the profit of the best menu of randomized contracts.
Linear contracts
We now discuss how to restrict the previous three classes to linear contracts. Contracts with the property that for all and some are called linear contracts.
The most straightforward class to restrict is that of single contracts, where all we do is require that the chosen contract is linear. We write to be the profit of the best (single) linear contract.
The next class to restrict is menus of deterministic contracts, where we require that each individual contract offered by the menu is linear. Specifically, for , we would like each to be linear. Interestingly, this turns out to be no more powerful than (single) linear contracts, because agents might as well pick the offered linear contract with the highest . As a result, also designates the profit of the best menu of deterministic linear contracts.
The final class to restrict is menus of randomized contracts, where we require that each distribution offered by the menu only contains linear contracts in its support. Specifically, for we would like the support of to be linear contracts. We will show this is more powerful than (single) linear contracts. We write to be the profit of the best menu of randomized linear contracts. These menus will be our main object of study in Section 4; as we will see, unlike menus of deterministic linear contracts, these are occasionally more powerful than single linear contracts.
This completes our overview of five classes of contracting mechanisms for the principal. Our five classes of interest are depicted in Figure 1, which also illustrates which classes contain each other.
2.1 Known upper bounds
Guruganesh et al. (2021) proved an upper bound of between a single linear contract and the maximum achievable welfare in a typed principal agent problem. Every class mentioned above is at least as powerful as single linear contracts and at most as powerful as extracting all welfare, so this bound applies to any pair of classes as well. However, this upper bound hinges on two key assumptions: (i) all types have the same set of costs and (ii) the distribution over types is uniform. Removing either of these assumptions breaks the proof, leaving only a bound. In this paper, we will work in the more general setting where the costs may be vary with types and the distribution is nonuniform. However, all proofs can be adapted to work in the more restricted setting above.
3 Gaps between menus and single contracts
In this section, we show that deterministic menus of contracts can be much more powerful than a single contract:
-
•
When the number of types is a constant, there is a principal-agent problem instance for which optimal deterministic menu of contracts can extract times as much profit as the optimal single contract.
-
•
When the number of actions is a constant, there is an instance where optimal deterministic menu of contracts can extract times as much profit as the optimal single contract.
3.1 -gap with three types
Theorem 3.1.
There is a principal-agent problem with agent types and actions, for which optimal deterministic menu can extract times as much profit as optimal single contract can:
We provide here the -gap instance and explain the high-level ideas behind its construction and analysis. We defer the full proof of Theorem 3.1 (which is rather technical) to Section A.1.
Construction of -gap instance
We begin by providing a formal description of the instance, which is also recorded in Table 1. There are three agent types. There are four outcomes, and their rewards are , , and . We will assume we have non-null actions (assuming without loss of generality), with costs given by for , for , and .
We now construct the forecast tensor . First, we let , and for all and , and we let for all and . That is, outcome always occurs when the type agent plays the last actions, when the type agent plays the first actions, and when the type agent plays any action.
For the type agent, we let for all , and we let for all , and moreover, we let for all . For the type agent, we let for all , let for all , and let for all . Furthermore, we let , and . The specific value of will not play any role in the analysis, and we can for example let for completeness (in Table 1 we denote this value by ).
When , it is easy to check that for all , and . Therefore, we can let for all and such that the forecast tensor is well-defined. Finally, we specify the probability of agent types: and .
Type | Outcome | Outcome | Outcome | Outcome |
Reward | Reward | Reward | Reward | |
Action | ||||
Cost | ||||
Action | 0 | 0 | 0 | |
Cost | ||||
Action | ||||
Cost | ||||
Type | Outcome | Outcome | Outcome | Outcome |
Reward | Reward | Reward | Reward | |
Action | ||||
Cost | ||||
Action | ||||
Cost | ||||
Action | ||||
Cost | ||||
Type | Outcome | Outcome | Outcome | Outcome |
Reward | Reward | Reward | Reward | |
Action | ||||
Cost |
High-level idea
First of all, we include the zero-reward outcome merely to satisfy the technical constraint that the probabilities over outcomes sum up to for any type and action. Ideally, we would like to ignore the existence of outcome , but in principle, a contract can specify a strictly positive payment for outcome . Therefore, we introduce type , which has much higher probability than the other two types and always results in outcome to make sure the payment for outcome is negligible (Lemma A.1) and hence does not interfere with the analysis. This is the only role of type , and thus we will ignore outcome and type for the remainder of this discussion.
Essentially, the above -gap instance is constructed such that the principal can only get low profit from type agent regardless of the contract (Lemma A.2), and moreover, the only way to get high profit from type agent is using a contract that associates a sufficiently low payment with outcome and a sufficiently high payment with outcome (Lemma A.3 and Lemma A.4), i.e., the contract must incentivize type agent to play a high-profit action through a high payment for outcome . However, notice that in the -gap instance, the type agent also has significant probability for outcome for every non-null action. Thus, if the contract specifies a high payment for outcome , it makes a high payment to the type agent for almost nothing in return and hence achieves negative profit from the type agent. Overall, this lets us show that the combined profit from these two types of agents is low (the soundness part of the proof of Theorem 3.1). This shows that any single contract has low profit.
On the other hand, notice that in this instance, outcome 3 has a strictly positive reward, and only type agent can possibly cause outcome 3 to happen. Therefore, if we use a menu of two contracts, we can use the first contract to incentivize type agent through a high payment for outcome 2 and use the second contract to lure type agent away from the first contract through a high payment for outcome 3. We can show that the second contract can simultaneously (i) be as attractive as the first contract for type agent and (ii) make zero profit (which is non-negative) from type agent (the completeness part of the proof of Theorem 3.1). Thus, overall the menu achieves high profit (in particular, at least times the profit of the best single contract).
3.2 -gap with two non-null actions
Theorem 3.2.
There is a principal-agent problem with agent types and non-null actions, for which optimal deterministic menu can extract times as much profit as optimal single contract can:
We first give the construction of the -gap instances and explain the high-level idea. Then, we formally implement our idea through multiple lemmas and prove Theorem 3.2.
Type | Outcome | Outcome | Outcome |
() | Reward | Reward | Reward |
Action | |||
Cost | |||
Action | 0 | ||
Cost | 0 otherwise | ||
Type | Outcome | Outcome | Outcome |
Reward | Reward | Reward | |
Action | |||
Cost | |||
Action | |||
Cost |
Construction of -gap instances
We begin by providing a formal description of the instance, which is also recorded in Table 2. For convenience we let for (and we will prove an -gap). There are two non-null actions and outcomes. Action has cost , and action has cost . Outcome has reward , and any other outcome has reward .
Now we construct the forecast tensor . We start with defining for outcomes . For all and , first let , and moreover for such that or , let . Then, let for all . All the other for , and that have not been defined are zero.
It is easy to check that for all , and . Thus, we can let for all and , such that the forecast tensor is well-defined.
Finally, we specify the probability of agent types: for all and , and .
High-level idea
Similar to the -gap instance, here we also have an extra zero-reward outcome to make the forecast tensor well-defined, and we introduce type , which has much larger probability than other types and always results in outcome , in order to make sure that a contract with non-negative profit in expectation over type distribution can only make a negligible payment for outcome (Lemma A.5), such that does not interfere with the analysis. Thus, let us ignore outcome and type in the following discussion.
In the above -gap instance, only outcome generates strictly positive reward, and hence, only action generates strictly positive welfare for any type (because only action has strictly positive probability for outcome ). Moreover, the expected welfare generated by action times the probability of agent type is roughly the same (up to a constant factor) for all types: That is, for all and ,
(2) |
Therefore, to extract a constant fraction of the expected welfare of a random-type agent, the contract must incentivize many agent types to play action . For the type agent, the only two outcomes that action can result into are outcomes and .
Because the probability that action results in outcome is different between different types, the contract cannot incentivize different types using only payment for outcome . Specifically, a small payment for outcome is not enough to cover the expected cost of action for many types, and a large payment for outcome would overpay many types and hence give up a lot of profit (Lemma A.6).
If we use a menu of contracts, we can have one contract for each agent type . Each contract has the same base payment for outcome , which by itself is not enough to incentivize action . Then, contract can incentivize the type agent to play action by an additional payment through outcome . Therefore, such menu can extract a constant fraction of the expected welfare of the agent (the completeness part of the proof of Theorem 3.2).
However, if we adopt the above idea for the single contract rather than the menu, then, we need to make additional payments for many different outcomes in the single contract. In the above -gap instance, for the type agent, action has zero cost and has strictly positive probabilities for all but outcomes and . Therefore, when faced with a single contract with additional payments for many different outcomes, the type agent would prefer playing action , which generates zero profit for the principal. As a consequence, when we use a single contract, there cannot be many types of agents simultaneously preferring action (Lemma A.7), and hence, overall the expected profit is low (the soundness part of the proof of Theorem 3.2).
Remark 3.3.
Under the assumption that the probability of every agent type with non-zero welfare is the same in the prior distribution of the agent type, Guruganesh et al. (2021) proved that linear contracts can achieve a fraction of the profit of the optimal deterministic menu. Thus, our -gap instance (where ) is tight for this setting.
Proof.
Note that in the -gap instance, only agent types has non-zero welfare, but their probabilities in the prior distribution are different. However, we can construct a new instance with equal probabilities of agent types from the -gap instance by making copies of each agent type such that the number of copies is proportional to the probability of that agent type. That is, in the new instance, for each , we make (it is easy to check is an integer) copies of agent type , and we make copies of agent type . In the new instance, all the types have the same probability in the new prior distribution. Clearly, the analysis of Theorem 3.2 still works by replacing the probability of each agent type with the number of copies of that agent type. ∎
4 Menus of randomized linear contracts
We now switch our attention to menus involving linear contracts. As we have already mentioned in Section 2, simple menus of (deterministic) linear contracts are no more powerful than a single linear contract. Instead, our main object of study are menus of randomized linear contracts, formed by specializing the menus of randomized contracts in Castiglioni et al. (2022) to the special case of linear contracts.
Recall that a randomized linear contract is a probability distribution over representing all the possible linear contracts (including linear contracts with , where the principal will pay out more than their entire reward). A menu of randomized linear contracts is defined by a tuple where each is a distribution over the transfer coefficients. The interaction between the principal and an agent of type proceeds as follows:
-
1.
The principal publicly commits to a menu
-
2.
The agent reports a type to the principal, possibly different from the true type
-
3.
The principal draws a transfer coefficient and communicates it to the agent.
-
4.
The agent plays the action that maximizes his utility when offered of the expected reward.
The very first question we might ask ourselves is: are randomized linear contracts actually more powerful than individual linear contracts. The answer (in contrast to the situation with menus of deterministic linear contracts) is yes.
Before we present the example, we will establish some common notation for the rest of the section. Let be the utility obtained by type when offered a linear contract with coefficient . If action has cost and expected reward for the principal, then in fact . From this we can observe that each is a convex, piece-wise linear function with at most pieces. Since we are only dealing with menus of randomized linear contracts, it suffices to specify the slopes of these piecewise linear functions to completely specify the problem instance.
Example 4.1 (Menus of Randomized Linear Contracts Differ From Linear Contracts).
Consider the following typed principal-agent problem with two types (and the underlying distribution is uniform), where is a small constant. Let the slopes of their utility functions be defined as follows:
This problem is designed so that any linear contract where is a breakpoint (one of ) yields a total utility of ; linear contracts at non-breakpoints only get less utility. The following menu achieves slightly more than utility:
Type one is indifferent between the two menu items because it has zero utility at all breakpoints. From type two’s point of view, its menu item has utility and the other menu item has utility . The first menu item extracts a profit of from the first type. The second menu item extracts a profit of from the second type. The total profit is , which is better for . This completes the example.
In the remainder of this section, we study the following three aspects of randomized linear contracts. First, in Section 4.1, we explore various structure of randomized linear contracts: e.g., How large must the support of be in the optimal menu of randomized linear contracts? Is it necessary for the support to contain ? Second, in Section 4.2, we present an efficient algorithm for computing the optimal menu of randomized linear contracts. Finally, in Sections 4.4 and 4.3, we explore (and bound) the gap in power between menus of randomized linear contracts and linear contracts.
4.1 The structure of randomized linear contracts
We begin by establishing some basic structural properties of the randomized linear contracts in belonging to the optimal menu. In particular, we will show that all such contracts are supported on breakpoints where an agent of one type would switch from playing one action to another.
Let be the total number of distinct breakpoints over all functions (in particular, ). We will label these breakpoints as , and for convenience of notation write . The first claim we prove is that, without loss of generality, every optimal menu is supported on this set of breakpoints (including ), and possibly one other point larger than .
Lemma 4.2.
For any principal-agent problem with types and actions, there exists an optimal menu of randomized linear contracts such that, for each ,
for some choice of for each type . In other words, all randomized contracts in this menu only place weight on points of the form or one other (undetermined) point.
We defer the full proof to Appendix A.4 but present a sketch below.
Proof Sketch.
Note that any mass put on a break point can be moved to both neighboring breakpoints without affecting the constraints and only increasing the objective. For the probability mass put on the points above the last breakpoint, we can create a new point based on its conditional expectation in a way that maintains the constraints and improves the objective. ∎
One obvious peculiarity of the characterization in Lemma 4.2 is that it leaves open the option of placing mass above the largest breakpoint , without any bound on the size of . In fact, a priori, there is nothing preventing the optimal menu from containing contracts supported on coefficients greater than , even though by offering such a contract, the principal is guaranteed to lose utility. Even barring placing mass beyond , it could still be the case that some breakpoints themselves are greater than ; these would normally correspond to actions that are not reasonable to incentivize with a single contract (they have negative net welfare for the principal and agent combined). Is it ever useful to incentivize these actions when offering a menu of randomized linear contracts?
Interestingly, the answer is (again) yes. We say that a randomized linear contract is bounded if always chooses a transfer coefficients bounded above by . Otherwise we say a randomized linear contract is unbounded. In the example below, we show that a menu of unbounded randomized linear contracts can extract strictly larger revenue for the principal than a menu of bounded randomized linear contracts.
Lemma 4.3.
There exists a principal-agent problem with types and actions such that the profit obtained by the optimal menu of bounded randomized linear contracts is strictly smaller than the revenue achieved by the optimal menu of unbounded randomized linear contracts.
We provide the instance below but defer the full proof to the appendix.
Proof Sketch.
Since we are only concerned with linear contracts, it suffices to specify the utility functions . In fact it suffices to specify the derivatives (since we always have that ).
We specify the slopes below:
We show (computationally) that in the above instance, there exists a menu of unbounded randomized linear contracts which extracts a revenue strictly greater than . On the other hand, the optimal menu of bounded randomized linear contracts extracts a revenue less than . ∎
4.2 Computing the optimal menu of randomized linear contracts
We now switch our focus to the computational problem of efficiently computing the optimal menu of randomized linear contracts. Ultimately, we will show that we can find this optimal menu by solving a concise (polynomially-sized) linear program.
We begin by writing out a much larger program in terms of the variables (where recall that each encodes a distribution over the positive reals via its pdf). The optimal menu will satisfy the following mathematical program:
(Rev) | ||||
(Prob) | ||||
(IC) | ||||
The first constraint simply states that each is a probability distribution. Equation IC is the incentive compatibility constraint which enforces type that will choose the contract . Finally, the objective (Equation Rev) maximizes the expected revenue for the principal over all possible menus of randomized linear contracts.
In the following theorem, we show how to rewrite this program as a concise linear program (relying heavily on our characterization in Lemma 4.2 of the support of these distributions).
Theorem 4.4.
Given an instance principal agent problem with types and actions per type with break points , we can compute a menu which achieves the optimal revenue in time that is polynomial in where denotes the bit-complexity of the probability matrix.
Proof.
We can write a linear program which computes the optimal menu by essentially solving the mathematical program described above. Using Lemma 4.2, we know that each randomized linear contract will only put mass on the breakpoints and one additional point above the last break point. One difficulty is that we don’t know the value (or even have a bound on) the final break point To get around this, we instead track the variables and (i.e., the total mass above and the average coefficient).
We can therefore represent each menu as a vector where denotes the probability of selecting a contract with transfer coefficient when . denotes the probability of choosing a point higher than the breakpoints. Rewriting the original mathematical program using the above simplification, we get the following linear program:
(Primal) | |||||
Furthermore, any solution the above linear program can be converted to an optimal menu with the same objective value. Simply let and denotes the probability that the contract for type plays the transfer coefficient The resulting menu satisfies the original mathematical program and has the same revenue as the objective. ∎
One corollary of this proof is that it implies an upper bound on the maximum transfer coefficient (although not a particularly strong one).
Corollary 4.5.
There is an upper bound which is polynomial in the size of the such that the optimal menu will use a transfer coefficient whose size is at most .
Proof.
Since and are both variables in the linear program, we know that their size is bounded by Finally, the breakpoint is a ratio of these quantities and therefore is also bounded by ∎
Although we know that the largest transfer is bounded in bit complexity and can be computed in polynomial time, it remains an open question how powerful these menus of bounded randomized linear contracts really are.
Open Question: What is the gap in revenue between a menu of bounded randomized linear contracts when compared to menus of unbounded randomized linear contracts? What is the best upper bound on the value of the largest transfer coefficient in the support of any contract?
4.3 Upper bounds for menus of randomized linear contracts
While Theorem 4.7 demonstrates a super-constant gap between linear contracts and menus of randomized linear contracts, the instance in the proof require both the number of actions and the number of types to grow without bound. It is natural to ask how this gap depends on each of these parameters – the number of actions and the number of types – individually. For example:
Open Question: What is the dependence on the gap between randomized linear contracts and single linear contracts as a function of the number of actions (keeping the number of types fixed)? As a function of the number of types (keeping the number of actions fixed)?
We do not answer this question in generality – however, interestingly, we show that in the special case where the number of actions is fixed to (one of the simplest non-trivial cases of the above question), the gap is bounded by a (universal) constant.
Theorem 4.6.
Suppose we have a principal-agent problem with actions (a null action and a non-null action). Then linear contracts can extract a constant fraction of the profit that randomized menus of linear contracts can:
Proof Sketch.
We bucket the types by the breakpoint of that shifts the agent to taking its non-null action. If a linear contract does not do well, then these breakpoints must be somewhat spread out. We then argue about the performance of a menu of randomized linear contracts; if it extracts a lot of profit from a type with high breakpoint then that menu item gives a lot of utility to a type with low breakpoint. If it repeatedly extracts a lot of profit over varied breakpoints, then eventually it must be playing breakpoints with greater than one probability, which is a contradiction.
4.4 Lower bound for menus of randomized linear contracts
We will now establish a lower bound on the gap in power between single linear contracts and menus of randomized linear contracts. Specifically, we will exhibit a family of instances with types and actions per type where this gap is at least . Note that since this gap is bounded above by (by simply choosing the best linear contract for one of the agents; see Lemma A.8), this lower bound is asymptotically tight in . We provide this construction in the following theorem.
Theorem 4.7.
There is a principal-agent problem with agent types and actions per agent, for which the optimal menu of randomized linear contracts can extract times as much profit as the optimal single linear contract:
Proof.
Since we are only concerned with benchmarks that pertain to linear menus, to specify a typed principal-agent problem it suffices to specify the utility function for each agent and the distribution over types (which we will take to be uniform). Since we want each agent to have at most actions, each function must be a convex, increasing piecewise linear function with at most pieces. In our construction, all such functions will share the same breakpoints, which we label in increasing order. We will set , where . For notational convenience, we’ll let and .
For simplicity, it will be easier to work with the derivatives of ; note that since for each type , each is completely specified by via the relation . Each is an increasing piecewise constant function with the same breakpoints as the functions. We will construct them from the following pieces: for each , define to be the piecewise constant function defined to equal
for and otherwise. (Note: the second equality above is slightly inaccurate in the case where , where the RHS should instead equal ; this will not affect any of the calculations that follow).
We now construct the functions as follows. Each will be a slight “perturbation” of the sum of all the functions ; in particular, we have that
(3) |
Note that each such function is indeed increasing (since , ) so these specify valid utility functions. One useful way of thinking about this example is that we divide our actions into two blocks of approximately actions each. In , each action corresponds to a linear piece with a fixed height of (since is independent of ), except for four of these actions, which have heights that are times larger. Moreover, these four actions are chosen symmetrically; two consecutive actions from the first block of actions, and their “mirror image” from the second block of actions.
To prove a lower bound on the gap provided by this instance, we will begin by proposing a menu of randomized linear contracts, and show that each type is incentivized to choose a specific contract from this menu. Recall that denotes the randomized linear contract that type will choose from the menu. We will let be the uniform distribution of support size that places of its weight on the point and the other of its weight on the point .
We now compute the utility achieved by this type (and other types) who receive this contract. To begin, note that
In particular, this means that
or in other words, the total contribution to each agent’s utility from the term in (3) is independent of the contract they select. It thus suffices to only consider the latter four terms of (3).
Now, if the type agent selects contract , they receive an extra utility in expectation: when they draw the contract, they receive extra utility, and when they draw the contract, they receive extra utility. On the other hand, if the type agent selects contract for any , we claim they only receive an extra utility in expectation. Specifically, if , then they are guaranteed to receive utility from the first two terms of (3) but never receive any utility from the second two terms of (3) (regardless of which contract they draw). Similarly, if , then they receive no extra utility when they draw the contract, but receive utility (from all four terms of (3)) when they draw the contract. This shows it is strictly dominant for an agent of type to select the contract .
We now wish to examine the profit received by both i. this menu of randomized linear contracts and ii. the optimal single linear contract and show that the gap between these two values is indeed . We begin with the profit obtained by this menu. Recall that the profit obtained by offering a linear contract to an agent of type is equal to . Now, note that (for any ) that
(4) |
So, the expected profit obtained by offering contract to type is given by
The total profit from this menu is therefore . On the other hand, if we offer a single linear contract to all types, we receive profit
But now, by (3), note that
But now, is maximized at one of the , where by (4) it is at most . It follows that , and therefore that .
∎
As a corollary of Theorem 4.7, we can show the same gap between menus of deterministic general contracts (Opt-DetMenu) and menus of randomized general contracts (Opt-RndMenu).
Corollary 4.8.
There is a principal-agent problem with agent types and actions per agent, for which the optimal menu of randomized (general) contracts can extract times as much profit as the optimal single (general) contract:
References
- Alon et al. (2021) T. Alon, P. Dütting, and I. Talgam-Cohen. Contracts with private cost per unit-of-effort. In Proceedings of the 22nd ACM Conference on Economics and Computation, pages 52–69, 2021.
- Briest et al. (2010) P. Briest, S. Chawla, R. Kleinberg, and S. M. Weinberg. Pricing randomized allocations. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pages 585–597. SIAM, 2010.
- Castiglioni et al. (2021) M. Castiglioni, A. Marchesi, and N. Gatti. Bayesian agency: Linear versus tractable contracts. In Proceedings of the 22nd ACM Conference on Economics and Computation, pages 285–286, 2021.
- Castiglioni et al. (2022) M. Castiglioni, A. Marchesi, and N. Gatti. Designing menus of contracts efficiently: The power of randomization. In Proceedings of the 23rd ACM Conference on Economics and Computation, pages 705–735, 2022.
- Cohen et al. (2022) A. Cohen, A. Deligkas, and M. Koren. Learning approximately optimal contracts. In Algorithmic Game Theory: 15th International Symposium, SAGT 2022, Colchester, UK, September 12–15, 2022, Proceedings, pages 331–346. Springer, 2022.
- Dütting et al. (2019) P. Dütting, T. Roughgarden, and I. Talgam-Cohen. Simple versus optimal contracts. In Proceedings of the 20th ACM Conference on Economics and Computation, pages 369–387, 2019.
- Dütting et al. (2020) P. Dütting, T. Roughgarden, and I. Talgam-Cohen. The complexity of contracts. In SODA, pages 2688–2707, 2020.
- Dütting et al. (2021) P. Dütting, T. Ezra, M. Feldman, and T. Kesselheim. Combinatorial contracts. In FOCS, pages 815–826, 2021.
- Gan et al. (2022) J. Gan, M. Han, J. Wu, and H. Xu. Optimal coordination in generalized principal-agent problems: A revisit and extensions. arXiv preprint arXiv:2209.01146, 2022.
- Grossman and Hart (1983) S. J. Grossman and O. D. Hart. An analysis of the principal-agent problem. Econometrica, 51:7–45, 1983.
- Guruganesh et al. (2021) G. Guruganesh, J. Schneider, and J. R. Wang. Contracts under moral hazard and adverse selection. In Proceedings of the 22nd ACM Conference on Economics and Computation, pages 563–582, 2021.
- Holmström (1979) B. Holmström. Moral hazard and observability. Bell J. Econ., 10:74–91, 1979.
Appendix A Omitted proofs
A.1 Proof of Theorem 3.1
Here we provide the detailed proof of Theorem 3.1 (that there exists an gap between single contracts and menus of deterministic contracts). We begin by establishing some lemmas.
Lemma A.1.
Consider the principal-agent problem defined in the above -gap instance. For any contract that has non-negative profit, it must hold that .
Proof.
First, note that for type agent, only first actions can generate strict positive welfare, and the welfare of action is , and hence the maximum welfare of type agent is generated by action . For type agent, only actions can generated strict positive welfare, and the welfare of action for is , and hence the maximum welfare of type agent is which is generated from action . Therefore, the maximum possible profits a contract can get from type agent and type agent are and respectively.
Notice that regardless of which action type agent plays, the result is always outcome which has zero reward, and thus, the contract pays type agent for nothing in return.
Therefore, the profit in expectation over agent types of the contract is at most , and for this to be non-negative, it must hold that
∎
Because of Lemma A.1, we henceforth only consider contract with for the -gap instance. As a consequence, if an action only results in outcome for a type of agent, then the resulting payment to that agent is at most , which is strictly less than the cost of any action . In the construction of -gap instance, we mentioned that outcome always occurs when type agent plays the last actions and when type agent plays the first actions and when type agent plays any action. Thus, we can henceforth assume that type agent never plays actions , and type agent never plays actions , and type agent never plays actions .
Lemma A.2.
Consider the principal-agent problem defined in the above -gap instance. For any contract with non-negative profit, we have
(5) |
Proof.
Consider any contract . First, since for all , type agent’s utility and the principal’s profit from type agent are both independent of , and thus, we can ignore outcome 1 and assume without loss of generality.
Moreover, since is the same for all , the expected payment type agent gets from outcome 2 is times a constant regardless of which non-null action type agent plays. Hence, among all non-null actions (also note that action is always no worse than the null action for type agent), type agent prefers the non-null action that maximizes the expected payment for outcome 3 minus the cost of the action, i.e., .
Note that does not depend on at all. Thus, type agent will still prefers the same action when faced with contract instead of . Therefore, it remains to prove that the profit which contract gets from type agent is at most (which implies that the profit of contract is at most ).
Henceforth, we further assume that
(6) |
i.e., we ignore action without loss of generality, because if type agent prefers action , then it generates zero reward and hence zero profit for the principal. Next, we show that for any , the principal’s profit from type agent is at most when type agent plays .
We first prove a necessary condition for type agent to play action for : If type agent prefers playing action , then it must hold that .
To this end, note that if type agent prefers playing action , then in particular, type agent prefers action over , which by Eq. (6) implies that
After rearrangement, this is equivalent to
() | ||||
(By Lemma A.1) | ||||
(By definition of ) | ||||
If , type agent plays action , which generates welfare , and obviously, the principal’s profit from type agent cannot exceed this. Hence, we consider the case when type agent plays action for . In this case, as we have shown, the necessary condition for type agent to prefer action is . The principal’s profit from type agent is at most , which is at most . ∎
Lemma A.3.
Consider the principal-agent problem defined in the above -gap instance. For any contract with non-negative profit, we have
(7) |
Proof.
Consider any contract . Since for all , type agent’s utility and the principal’s profit from type agent are both independent of , and thus, we can ignore outcome 3 and assume without loss of generality. Also, notice that outcome and have zero reward and hence do not contribute to the principal’s profit.
Given contract , let be the action that type agent prefers. Without loss of generality, we assume that is not the null action or action (because otherwise Eq. (7) holds trivially). Notice that the welfare generated by action is , which is equal to by definition of , and we define such that . Hence, our goal is to upper bound . Without loss of generality, we also assume that (because the welfare generated by action is , and the principal’s profit from type agent cannot exceed this).
Since type agent plays action given contract , we have that . Since by definition of , it follows that
(8) |
Now we derive the utility generated by any action for type 1 agent (denoted by ):
(By definition of ) | |||||
(By definition of ) | |||||
(9) |
Using Eq. (9), we calculate the the utility generated by action for type 1 agent:
(By Eq. (9)) | ||||
and we lower bound the the utility generated by action for type 1 agent:
(By Eq. (9)) | ||||
(By definition of ) | ||||
( as ) | ||||
() | ||||
() | ||||
Recall that is type agent’s favorite action, and hence, for type agent,
which implies that . After rearrangement, this is equivalent to
() | ||||
∎
Lemma A.4.
Consider the principal-agent problem defined in the above -gap instance. For any contract with for any , if there is an action that generates non-negative utility for type agent, then it must hold that
(10) |
Proof.
Consider any contract with with . The utility of action for type agent is . For this to be non-negative, it must hold that
(By definition of ) | ||||
(By definition of ) | ||||
( and for ) | ||||
It remains to prove that . To this end, note that for and , and we derive that
(By ) | ||||
∎
We can now proceed to prove the main theorem.
Proof of Theorem 3.1.
Soundness. We prove that any single contract can only get total profit at most from first two types of agents (recall type agent generates zero reward). By Lemma A.2, contract can only get profit at most from type agent. By Lemma A.3, if , then contract can only get profit at most from type agent, and thus, the total profit from two types of agents is at most .
Therefore, it remains to analyze the case for . In this case, we can without loss of generality assume that type agent prefers an action , because otherwise type agent prefers either the null action (which generates zero profit) or action (which generates welfare and hence at most profit). Since type agent prefers action over the null action, action must have non-negative utility, and it follows by Lemma 10 that Ineq. (10) holds. Combining Ineq. (5) in Lemma A.2 with Ineq. (10), we have that
(By definition of ) | ||||
On the other hand, by Lemma A.3, we have that
Hence, the total profit of contract from first two types of agents is at most in this case.
Completeness. We show a menu of two contracts that gets total profit from first two types of agents and zero profit from type agent. The two contracts are and . First, it is easy to check that given contract , every action among has zero utility for type agent (i.e., for all ), and given contract , none of the actions can make strictly positive utility for type agent. Thus, we can assume that type agent chooses contract and plays action , and then the principal’s profit from type agent is .
On the other hand, type agent will get utility by choosing contract and playing action . Moreover, if choosing contract , type agent will get utility for action , which is at most . Thus, we can assume that type agent chooses contract , and then the principal’s profit from type agent is non-negative, because for any outcome, contract does not pay more than its reward. It follows that the total profit from two types of agents is at least .
Finally, recall that regardless of which action type agent plays, the result is always outcome . Since the payment for outcome is zero for both contracts , the profit from type agent is zero. ∎
A.2 Proof of Theorem 3.2
Here we provide the detailed proof of Theorem 3.2 (that there exists an gap between single contracts and menus of deterministic contracts).
Lemma A.5.
Consider the principal-agent problem defined in the above -gap instance. For any contract that has non-negative profit, it must hold that .
Proof.
Note that only outcome 1 has strictly positive reward, and only action can result in outcome 1. Hence, the welfare of type agent is for all and , and the principal’s profit from this type of agent is at most this amount.
Moreover, observe that type agent can only result in outcome regardless of which action is played. Thus, contract pays type agent for nothing in return.
Altogether, the profit of contract in expectation over agent types is at most
and for this to be non-negative, it must hold that . ∎
Lemma A.6.
Consider the principal-agent problem defined in the above -gap instance. For any , for any contract with , we have
(11) |
Proof.
Note that only outcome 1 has strictly positive reward, and only action can result in outcome 1. Moreover, since for all , outcome 1 happens with probability at most regardless of the contract and the agent type. Thus, contract gets profit at most (which in turn is at most by our assumption) regardless of the agent type. It follows that
∎
Lemma A.7.
Consider the principal-agent problem defined in the above -gap instance. For any , given any contract with that has non-negative profit, we have
Proof.
Consider any such that type agent prefers playing action given contract . First, since type agent prefers action over the null action, action must have non-negative utility. Because for type agent, action 1 only has strictly positive probability for outcomes , and , it follows that . After rearrangement, this is equivalent to
(By Lemma A.5 and ) | |||||
(By definition of and ) | |||||
( for ) | |||||
(By assumption ) | |||||
(12) |
Moreover, since type agent prefers action over action , action must have higher utility than action . Namely, (recall ). After rearrangement, this is equivalent to
(By Lemma A.5 and ) | |||||
(By definition of ) | |||||
(13) |
where the final step follows from the second to the last steps of the derivation of Ineq. (A.2).
Notice that Ineq. (A.2) gives a new lower bound of for all , which is twice as large as the lower bound given by Ineq. (A.2). Using this larger lower bound, we can repeat the above derivation of Ineq. (A.2) (i.e., we use the larger lower bound instead in the third inequality of the derivation) and double the lower bound again. By repeating such derivation arbitrarily many times, we have that for all is arbitrarily large, and thus, contract makes arbitrarily large payment to each type of agent in . Therefore, contract must have strictly negative profit (because the reward generated by any type of agent is always bounded), which contradicts our assumption in the lemma statement. ∎
Proof of Theorem 3.2.
Soundness. We show that any contract with non-negative profit at most has expected profit (the expectation is over the distribution of agent type). Let be such that . Now we upper bound the expected profit of contract as follows:
expected profit | ||||
(15) |
Moreover, because only action can generate strictly positive reward, we have that
(16) |
Combining Ineq. (A.2) and Ineq. (A.2), we get that the expected profit of contract is at most .
Completeness. We show that there is a menu of contracts that achieve expected profit . Specifically, for each and , is defined as follows: let , and let if , and let the other entries be zero.
Because all the contracts in the menu make zero payment for outcome , and type agent can only result in outcome which has zero reward, we can ignore type agent.
Now we show that given the above menu, for all and , type agent wants to pick contract and play action . First, it is easy to check that for type agent, given contract , action generates zero utility, and action generates utility
(17) |
which is strictly positive. Thus, it remains to show that by picking any other contract , type agent cannot get more than the utility in Eq. (17). To this end, we notice that given contract , type agent would get the following utilities by playing action and action respectively:
utility of action | |||
utility of action |
Finally, we derive the expected profit of the above menu (given that we have shown type agent picks contract and plays action ) as follows:
expected profit | |||
∎
A.3 Bounding the gap between linear contracts and menus of randomized linear contracts
Lemma A.8.
The optimal linear contract achieves a approximation with respect to the optimal menu of randomized linear contracts. In particular,
Proof.
For each type, we can compute the best linear contract. This contract generates at least as much revenue as any component of the randomized linear contract. Hence, we can extract at least an fraction of the optimal revenue. ∎
A.4 Proof of Lemma 4.2
Proof of Lemma 4.2.
Given any optimal menu , we will construct a new menu which satisfies the above constraints and whose revenue is at least as large as . In particular, we will demonstrate how to redistribute probability mass not supported on one of these points to these points while leaving the performance of the menu unchanged.
For any point that is not a break point, we can write as a convex combination of two adjacent breakpoints. Now we simply increment by and by. Since we are simply moving the mass at a given point to its two neighbors, and all utility functions are linear in between any pair of consecutive breakpoints, the utility of each agent for each randomized linear contract in the menu remains the same (and hence each agent still selects the same contract from the menu and plays the same action).
The profit obtained by the principal by offering linear contract to the agent of type is given by (when taking the derivative, we arbitrarily break ties in the favor of the principal). Since , we note that the revenue achieved by the new menu is at least what is achieved by .
It remains to deal with the probability mass above . Define the point
whenever the . By definition, . We will set . Since we are simply contracting the mass in this last interval , the resulting distribution is still a probability distribution. Furthermore,
for any linear function . Again, since (for this range of ) all utilities for each agent (and the principal’s profit) are linear functions of , they are preserved under the new contract .
∎
A.5 Proof of Lemma 4.3
Proof of Lemma 4.3.
Recall that the breakpoints in the instance are multiples of , i.e. for First, we exhibit a menu whose revenue is large . Consider the menu
The first menu item extracts a revenue of and the second extracts a revenue of to get a total revenue of .
To show that no bounded randomized linear contract cannot get a fractional value of greater than , we exhibit a dual solution to the dual of linear program presented in Section 4.
We derived this dual by restricting the breakpoints to just . Hence any feasible dual solution is an upper bound on menus of bounded randomized linear contracts. In particular, assigning values , , and achieves an objective of approximately . ∎
A.6 Proof of Corollary 4.8
Proof of Corollary 4.8.
Note that the example in Theorem 4.7 only has one non-null outcome. We first claim that for such instances, every general contract is equivalent to an affine contract: a contract that transfers times the principal’s reward plus an additive (in particular, a transfer of on the null outcome and on the non-null outcome is equivalent to the affine contract with and ).
Because of this, the best menu of randomized (general) contracts performs equally as well as the best menu of randomized affine contracts. Since all linear contracts are affine, this menu performs at least as well as the best menu of randomized linear contracts. We thus have that
A.7 Proof of Theorem 4.6
Proof of Theorem 4.6.
Consider any with actions (a null action and a non-null action ), agent types, and outcomes. For each agent type , we let denote the utility function for type- agent given linear contract (i.e., pay for each outcome ) as input variable. Notice that (i.e., the best of the utilities of actions and ). We let . Then, the utility function can be simplified as . For each agent type , we let denote the minimum linear contract for which type- agent would like to play action , i.e., .
Bucketizing the agent types
Let (any constant larger than would work) and and . Now we bucketize the agent types into buckets according to their , and is chosen such that . The -th bucket contains every agent type such that . Now consider two principal-agent problem instances by modifying the instance :
-
•
Odd instance : Remove every agent type that belongs to a bucket with even index. Add a dummy agent type (which always results into the dummy outcome with zero reward) such that its probability is the sum of the probabilities of the removed agent types.
-
•
Even instance : Same as above except that we now remove the agent types in the buckets with odd indices.
Obviously , and
Assume that without loss of generality. Then, we have that
Henceforth, it suffices to show . In the principal-agent problem , if two agent types belong to two different buckets (say for ), then because must be odd. It follows that by definition of the buckets.
Choosing one agent type from each bucket
Notice that for each bucket , linear contract can extract -fraction of the welfare of any agent type . Indeed, for any , we have , and hence type- agent would play action and generates a profit for the principal, which is fraction of type- agent’s welfare.
Suppose the optimal linear contract only achieves expected profit for . Then the expected welfare of bucket (i.e., ) for any odd is at most , because we have shown there is a linear contract that extracts -fraction of the welfare of any agent type . Moreover, suppose the optimal menu of randomized linear contracts extracts fraction of the expected welfare of bucket . Then the expected profit of is at most . Since is a constant, it suffices to prove .
Moreover, since extracts fraction of the expected welfare of bucket , there should be at least one agent type in from which extracts at least fraction of the welfare. We choose one such agent type for each bucket with odd .
Summarizing what we have done so far, we have chosen agent types, which we denote by (ordered s.t. is non-decreasing in ), such that
-
•
for each (recall this follows from picking the odd instance),
-
•
and menu extracts certain fraction of the welfare of the type- agent for each , such that (this is by our choice of the agent types),
and our final step is to show , which implies .
Proving that
Let denote the CDF of type- agent’s favorite randomized linear contract for each (we will also use to refer to type- agent’s favorite randomized linear contract). Then, we have that
where the integrals start from because is the minimum for which type- agent would like to play action . Note that the LHS of the first equation is just by definition, and we let denote the LHS of the second equation (observe that ). Without loss of generality, we assume that for all , because otherwise we can first remove all the agent types with and then prove for the remaining agent types (which obviously implies ).
Now we establish a lower bound for . Because type- agent prefers over , we have that
where we denote the RHS by . Thus we can prove a lower bound for instead. To this end, we derive that
(By ) | ||||
(By ) | ||||
Therefore, we have shown that . Taking a telescoping sum, we have that . It follows that because and , and is a constant. ∎