Estimating Auction Equilibria using Individual Evolutionary Learning

Estimating Auction Equilibria using Individual Evolutionary Learning by Kevin James I develop the Generalized Evolutionary Nash Equilibrium Estimator (GENEE) library . The tool is designed to provide a generic computational library for running genetic algorithms and individual evolutionary learning in economic decision-making environments. Most importantly, I have adapted the library to estimate equilibria bidding functions in auctions. I show it produces highly accurate estimates across a large class of auction environments with known solutions. I then apply GENEE to estimate the equilibria of two additional auctions with no known solutions: first-price sealed-bid common value auctions with multiple signals, and simultaneous first-price auctions with subadditive values. The library is available for download at https://github.com/kajames2/biddingga


Introduction
Auctions are heavily studied, by both economists, and more recently, computer scientists. This is because they relied upon to aid the allocation of resources in the most efficient manner, whether it be a knick-knack on eBay, Ad space on Google, or electromagnetic spectrum from the FCC. However, there are still many open questions without any theoretical solutions.
Consider this simple auction: the first-price sealed-bid. In it, every bidder privately submits a bid for the item, and the one who bids the highest gets it for that price. How should someone bid in such an auction? If we assume all the bidders have the same properties (risk aversion, valuation of the item, etc), the solution is well-known [33]. However, once we allow for some eminently reasonable heterogeneity among the bidders, much of auction theory falls apart, and only special cases are known with certainty. The rest have no known solution, only having some proofs of general properties and constraints on how one should bid.
Once we expand our search to other auctions, things are even bleaker. There is very little known beyond the simplest case for a common value auction, where the item has an identical value to all bidders, but each bidder has a different estimate for that underlying value. And whenever there are multiple items, there are no exact theoretical predictions except for very special conditions. This matters, because often, poorly understood auctions are still viewed as the best mechanism for selling a good, and so we observe scenarios where auctions with significant financial stakes have had unexpected results.
New Zealand fell into precisely such a trap in 1990 [28]. The government was looking to sell mostly identical licenses for spectrum, and not knowing how much to charge for them, decided to hold an auction. The consulting firm suggested a simultaneous second-price sealed-bid auction. They placed all the spectrum licenses up for sale simultaneously, and had everyone submit a private bid on as many licenses as they wanted. Afterwards, the highest bidder wins the license and pays the secondhighest bidder's price. While this auction type is well understood in the case of a single item, this simultaneous design is not. The government projected they would raise $250 million in revenue, but ultimately only received $36 million. For one item, the highest bid was $100k, and the second highest-the price for which the highest bidder had to pay-was $6. For another license, the highest bid $7 million, and the second highest was just $5000. Because the bids were posted to the public after the auction, the government was publicly humiliated for only collecting about 15% of the projected revenue. They then switched to a first-price sealed-bid auction, which worked better, but had other challenges.
So understandably, if the real-world is demanding these more complicated auctions, we would prefer to gain as much insight into how they work and how bidders will operate them prior to actually putting them into practice. Outside the limited theory available, laboratory experiments are the primary tool to analyze these complex auctions. Indeed, they have proven themselves invaluable in aiding development of the FCC's 1994 spectrum auction [25]. However, while much cheaper than the real auctions, experiments still require significant time and resources, and given the sheer number of possible permutations of both auction designs and environmental parameters, prior information that can guide the research agenda is highly sought after. Computational modeling can provide this, but no generalized tool exists.
There are several routes that show promise towards providing insights into nash equilbrium auction bidding behavior 1 , and I ultimately decided to use Individual Evolutionary Learning (IEL). IEL was first introduced by Arifovic and Ledyard in 2003 [3]. It is an multi-agent extension of the more common Genetic Algorithm (GA). Genetic Algorithms have been shown to have good convergence properties in economics, even in environments where naive best-response algorithms diverge and the equilibrium is unstable [2]. They have also been shown to be effective with finding global optima even in large decision spaces [32]. In 2017, French [16] created a proof-of-concept program that used an IEL to successfully find the equilibrium bidding strategy in a specific auction domain. Although it was limited to linear profit 1 I compare some of these techniques in more detail in chapter 3 functions and not designed around performance, it had several critical innovations that can serve as the foundation of a more generalized tool.
The goal then, is to create a computation library that applies Individual Evolutionary Learning to estimate the equilibrium bid function in a wider variety of auctions and settings that have previously been achievable. Within an auction, the library should support asymmetries between players in the form of risk aversion, subjective probabilities, value draw distributions, and budgetary constraints. For auction types, the program should match the theoretical solutions to the symmetric forms for the first-price, second-price, all-pay, and single-signal common value auctions. Furthermore, it should provide clear and consistent results for unsolved auctions, including multiple-signal common value auctions and simultaneous sealed-bid auctions. The GENEE library satisfies these requirements.
The library has multiple potential uses. The primary use-and focus of the dissertation-is to make predictions of human behavior in complex auctions. A direct byproduct of this is that the library will also yield estimates for the efficiency of an auction, the profits of each bidder, and the revenue raised for the auctioneer. This can aid auction designers in evaluating mechanisms in different environments and in the creation of experimental testbeds that stress the design.
A second use of the library is in the evaluation of human learning in laboratory ex-

periments. Arifovic and Ledyard have successfully leveraged Individual Evolutionary
Learning to estimate convergence to equilibria in complex laboratory experiments [4].
In addition, they have found that for large decision spaces with many variables, IEL outperforms other learning models [5]. There have been recent experiments that have subjects submit full bidding functions, rather than just a single bid given a randomly drawn value [11], [23]. These align with the inputs of the GENEE library, allowing it to provide both predictions and post-experiment analysis on how subjects learn relative to the IEL.
A third use of the library is to estimate econometric structural models from data.
Because the model is tolerant to significant asymmetries, one can use observed bidding data in repeated auctions, such as Google AdSense auctions, and estimate underlying features of participants-like risk aversion-by determining which parameters result in equilibrium behavior nearest to the observed data.
A final usage for the GENEE library is to help bidders taking part in an auction. A bidder can encode their assumptions for competing bidders and their own preferences, and the program will output the equilibrium behavior. Bidders and even ascribe offequilibrium behavior to competitors and calculate their optimal bidding strategy in response to such play. This level of flexibility gives the program value that cannot be found in any other tool.
The dissertation is organized in the following manner. Chapter 2 describes the evolutionary model library. Individual Evolutionary Learning models have a niche in economics research, and no generalized library exists. While a basic version is relatively simple, there are numerous optimizations and extensions that can be added to increase performance and convergence. I compile these features into a highperformance, flexible library. This not only provides a base for auction bidding model, but also contributes to the field by lowering the programming burden of future models.
Chapter 3 details the core of the GENEE auction model. It covers the numerical library that performs the necessary statistics, as well as how bidding strategies are represented and evaluated. Beginning with the representation used in French, I create a new design leveraging domain knowledge to improve convergence speed and precision. The library also takes a more general approach than prior attempts when evaluating auctions. This allows it to work on a much larger set of auctions than previously achievable. Taken together, my model increases performance-and thus practically achievable precision-by several orders of magnitude and turns a proof of concept into a practical application. After detailing the core model, I then analyze its output for auctions with known solutions.
Chapter 4 extends the library to work with 2-item auctions. It is then used to evaluate simultaneous first-price auctions with subadditive values. This environment lacks a theoretical solution, as New Zealand learned after switching to it when the simultaneous second-price auction failed.
Chapter 5 applies the model to a common value auction with signals. The common value auction is most frequently used to model the purchase of mineral rights. In it, it is assumed that all participants have the same value for an object up for auction,

Genetic Algorithms
GAs are a learning technique originally developed to mimic biological evolution [18].
In a GA, there is a set of strategies, called a population. Each strategy is a potential solution to the problem being solved. For example, if the problem is to find the x that maximizes some function f (x), then a strategy could be a single real number, or anything that could be converted into a real number, such as a binary array. Each iteration, the strategies in the population are evaluated, modified, and culled, akin to population dynamics in nature where random mutations among members of a population are removed or promoted in future generations based upon their fitness (performance) in the environment. In a static environment, the best strategy in the population will eventually converge to the global optimum 1 [31].
Both genetic algorithms and the related evolutionary algorithms have mostly found use as a general optimization technique. Although not considered the most efficient, they rely on very little domain knowledge and can find good results in large strategy spaces [32]. This makes them a common choice for non-linear global optimization when more specialized techniques cannot be used. Eiben and Smith's [13]. It conforms with what is found in Arifovic [2], but with one stage being formalized and generalized. The next sections detail the implementation.

Representation
Strategies in genetic algorithms can take any form, but some are better suited to certain domains than others. Genetic Algorithms only require that the strategy can be mutated and evaluated. The most common representations are binary arrays, real-values, and orderings (e.g. [1,4,2,3], signifying an order of events). While my implementation has hooks for any type of representation, only the binary representation has been implemented, as that is the only one needed for this research.

Parent Selection
Each iteration of the algorithm requires parents to be selected. Parents are paired up, and a pair of children are created based off the parents. The number of parents selected is therefore equal to the number of children creates, which is a hyperparameter, often set to the same size as the initial population. Strategies are selected to be parents stochastically, with probability dependent on the fitness of each strategy in relation to the fitnesses the other strategies in the population. There are many popular selection techniques. They are covered in detail in a few sections.

Crossover
After a pair of parents have been selected, the child creation algorithm is run. The first step is to create two new strategies that contain features from each parent. For binary array strategies, I keep to the most common technique, one-point crossover.

Repeat N times
First, the population is initialized. Each iteration, parents are selected, paired up, and an algorithm creates child strategies with characteristics from both parents (Crossover) as well as some random component (Mutation). Then, these created children are pooled back in with the population, and the Survival stage culls the pooled population so that only there are only as many strategies as there were at the beginning of the iteration. Either one or both of the selection stages (Parent Selection and Survival Selection) will favor strategies with higher fitness in the environment. This iterative process is repeated for some number of iterations.   First, an index is selected at random. Two children are created by taking the bits of the first (second) parent from beginning to the selected index, and then the bits of the second (first) parent for the remainder.
Let each parent strategy, p 1 and p 2 be n bits in length, and let p j i be the jth bit in the strategy. In one-point crossover, an index k is chosen at random between 1 and n, and the two children, c 1 and c 2 are defined by: This cuts each parent into two pieces and swaps the second part, as seen in  Indices are selected at random, each with a probability p mut of being selected. Those bits are flipped to created altered children.

Mutation
After the children are created via crossover, they are each mutated. For binary representation, mutation occurs by iterating through each bit, and flipping the bit (0→1, or 1→0) with probability equal to the mutation rate, p mut . The mutation rate must be tuned so that small changes of only a single bit can occur, as well as larger mutations requiring multiple bit flips. This also must be changed based upon the number of bits in the array. To simplify the parameter, I implement mutation by drawing from a Poisson distribution with mean, µ mut , and then flipping that many bits at random in the strategy. This is equivalent to the iterative approach for large bit lengths, but requires fewer computations and is an easier parameter to interpret and set.

Survival
After the children have been generated, the original population and the children are pooled together. A selection process similar to Parent Selection occurs to bring the population back down in size to that of the original population, as seen in Figure 2.5.
Just like with Parent Selection, some strategies may be chosen more than once. The next section covers the different selection operators implemented during the Parent Selection and Survival stages.

Roulette Selection
Roulette selection assigns a weight, w to each strategy s. The weight is determined by the weight function,  During Survival, the children are added to the rest of the population. In this case, the 2 generated children are added in with the original 3 strategies. Of these, a number equal to the original population size are chosen. While this selection typically favors higher fitness strategies, it does not just pick the highest. Also note that a strategy can be selected multiple times.
where f s is the fitness of the strategy, and f is the vector of all fitnesses in the population. Given the weights, a virtual roulette wheel is constructed with each strategy occupying an arc in proportion to its weight. The strategies are then selected by spinning the wheel N times and taking the strategies landed on. This is the same as selecting weighted random numbers with weights: There are several commonly used weight functions. I will describe them in turn.

Simple Roulette
Here, the weight is simply equal to the fitness of the strategy: which reduces the probability of selection to: While this is straightforward, it suffers two deficiencies. The first is that it breaks with negative fitnesses, as they would be assigned an unfeasible negative probability of being chosen. This is easily handled by shifting fitness values as described in the next method. The other problem is harder to fix. The selective pressure is weak near the optimal unless the gradient around the optimal is large. The fitness of nearby solutions are often within a percent of the optimal, and as such are only weakly disfavored in the selection process. This limits exploitation and slows convergence to the optimal.
Zeroed Roulette This is a simple variant of the simple roulette method, where:

Ranked Exponential Roulette
Both this and Ranked Weighted Roulette make use of ranking. Ranking entails assigning the strategy with the lowest fitness a rank of 0, 2nd lowest a rank of 1, and so forth, with the highest fitness strategy receiving a rank of n s − 1.
Ties are handled by assigning the average rank to those that tied. Using ranks creates separation in selection probability even when the fitness differences are small.
In exponential roulette, the weights are then assigned as follows: where r s is the rank of the strategy.

Ranked Weighted Roulette 2
This has a hyper-parameter, α, that tunes how selective the mechanism is. If the number of strategies is given by n, weights are defined as: When α = 0, the weights are equal for all strategies. Meanwhile, at α = 1, the weights are linear with rank (normalized by the sum of all ranks). Being able to tune how selective the mechanism is makes this very versatile and used frequently.

Tournament Selection
Tournament selection operates by choosing a tournament size, m, and then running a tournament for each strategy selection. In each tournament, m strategies are chosen, with equal probability, and the highest fitness strategy from the the subset is selected in Thunderdome fashion.
If the tournament size is one, the tournament reduces to just random selection.
Increasing the tournament size exerts stronger selective pressure, and in the limit, will only select the strongest strategy in the population.
Usually, choosing the tournament subset is done with replacement, but it is instructive to consider the case without replacement and m = 2. Here, the probability of a strategy being ultimately chosen is given by: This is the same as the Ranked Weighted Roulette with α = 1. And so we can see that Ranked Weighted Roulette can be interpreted as running a Tournament with m = 2 without replacement with probability α, and selecting a strategy at random (a tournament with m = 1) with probability 1 − α. And so, for large population sizes where the distinction between drawing with or without replacement can be safely ignored, we see that Ranked Weighted Roulette is just Tournament selection where the tournament size hyper-parameter is generalized to be a continuous variable and constrained to be no greater than two. This is a result not found anywhere in the literature and hints at a unifying selection mechanism that allows m to be any continuous number greater than one. I This selection operator exerts the same pressure on average at the Mixing Tournament Selection, it is not the same for any m. It will have more instances of strategies being selected off smaller tournaments and also more strategies being selected off larger tournaments. So in some sense, it may allow for a bit more exploration and exploitation than typically occurs in standard Tournament selection.

Age Selection
With Age Selection, the age of each strategy is incremented at the end of iteration of the GA. Newly created children strategies are assigned an initial age of zero. Selection is as simple as selecting the N newest strategies, regardless of fitness. I do not utilize this, but it is important to mention because many in the literature implicitly do.

Best Selection
This applies the strongest selective pressure of any method. The strategies are sorted by fitness, and the N with the highest fitness are selected. In practice, this tips the scale too far towards exploitation. It will find an optimum in few iterations, but it is more likely to be a local optimum.

Elitism
Elitism can be used in conjunction with another selection method. When N strategies are to be selected, elitism says to pick some number N e < N of them using Best Selection, and then pick the remaining N − N e using another selection scheme. This guarantees that the strategies with the highest fitness make it into the next population. It turns out that this feature is required to prove a genetic algorithm will converge to the optimum [31].

Survival vs. Election operator vs. Elitism Only
The survival stage is a relatively new stage in GAs and not universally used. Originally, the entire population would be replaced by the new children strategies. Then, Elitism was shown to be necessary for convergence, and so the children replaced all but the select elites from the original population.
Arifovic introduced the concept of an Election operator. In it, after two children were generated from the two parents, a Best Selection operator was used to pick the best two of the four (two children + two parents), thereby only keeping children that were superior to their parents. This is a fairly strong selection operator, whose strength depends on the parent selection operator chosen.
Survival encompasses these previous extensions and formalizes it into a new stage.
By just using Age Selection in survival and setting the number of children equal to the population size, the stage has no effect and the algorithm reduces to the canonical form. Adding Elitism to the Age Selection gives the most common algorithm, and using some other selection criteria like Tournament or Roulette will give something capturing the essence of the Election operator by not keeping a child strategy unless it is shown to be better.

Choosing Selection Operators
There is no clear consensus on which selection operators to use when. There is always a trade-off between convergence speed and not getting stuck in a local optimum. In practice, Weighted Ranked Roulette and Tournament selection have tended to be the most popular methods, and elitism is almost always employed during survival.
Based on guidelines from the literature, I set the default Parent selector to be a Weighted Ranked Roulette with α = 0.4, and the Survival selector to be the same with 5-strategy elitism. For binary strategies, the default mutation rate, µ mut , is set to 2.

Individual Evolutionary Learning
Individual Evolutionary Learning is an extension to genetic algorithms to enable multi-agent competition. It has been argued that GAs were not originally designed for function optimization [20], and are in many ways weak at doing so. Instead, they are better-suited to adapting to a shifting environment or fitness function. IEL showed the algorithm to be more accurate and likely to converge [5] in large state spaces than other learning algorithms like Reinforcement Learning [14] or Experience Weighted average [8].

Additions & Optimizations
The library has some additions not found in other IEL models. Some are speed optimizations, and some give it extra flexibility for certain problem domains.

Fitness caching
In both GAs and IEL, the fitness function is traditionally the most computationally expensive step-often by multiple orders of magnitude. In a single GA, the fitness function is often constant. When it is, the GA automatically saves the fitness with each strategy, and reuses the value in subsequent periods.
Each iteration of the GA has the original population which survived the last iteration, and newly created children. With this fitness caching, fitness only has to be calculated for the children. The most common case is for the number of created

Repeat N times
The process is largely the same as for the single GA in Figure 2.1. The two main differences are that there is a stage for each population to choose a strategy for play each iteration, and that now multiple populations are updating rather than only one. Note that in the base version, all populations update, then all populations choose a new strategy for play. The selection method for choosing a strategy for play is typically very strong, with the default set to a size-4 tournament. The IEL acts to connect otherwise independent genetic algorithms. It drives the algorithm by requesting the GAs submit strategies for play, and sending them an individualized fitness function they can use to evaluate their strategies holding all other players' strategies constant. Otherwise, the GAs act independently, allowing for different settings (selection methods, mutation rates, etc.) as well as entirely different strategy spaces and representations. For example, one GA could represent a buyer, while another represents a seller, each with entirely different strategy spaces.
children to equal the size of the population, in which this case fitness caching reduces the number of fitness calculations in half.

Phenotype caching
Converting from a binary genotype to the representation can also require some computational time and can be cached with the strategy once it has been calculated. The benefit to this is that it can be used in both static fitness environments and ones where the fitness function changes each iteration. This means in IELs, the phenotypes of the previous population can be reused.
Because of phenotype caching, it is important that in an IEL, the phenotype contains all calculations that can be performed independently of what other GAs have chosen as strategies. In some cases with only light coupling between GAs, the vast majority of the calculations can be pulled out of the fitness calculation and into the genotype-to-phenotype conversion, yielding similar savings to fitness caching.

Count storage
Another important optimization is to realize that many strategies end up being copies of one another. By the end of a GA or IEL, on the order of half of the strategies in a population are not unique. To exploit this duplication, rather than storing an array of the strategies, the unique strategies are paired with the frequency in the population. Selection strategies are tasked with returning a new frequency list. This allows for phenotype calculations and fitness calculations to be only performed once per unique strategy.
While it is possible to do an additional optimization where once children are created, they are each compared to the existing population to see if there already exists an identical strategy, in practice this can be computationally expensive, and is frequently not worth it. Because of this, there is some inefficiency where there are multiple instances of the same strategy in the population due to these serendipitous copies.

Batching
The last two features are additional features, rather than optimizations. One potential problem in an IEL is that the updating is reliant on the strategies chosen by each sub-GA. If a GA submits a poor strategy, the other GAs will adapt accordingly, leading to setbacks in the convergence. In practice, having GAs only submit their best strategies largely eliminates this. However, as a precaution, the algorithm allows for batching.
With batching, each GA submits N strategies. These are paired up into N groups of strategy pairings, and the fitness of a strategy becomes the mean across the N . This sampling allows strategies to be evaluated on how well it performs against the pool of strategies the other GAs have, rather than just their best performing.
This process of batching is completely equivalent to only selecting one strategy per iteration, keeping a running total of the fitness, and only updating each population once every N iterations.

Sequential Updating
In some environments players take turns, rather than moving simultaneously. The IEL library allows for each GA to be assigned a priority. All GAs with the same priority update, and then submit new strategies.
Consider a scenario where there are buyers and sellers. Sellers each set a price, and buyers then choose how much purchase. In this, all buyers can be assigned an identical higher priority, and buyers assigned identical lower priority. Each IEL iteration, the sellers will update based on what the sellers and buyers chose the previous iteration, and submit new prices. The buyer then update based on these newly submitted seller strategies and the submitted buyer strategies the previous iteration.
Taken as a whole, the GA and IEL base of the library provides a relatively simple coding interface, high performance, and a wide array of features, many not found in any other implementation. This lets it serve as a strong core to the rest of the GENEE library, and also allows others to use it when implementing their own GAs and IELs.

Chapter 3 Auction Individual Evolutionary
Learning Suppose a bidder walks into the room where an auction for an item is being held and sees all the competing bidders. In a Bayesian Incomplete Information model, he knows how much he values the item at, and estimates a distribution of the value for each competing bidder. Furthermore, even though he knows his true value for the item being auctioned, he also estimates a distribution for his own value-this is the distribution the other bidders are assumed to ascribe to him. Given this, and assuming all bidders hold the same assumed distributions, an equilibrium bid function can be found for each bidder. The bid function, b i (v) for player i prescribes how much should be bid for each possible value draw, v.
To find the optimal bid function, consider a first-price sealed-bid auction. Let X i be the distribution of bidder i's value. Given the bid function Given this and our previous assumptions, we can write the expected profit of player i as: is the cumulative density function of B j .
Each bidder then has an objective to maximize this expected profit: Doing a simultaneous maximization leads to the equilibrium bid functions. Crucially, this is often not analytically tractable. It has been solved when value draws are symmetric between bidders [33], [24] for both risk neutral bidders as well as some risk averse bidders with some assumption. For asymmetric bidder, is has been solved when all values are drawn uniformly with the same lower support, or when the values are drawn uniformly with asymmetric value shifts [22]. Similar limitations exist in other auction types.

Previous Work
There has been some research into using computers to solve for the equilibrium bid functions. The greatest success has been by reducing the problem to a system of ODEs, and then employing various methods to solve them. Li and Riley [27] created a program BidComp to do this. And while it has high precision, it also carries significant assumptions, including: the auction must be first-price sealed-bid, value distributions must have the same support, and the value distributions must be orderable via stochastic dominance. It also has some inaccuracies at the endpoints of the function. Hubbard [19] surveys the literature of these systems of ODE solutions and describes the most modern techniques for solving them, but they all face similar constraints and assumptions that make the difficult to generalize to new auction types and more generalized utility functions and subjective probability functions.
There have also been a few attempts to solve for the bid functions using GAs and IEL. Andreoni and Miller [1], used a GA to solve symmetric first price auctions. They assumed the bid function to be linear (which is the case), and task the GA to find the slope. To evaluate the fitness, they used Monte Carlo simulations. While it was reasonably successful, it is limited to a very narrow set of problems.
Chernomaz generalized Andreoni and Miller by using an IEL, which allowed for asymmetric bidders [9]. He also generalized to allow quadratic functions. However, this is still a very strong constraint on the functional form, and he found that even allowing for quadratic functional forms led to inaccuracies when the underlying solution was actually linear.
French [16] generalized further by allowing for piecewise linear bid functions. With enough segments, the program was able to capably estimate non-linear bid functions.

Representation
A single strategy in the IEL represents a candidate bid function. Suppose we represent such a function by n floats, each being a sample from the function equally spaced To test whether sorting leads to better results, as well as configure other param- Sample C++ code running a first-price auction with 2 bidders drawing values from the standard uniform. There is much more boilerplate code than in the single GA, but, modifying the boilerplate for other auctions and player asymmetries is comparatively simple.
eters, the first-price sealed-bid auction is used as a baseline. The equilibrium bid functions are well known, and they are well understood to not be a strictly dominant strategy. This will lead to fluctuations from the equilibrium, allowing for a fair comparison on which model parameterizations lead to the great accuracy and precision. Next, the auction is created by passing in the value distributions. Additional optional arguments include utility functions and subjective probability functions. Finally, the individual GAs and the IEL driver are created. Once all that boilerplate is complete, the driver can run for a set number of rounds and the each GA can output their bid functions and estimated expected profit. Additionally, the auction can be queried for common auction metrics such as the expected value realized by each bidder and the auctioneer's expected revenue from each bidder.

Accuracy Metrics
French and Chernomaz both measured the accuracy of the estimated bid functions by using a continuous version of Root Mean Squared Error, D 1 , and Mean Signed Error, D 2 . They are given by the following equations: Together, D 1 will inform how close GENEE's result is to the theoretical equilibrium, and D 2 indicates whether there is any directional bias.

Initial Results
For initial testing, I ran a symmetric two-player first-price sealed-bid auction with draws from the standard uniform. For this, the equilibrium bid function is just b(v) = 0.5v. Each GA was configured to have 1000 strategies, and the bid functions is composed of 100 segments. Another open question is which selection mechanism is appropriate when sub-   mitting a strategy into the auction each iteration. Intuitively, we can expect that it is optimal to usually submit a high-fitness strategy. Submitting a low-performing strategy results in the other bidders adapting to the anomalous submission, setting back convergence. However, one reason GAs perform well is because they are not simply best-responders [2]. In fact, best response algorithms are notorious for getting stuck in cycles and never reaching an equilibrium. To test which submission technique is best, three methods are compared: a tournament selection with size 4, simply selecting the best strategy, and finally selecting the mode in the population. Table 3.1 provides estimates to the performance of each. Each method was averaged over 10 runs. In each run, the bid function over the last 100 iterations was averaged over, and D 1 and D 2 were calculated. Based on the results, simply submitting the best strategy yields the most accurate results, implying that the error caused by submitting poor strategies outweighs any costs of being nearer to naively best-responding. This is likely because even submitting the best strategy within the population is not the same as best responding, since the true best response is unlikely to be a member of the population.

Limitations
Now suppose a new bidder is added whose value distribution is drawn from a normal distribution X ∼ N (0.7, 0.2 2 ). Similar to before, Figure 3.5 shows the end average convergence. Theory states that bids should be higher than when all three draw from the standard uniform b U (v) = 2 3 v. This is because one bidder now has a higher value on average, and so the other bidders are facing more difficult competition and up their bids accordingly. This in turn makes the new bidder also bid above the base function.
Although the general behavior is reasonable, there are serious flaws in the result for the normally distributed bidder. At high values, the bid function increases well above the highest possible competing bid, which results in paying more without any increase in win probability. Equally distressing, on the very low end of the value range, the bidder bids above value. What can account for this?
It turns out the expected profit is changed very little by these mistakes. There is only a 0.1% chance of the bidder drawing a value below 0.1, and less than a 1% chance of winning with such values. And so bidding too much changes the expected profit by less than 0.001%. A similar argument can be made on the upper end of the distribution. Compared to getting better results near the center of the distribution, the tails represent rounding errors. Given a set of strategies, the likelihood that both the tails and center are improved is unlikely, and so the ones with the center are favored as long as the tails ends are not too egregiously wrong.
Even though it makes sense to not care about low probability events, we still expect the IEL to be able to solve such problems. It turns out that with some small modifications, it is possible to correct these tail-end values.

Independent Segment Representation
To resolve tail-end inaccuracies, consider the optimization problem faced by bidders again: The integral can be split over m equally spaced segments: The maximization can then be swapped with the summation: In this form, we now have the bid function split over m segments, each maximizing profit over a value range. This makes intuitive sense because once a value is realized, the bid should maximize profit for that value independently of the maximization over other value ranges. That means the bid function can be found via many independently optimizing GAs acting together. 3.6 shows how such a bid strategy might look. In this case, there are two GAs, one optimizing the bid function over the first half of the value range, and the other optimizing the other half. Each can sort the bids just as was done in the case with a single GA.
The benefit to doing this is that regions of the value domain with low probability While this would seem to imply more component GAs are always better, in prac-   Each cell represent a population size-component count pairing. In each scenario, 10 runs were performed, with D1 and D2 being calculated off the average bid function submitted over the last 100 iterations. Lighter colors denote closer to 0, which is better. There is a clear detriment from having either too many components/strategies, or too few, and a basin is apparent.
tice this is not the case. As the number of component GAs increase and the search space diminishes, the component GAs get to be too good, turning into little more than best responders. This leads to cycling and inaccuracies. So, there is a "sweet spot" for the number of components and the number of strategies. Figure 3.9 shows the accuracy for the 2-bidder symmetric first-price auction over a variety of combinations. In practice, it appears having more than 10 components will result in poor convergence.
However, it is not as simple as just picking the combination that has the lowest error in Figure 3.9. Figure 3.8 displays the effects of components on the asymmetric auction accuracy, which was the original motivation for the compositing. Here it is apparent that having additional components does help ameliorate tail-end inaccuracies. Therefore, the choice of number of components depends on the scenario. Luckily, even if imperfect, using 5-10 components with between 50-100 strategies per population proves to be very good in the practice. If higher precision proves necessary, then a simple search can be performed.

All Pay & Second Price Auction
We now expand our auctions to consider the all-pay sealed-bid auction, where the highest bidder receives the item, but all bidders must pay the bid they submitted, and the second-price auction, where the highest bidder receives the item but only pays the bid of the second-highest bidder. The all-pay is a trivial transform from the first-price auction, where the bid is now subtracted from expected profit in all cases, rather than being conditioned on winning. The second-price auction, although easier to solve theoretically (b(v) = v), is actually more complicated to implement computationally.
Suppose we have n draws from the same distribution X. If the draws are sorted from lowest to greatest, the kth lowest draw, the kth order statistic, is denoted X (k) .
Its cdf is given by: Prob(exactly i draws < y) To evaluate the expected profit in the second-price auction, a bidder needs to know the expected price conditional on winning with a bid. As an intermediary step, the highest order statistic of the opponents' bids is required. However, because the distribution of bids by each bidder is dependent on both the bidder's value distribution and the submitted bid function, both of which can be asymmetric across bidders, the order statistic needs to be calculated for non-identical distributions. Although cumbersome, this can be calculated.
Let C n k be the set of all combinations of k selections among n unique objects. Let c∈C n k be one such combination. Define c i to be a binary indicator for whether object i is selected in the combination c. It will be 1 if the object is selected in the combination, and 0 otherwise. Then, for n distributions, X 1 , X 2 , ...X n , cdf of the kth order statistic X (k) is given by: With this, the second-price auction can be evaluated.

Results
The three auction types-first-price (FPA), second-price (SPA), and all-pay (APA), were evaluated for environments with known solutions. Each was run with either 2 or 5 bidders, with each bidder drawing values symmetrically from a standard uniform.
The convergence can be seen in Figure 3.10.
In addition to the bid functions, GENEE can also output the bidders' profits, their realized values, and the auctioneer's expected revenue. The estimate for these auction attributes are shown in Table 3.2. They comport with the revenue equivalence theorem [30], which states that changing the auction type will not yield different revenues when bidders are symmetric and the auction mechanism is efficient.

Conclusions
Building off of French's work and the IEL library, the GENEE library has been shown to provide highly accurate estimates to auctions with known solutions. The predicted revenues and efficiencies also comport with theory.
Unlike previous attempts however, the GENEE library can handle multi kinds of auctions such as the second-price and all-pay auctions, and can provide estimates for more exotic environments, with non-linear utility functions and subjective probability functions, as well as asymmetric value distributions with differing supports. The flexibility extends past even this, enabling auctions with multiple items and bidders with completely different representations. There has been considerable research into these auctions. Feldman et al. [15] proved that when values are non-complementary the efficiency of simultaneous firstprice auctions is at least 50%, and the efficiency of second-price auctions is at least 25%. Unfortunately, Cai and Papadimitriou [7] were able to prove that finding a Nash equilbrium bid function in first and second price simultaneous auctions is NP-hard.
Even worse, they were able to prove even finding an -approximate equilibrium is NP-hard in the case of second-price auctions 1 . While still unproven, it is strongly suspected that first-price auctions suffer the same restriction.
Cai and Papadimitriou aptly summed up the hopelessness of finding the equilibrium bid strategies by writing, "even recognizing a Bayesian Nash equilibrium is intractable." A strategy for a component GA is a region in v A ×v B space, and contains the same region in both item bid functions. This is required because the expected profit of bid function A in a value region depends on the bid function of B over that same region, and vice versa.

Extending GENEE
While the problem does quickly become intractable as the number of items being sold increases, it is still manageable with only 2 items. To implement it, GENEE must be extended beyond 1-dimensional functions.

Expected Profit Calculations
The expected profit calculations, while computationally cumbersome, are not especially more complicated conceptually than the single-item case. Given player i's bid , let B i represent the joint distribution of the bids. Given this, its cdf is defined as: bidders on both items. This is calculated by: Meanwhile, the probability of winning only item A is the probability of outbidding all bidders on A, but not winning B, , P (A ∩ B). It can be calculated with the following: The probability of only winning item B can be calculated similarly to only winning item A. Winning no item is just 1 subtracted by the other three probabilities. With all these probabilities, the expected profit can now be calculated 2 :

Accuracy Measurement
The final step is to extend the accuracy measurements, D1 and D2 to handle 2dimensional bid functions. In this case it is a simple matter of replacing the single integral with a double integral. Additionally, each bid function, b A (v A , v B ) and b B (v A , v B ), will be measured independently.
Note that the bids are both functions of the values, but the notation was suppressed for clarity.

Results
Recall that it is assumed bidders receive the value for the item if only 1 item is one, but receive g(v A , v B ) if both items are won. Three different non-complementary value functions were explored: The additive valuation serves as a baseline and will be addressed first.

Dating Game
Now suppose g(v A , v B ) = 0. This means that if a bidder wins one item, they receive it's value, but if they win both, they receive nothing. Such a function is admitted contrived, but a plausible scenario is that of dating. Expending resources in the pursuit of multiple lovers can be conducted, but in this model, being successful with both ultimately leads to rejection by both.
Intuitively, we would expect the bidder to focus on item with the higher value draw, and bid low enough to not win the other item, perhaps even going as far as bidding nothing on it. A naive approximation would be: Which just says to only bid when the value for item A exceeds that of item B, and when bidding, bid a average of the single-item equilibria weighted by the probability of that many other bidders choosing to bid on item A. With symmetric uniform draws and 4 bidders, this works out to be: This is just a first-order naive approximation. The actual solution remains an open question in the literature. Figure 4.5 shows what GENEE converges to in the 4bidder scenario. It finds that the bidders do bid on both items sometimes, as long as they believe there is a significant probability of losing the item they value more. In fact, it is observable that conditioned on the value of item A, the bid on A is strictly non-increasing with value for B. This is means that as their value for B increases, and thus they bid more on item B, the probability of winning B increases, and in turn the expected profit from winning item A decreases, finally leading to a decrease in the bid on item A.
The maximum bid is 0.67, slightly higher than the naive estimate, which is expected given that bidders sometimes bid on both item, leading a higher expected number of competitors.

-Bidder Dating Game
A particularly notable result is the discontinuity around v A = v B = 1. Currently, GENEE does not support discontinuities. The best it can do is drop from 1 to 0 across a single segment, which looks similar. With this simulation having 60-by-60 segments, the quickest it could switch between items is over a ∆v = 1 60 ≈ 0.01667.

Figure 4.6: 4-Bidder with Perfect Substitues
Note that this lacks the discontinuity found in the Dating Game and is instead smooth over the domain. Also, the maximum bid is about 0.68, slightly higher than the Dating Game, but much closer to it than the additive values maximum of 0.75.

Perfect Substitutes
Finally, suppose g(v A , v B ) = max(v A , v B ). In this case, the items are perfect substitutes, and the bidder only receives value equal to the most valuable item. This is perhaps the best approximation of some of the bidders in the New Zealand Spectrum auction. Many only need on spectrum license, and so winning multiple wastes money.
Once again, there is no theory on how to bid in such an environment, but it should lie somewhere between the additive values and dating game behavior.

Estimated Auction Attributes
While the bid behavior in different scenarios is interesting in and of itself, of greater interest are estimates for the auction properties such as efficiency and auctioneer revenue. From the model, revenue, profit, and realized value can be directed extracted.
By running Monte Carlo simulations to determine the expected maximum attainable value, efficiency can be calculated.  From these, it is apparent that very little efficiency is lost in any of the 2-item environments, but the loss is non-zero. The loss occurs in the subadditive parameterizations during situations such as when the buyer with the highest value on A has an even higher value on B, but not the highest, and so underbids on A, and loses it to someone with a lower value for it, but no value for B.
Auctioneer revenue suffers greatly as the number of bidders approach the number of items, becoming even lower as valuations for the pair decrease. This might provide some insight into the revenue shortcomings of the New Zealand spectrum auctions.
A lack of bidders resulted in lower and perhaps fewer bids to avoid accidentally overpurchasing.

Conclusions
Extending GENEE to support 2-dimensional bid functions empowers it to tackle auctions with scant theoretical predictions. It was able to provide point estimates to the auction performance where none was previously available, and could only have been estimated through experiment data.
This also provides a base that can be built on to examine not just simultaneous second-price auctions, but also auctions with complementary values and the submission of combinatorial bids (a bid which demands either both items or none).

Chapter 5
Common Value Auction with

Multiple Signals
Consider an auction to lease a gold mine. The gold mine has the same value, v, to all bidders, but each bidder has a different signal, s, as to the mine's value. How should they bid? First, suppose each signal is unbiased, such that E(v|s) = s. Additionally, assume all bidders simply submit their expected value as their bid. It turns out that even though each bid is an unbiased estimate, the highest estimate among them is biased upwards. Because of this, the winner of the auction will on average overpay for the lease. This phenomena is known as the Winner's Curse, and is prevalent in practice. To avoid it, bidders must recognize that E(v|s = s max ) < E(v|s), and adjust their estimate of, v, downwards by accounting for this fact that winning implies their estimate was highest.

Single-Signal Scenario
To give the scenario concreteness, suppose the true value, v, is drawn uniformly in Wilson first solved for the bid function [34], and Milgrom and Weber [29] as well as Levin et al. [26] developed it further. Before turning to more complicated variants, it will be instructive to use GENEE to reproduce the theoretical predictions and ensure it works in this auction environment.
The expected profit of a bidder is given by: While this integral can be evaluated easily enough, it cannot be split up in the signal space, a requirement for running GENEE with component GAs. To remedy this, the integral is rewritten as follows: E(π(b i (s))) = 9500 500 500 −500 This integral has the signal, s, only vary through the outer integral, and allows for a region of the bid function to be evaluated independently of other regions. Also note that while this requires double integration, the bid function is only 1-dimensional, so while some of the procedures developed in chapter 4 are useful, the process is more akin to that seen in chapter 3. The algorithm successfully models all regions except the lower endpoint. This is solved by avoiding it. For the remainder of the chapter, the model will focus on solving the center region of the bid distribution. This has been done elsewhere in the literature [21], and allows for a much simpler model. In the center signal region, the relative bid, (r i (s) = b i − s), reduces to a constant, since the actual value conveys no special information.
It is important to note that this reduction only holds because of our assumption of operating sufficiently far from the endpoints. At the endpoints, some bidders may receive signals outside the value range, allowing for a more precise estimate of the value. Bidders with signals near the value endpoints must adjust their bids to account for the possibility of competing bidders receiving these more informative signals. This then propagates to bidders further from the endpoints who react to these changes in bidding. This is visible in Figure 5.1 (b), where the signal region s > 1000, in which the true value cannot be at the endpoint, exponentially decays towards discounting  the observed signal by a fixed amount of 500. Note that this fixed discount region not only avoids the Winner's Curse in expectation, but actually reduces its possibility of occurring to zero.
With this admittedly strict assumption of operating near the center of the signal domain, the bid function reduces to a single relative bid value, r i , and the expected profit equation can be reduced to the following: Notice that because the signal value does not affect the relative bid, the expected profit is reduced to only integrating over the domain of possible errors, and the true value can be normalized to zero. This simplified version is easy to solve for by modifying GENEE to support estimating point bids.

Multiple Signal Scenario
Now suppose a more realistic environment where bidders must pay for signals, rather than being endowed with them exogenously. Prior to observing any signals, a bidder must decide how many signals to purchase between 1 and 5. Each signal is still drawn with an error uniformly distributed in [−500, 500].
As established in Cox and Haynes [10], the sufficient statistics for multiple draws from a uniform are the minimum and maximum draws, and draws between the minimum and maximum provide no additional information. In the general case, bids are a function of both the precision and midpoint, b i (m, p).
However, from the assumption previously stated that we are far from either endpoint, the relative bid function, r i (m, p) = b i (m, p) − m, does not depend on the midpoint, reducing to just r i (p). Given this, we can write the expected profit equation as follows (normalizing the midpoint to 0): The joint pdf of the midpoint and precision, f (m, p), can be calculated from the joint order statistic of the min and max draws.

Model Results
With  After running GENEE for all 70 signal scenarios, the value of signals can be estimated. In each signal scenario, the profit of each bidder is estimated. If increasing  Conditional on a precision, the triangle denotes the possible midpoints relative to the true value. Adding r i (p) to this distribution of possible midpoints at that precision provides the distribution of bids relative to the true value. This is indicated in the graphs via shading. Any shading above the zero line indicates a possibility of falling victim to the Winner's Curse. Note that in (a) Bidder 1, who only has 1 signal, is shown as a bullet in the bottom left-hand corner. Because this bidder only has one signal, precision will always be 0. In all scenarios, conditional on a precision, bidders with more signals bid less than those with fewer. However, it is important to remember that those with more signals have a higher expected precision, so they are more often operating on the right-hand side of the graph, where bids are higher on average.
the signals purchased by 1-while holding all other bidder signal purchases constantincreases the expected profit of the bidder by more than the cost of the signal, the bidder would prefer to have purchased an additional bid. The reverse is true when determining whether the bidder would have preferred to have purchased fewer signals.
If no bidder would have preferred to change from the purchased number of signals, then that signal scenario is an equilibrium.

Experiment
An experiment was performed to evaluate people's behavior in the environment. Each auction had 4 bidders, values and signals were drawn in accordance to the model denominated in cents. Therefore, the minimum value in an auction was $5.00, and the maximum possible value was $95.00. Signals were within $5.00 of the true value in either direction. The cost of a signal was set to 10 cents.

Procedure
A full description of the procedure can be found in Deck et al. [12]. Briefly, each session had 12 subjects. Subjects competed in 30 auctions and were paid their cumulative earnings. Subjects were given an endowment of $25.00. Auction losses and the costs of purchased signals were deducted from the endowment. Subjects received a $7.00 participation payment in addition to their earnings, which averaged $12.13 1 .
At the start of each auction, subjects were randomly and anonymously placed in groups of 4. First, each bidder simultaneously decides how many signals to purchase.
Next, each bidder was informed of the information contained in their own signals and the number of signals acquired by the other 3 bidders in the auction (but not the   The average winner fell prey to the Winner's Curse and lost substantial sums. Interestingly, due to their propensity towards overbidding, the value of signals is substantially higher than the model suggested. realization of those signals). Then the actual auction occurred. Finally, the auction results were displayed to everyone as was the true value of the asset to enhance transparency.

Results
The auctions were filtered to those with true values between 1000 and 9000. Figure   5.6 shows how subjects bid in the auction. Both eventual winners and losers risked falling prey to the Winner's Curse a majority of the time. On rare occasions, bidders even placed bids above the maximum possible value based given their signals, even though the experiment's interface provided the allowable range of the true value given signals.  Conditional on winning, signals increased expected profit significantly more than was predicted in the model. However, this does not mean we would expect subjects to purchase more signals than originally predicted. To see why, consider a rational bidder in this auction, armed with Table 5.1 and Figure 5.6. Given that the winning bid is usually above the true value, the expected probability of winning at a price below the true value is rather low, leading the rational bidder who does not overbid to "lose" most of the time. Given such a situation, signal purchasing is largely a waste of money for such a bidder.
Bidders who do win may or may not benefit from signal purchasing. Clearly, conditional on winning, signals help stem the bleeding. However, purchasing additional signals could lead to lower overall profit if it increases the likelihood of winning. Ultimately, Figure 5.7 shows the average number of signals purchased each auction, and the average remains steady across time at about 1.7 signals per bidder, per auction, not far in aggregate from the Nash equilibrium of 2 signals per bidder.

Conclusions
The GENEE library proved invaluable in evaluating such a complex environment.
Not only was it able to provide estimates to the equilibrium bid functions, but it was also able to estimate the values of signal purchasing, leading to the solving of the meta-equilibrium of signal purchasing.
A clear next step is to relax the assumption that the true value is far from the endpoints. Handling this more general case allows for more precise estimates of the value of signals, and for more observations from the experiment to be analyzed. However, it remains to be seen whether the expected profit can be calculated quickly enough to be practical, or if the functions can converge reliably at the lower endpoint.

Chapter 6
Conclusions I have created a computational program that provides significant value to the field of mechanism design. It contributes a generalized implementation for both genetic algorithms and individual evolutionary learning that can be reused for other applications. More importantly, it provides a robust library of tools to evaluate many forms of auctions, both common and more exotic.
Furthermore, it allows for more complex bidder behavior, with asymmetric value draws, non-linear utility functions and subjective probability functions allowable.
This alone opens the doors to computational investigations of auction domains that were previously impossible to explore in any systematic way.
Because the computational evaluation of equilibrium bid functions has remained largely unexplored beyond that of simple asymmetries in first-price auctions, the avenues for future research is vast. The most obvious routes would be to apply it to more parameterizations, such as superadditive values in the simultaneous first-price auction environment. Another route is to extend GENEE to work with more auction mechanisms, such as randomized auctions, where the auctioneer chooses a mechanism (first-price, second-price, all-pay, etc.) at random after bids are submitted. Another possible auction extension would be the simultaneous second-price sealed bid auction, or to allow combinatorial bids in all the simultaneous auctions.
Besides extensions, there are also many potential routes to improve the underlying library. Auction processing speed can likely be improved by shifting some calculation to the GPU, and special case algorithms may exist that can improve evaluation of certain auctions. But beyond just speed enhancements, some options I passed on, such as cubic interpolation and Monte Carlo evaluation of the expected profit function, are still worth being investigated. An even more dramatic change would be to replace the Individual Evolutionary Learning backend with an alternative such as adversarial neural networks. Such changes would have dramatic effects on convergence speed and accuracy, possibly for the better. A final possible change would be to add hooks for the library into higher-level programming languages such as Python to increase accessibility to other researchers.
Even without these potential extensions and improvements, the tool stands on its own, having already provided unique results that no alternative method can currently generate, including the simultaneous first-price auction and the common value auction with asymmetric signals. The fact the same algorithm can estimate the Nash equilibrium bid functions in these vastly different scenarios is a testament to its flexibility, and bodes well for its continued use in the field.