In [1]:

```
%matplotlib inline
from IPython.core.display import HTML
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
from pandas import DataFrame, Series
matplotlib.rcParams.update({'font.size': 16})
```

The Iowa Electronic Markets are small, real-money financial markets designed to aggregate information about future events. The market microstructure of these markets is studied and a market making model is developed to provide liquidity for one set of securities offered by this exchange. A computer program was created to employ the market making model and profit from the market's inefficiencies. Using invested capital, the system traded 34% of the total market volume and achieved a Sharpe ratio of 9.9. This paper reveals the details of how this algorithmic trader worked to show how it functioned and the value it added to the Iowa Electronic Markets.

- The 2008
*Winner Takes All*Presidential Election financial market had two securities:- representing the Democratic candidate (
*DEM*), Barack Obama - representing the Republican candidate (
*REP*), John McCain

- representing the Democratic candidate (
- There were no explicit transaction costs from trading these securities in this market
- At maturity, each security pays \$1 if the security's candidate wins and \$0 if the candidate loses
- For these securities, a win is when the candidate captures more votes than his opponent as reported by The New York Times three days after the election and is not based on the electoral college

- Since there can be only one winner, the total payout of both securities at maturity is guaranteed to be equal to \$1.
- To avoid arbitrage, the value of the two securities together must also be equal to \$1 for all times before maturity, ignoring any discount functions
Price movements must be inversely correlated because when the value of one security goes up, the other must go down

- Although there are two securities, this market has only one risk factor and one real asset
- Buying one security is the same as selling the other

*securities*= one of the two securities representing the two candidates*asset*or*market asset*= the one true asset that is is traded in this market

A long position in the market asset is defined as a long position in the Democratic candidate and a short position in the Republican candidate, and a short position in the market asset is the opposite.

- Three pieces of price information for each security; the bid price, the ask price, and the last trade price
- Minimum tick size for all prices is one tenth of a penny
- The last trade size, bid size, and ask size are not disclosed

In [2]:

```
# price diagram code
def price_diagram(data, labels, colors, xsteps):
sec1 = [(xsteps[0], data[0, 0] - xsteps[0]), (data[0, 1], xsteps[1] - data[0, 1])]
sec2 = [(xsteps[0], data[1, 0] - xsteps[0]), (data[1, 1], xsteps[1] - data[1, 1])]
xlabels = np.arange(xsteps[0], xsteps[1] + 0.001, xsteps[2])
xlim = np.arange(xsteps[0], xsteps[1], xsteps[2])
fig, ax = plt.subplots()
fig.set_size_inches((10, 1.5))
ax.broken_barh(sec1, (21, 8), facecolors=colors[1], alpha=0.5)
ax.broken_barh(sec2, (11, 8), facecolors=colors[0], alpha=0.5)
ax.set_ylim(5,35)
ax.set_xlim(*xsteps[:2])
ax.set_xticks(xlabels)
ax.set_xticklabels(xlabels)
ax.set_xlabel('Price')
ax.set_yticks([15,25])
ax.set_yticklabels(labels)
ax.grid(True)
return HTML('<center>' + DataFrame(data,
index=reversed(labels),
columns=['BID', 'ASK']).to_html() +
'</center>')
def DEM_REP(data, xsteps=(0, 1, 0.1)):
return price_diagram(np.array(data),
labels=['REP', 'DEM'],
colors=['red', 'blue'],
xsteps=xsteps)
def DEM_REPinv(data, xsteps=(0, 1, 0.1)):
data = np.array(data)
data_inv = np.array([data[0, :], (1 - data[1, 1], 1 - data[1, 0])])
return price_diagram(data_inv,
labels=['REPinv', 'DEM'],
colors=['red', 'blue'],
xsteps=xsteps)
def Good_Bad(data, xsteps=(0, 1, 0.1)):
data = np.array(data)
data_inv = np.array([data[0, :], (1 - data[1, 1], 1 - data[1, 0])])
data_gb = np.array([(max(data_inv[:, 0]), min(data_inv[:, 1])),
(min(data_inv[:, 0]), max(data_inv[:, 1]))])
if data_gb[0, 0] < data_gb[0, 1]:
return price_diagram(data_gb,
labels=['Bad spread', 'Good spread'],
colors=['brown', 'green'],
xsteps=xsteps)
else:
return price_diagram(data_gb,
labels=['Bad', 'Good spread (crossed)'],
colors=['brown', 'green'],
xsteps=xsteps)
```

In [3]:

```
DEM_REP([(0.572, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[3]:

BID | ASK | |
---|---|---|

DEM | 0.572 | 0.602 |

REP | 0.424 | 0.450 |

Subtracting the REP bid-ask prices from 1 yields bid-ask prices for REPinv:

In [4]:

```
DEM_REPinv([(0.572, 0.602), (0.424, 0.45)], xsteps=(0.5, 0.7, 0.05))
```

Out[4]:

BID | ASK | |
---|---|---|

DEM | 0.572 | 0.602 |

REPinv | 0.550 | 0.576 |

REPinv has the same market exposure as DEM.

Notice that the REP bid price determines the REPinv ask price, and the REP ask price determines the REPinv bid price.

- The IEM allows market participants to buy and sell
*bundles*of securities with the exchange itself for a fair price of \$1- A bundle is the pair of securities DEM and REP

- This allows a trader two alternatives to trade into a position:
- buy the one security they want
- buy bundles and then sell the other undesired security

- bid price is the maximum of the DEM and REPinv bid prices
- offer price is the minimum of the DEM and REPinv offer prices

If a trader wanted to trade in this market it would be efficient and rational for them to only trade using the asset's true bid and ask prices. These two prices make up what can be considered to be the **good spread** and the other two prices make up the **bad spread.**

In [5]:

```
Good_Bad([(0.572, 0.602), (0.424, 0.45)], xsteps=(0.5, 0.7, 0.05))
```

Out[5]:

BID | ASK | |
---|---|---|

Good spread | 0.572 | 0.576 |

Bad spread | 0.550 | 0.602 |

This pricing methodology does not allow arbitrage, but when the good spread is crossed (the bid is greater than the ask), the fair price is undefined.

- It would be inefficient for a trader to use a market order to buy the market asset on the bad offer or sell the market asset at the bad bid
- Doing so would be considered a
*price-taking violation of individual rationality*, as discussed in Oliven and Rietz (2004)- The researchers found that in the 1992 Presidential election, 37.7% of market orders made this error

In [6]:

```
report = pd.read_csv("daily_report.csv")
report.set_index("Date", inplace=True)
rollingwindow = 7
sumRR = report.sumRR.cumsum().diff(rollingwindow)
sumR = report.sumR.cumsum().diff(rollingwindow)
sigma=(sumRR/(rollingwindow*96) - (sumR/(rollingwindow*96))**2)**0.5 * 96**0.5 * 100
report['Volatility'] = sigma
report["Total Profit"] = report["Total Profit"].cumsum()
report["MM Profit"] = report["MM Profit"].cumsum()
report["Arb Profit"] = report["Arb Profit"].cumsum()
report["Spread Profit"] = report["Spread Profit"].cumsum()
report["Positioning Profit"] = report["Positioning Profit"].cumsum()
def activity_plot(fields, styles):
fig, ax = plt.subplots()
fig.set_size_inches((12, 8))
for field, style in zip(fields, styles):
report[field].plot(style=style, label=field)
ax.set_xlabel('Date')
ax.grid(True)
plt.legend(loc=2)
```

Plots of Market Activity during the time of this research project.

In [7]:

```
activity_plot(["Mid Price"], ["r"])
```

In [8]:

```
activity_plot(["Volatility"], ["r"])
```

In [9]:

```
activity_plot(["Good Spread", "Bad Spread"], ["green", "brown"])
```

In [10]:

```
activity_plot(["Total Market Value", "My $ Traded"], ["k", "r"])
```

- In this market it is possible for arbitrage opportunities to arise
- Oliven and Rietz (2004):
*market-making violation of individual rationality*- A trader adds a limit order to one of the order books that causes the good spread to become crossed
- A crossed market is when the bid price exceeds the ask price

For example, in this market:

In [11]:

```
DEM_REP([(0.572, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[11]:

BID | ASK | |
---|---|---|

DEM | 0.572 | 0.602 |

REP | 0.424 | 0.450 |

In [12]:

```
DEM_REPinv([(0.572, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[12]:

BID | ASK | |
---|---|---|

DEM | 0.572 | 0.602 |

REPinv | 0.550 | 0.576 |

A DEM bid of 0.580 would have this result:

In [13]:

```
DEM_REPinv([(0.58, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[13]:

BID | ASK | |
---|---|---|

DEM | 0.58 | 0.602 |

REPinv | 0.55 | 0.576 |

In [14]:

```
Good_Bad([(0.58, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[14]:

BID | ASK | |
---|---|---|

Good spread (crossed) | 0.58 | 0.576 |

Bad | 0.55 | 0.602 |

In [15]:

```
DEM_REP([(0.58, 0.602), (0.424, 0.45)], xsteps=(0.3, 0.7, 0.05))
```

Out[15]:

BID | ASK | |
---|---|---|

DEM | 0.580 | 0.602 |

REP | 0.424 | 0.450 |

- The absence of displayed order sizes in this market creates the potential for traders to game this market or behave in a way that frustrated the system's ability to determine the efficient price of the market asset.
- A limit order for one share appears to other market participants appears similar to limit orders for larger sizes.

- Do traders place one share orders in an attempt to alter other market participants' perception of current prices?
- It is clear that traders placed one share orders with some frequency because sometimes those market participants would also inadvertently create an arbitrage opportunity.
- About 10% of the system's 1,267 arbitrage attempts resulted in a trade of only one bundle, indicating that the smaller order for the two securities was for one share.

- Is it a trader's attempt to draw more favorably priced orders to the opposite side of the order book they intend to trade?
- Are there politically motiviated traders attempting to alter the market price?

Consider an exponential utility function to evaluate changes in wealth, W:

$$U(W) = -e^{-\lambda W}, \lambda > 0$$Assume that $W$ is distributed normally with a mean of $\mu$ and a variance of $\sigma^2$. The expectation of $U(W)$ is then given by:

$$\mathbf{E}U(W) = \frac{1}{\sigma \sqrt{2\pi}} \int_{-\infty}^{\infty} -e^{-\lambda W} e^{-\frac{(W-u)^2}{2\sigma^2}} dW$$By re-arranging the terms and employing calculus, one can reduce this to:

$$\mathbf{E}U(W) = -e^{-\lambda (\mu - \frac{\lambda \sigma^2}{2})}$$Maximizing the expected utility of changes in wealth $W$ is then equivalent to maximizing the expression

$$\mu - \frac{\lambda \sigma^2}{2}$$The exponential utility function is equivalent to the mean variance utility function when changes in wealth are normally distributed.

We can then write the market making model's utility function as:

$$U(W) = \mathbf{E}[W] - \frac{\lambda}{2} \mathbf{Var}[W]$$The market maker can estimate the expected increase in wealth when it buys a security on its bid price or sells at its ask price:

$$\mathbf{E}[W] = s \left | X \right | - G(Z)(X+A-D)$$where:

- $Z$ is the total size of the counterparty's trade, which may be partly or completely filled by the market maker.
- $A$ is the market maker's current position before the trade
- $D$ is the desired position, making the difference $A-D$ the current undesired position.
- $X$ is the potential alteration to the market maker's portfolio, which will be positive (negative) when the market maker is buying (selling).
- $s$ is market maker's per-share compensation for altering its portfolio, aka the spread
- The total compensation $s \left | X \right |$ is positive when buying or selling.

- The function $G(Z)$ is a function modeling the permanent impact of the trade.

If:

- $P_{post}$ is the market asset's efficient price sufficiently far enough into the future after the trade that the temporary impact has completely decayed
- $P$ is the price immediately before the trade

Then:

function $G(Z)$ becomes an estimate of the price change $P_{post} - P$:

$$G(Z) = P_{post} - P$$The function $G(Z)$ must be linear in $Z$ to enforce a *no arbitrage* condition on the market.

The linear market impact model is:

$$\frac{P_{post} - P}{P} = \gamma Z$$Market impact is then a linear function of the constant $\gamma$.

Defining $Y=Z-X$ as the estimated size of the trade filled by other market participants at the same price, the market impact function $G(Z)$ becomes

$$G(Z) = \gamma P (X + Y)$$The estimate of the expected profit from a buy or sell trade is:

$$\mathbf{E}[W] = s \left | X \right | - \gamma P (X + Y)(X+A-D)$$The variance of the expected increase in wealth comes from the variance of changes in the undesired position value, including the new position $X$. The market making model can estimate the variance of net wealth as:

$$\mathbf{Var}[W] = (\sigma \sqrt{t} P(X+A-D))^2$$where:

- $P$ is the efficient price of the market asset
- so the quantity $P(A-D+X)$ is the value of the new undesired position measured in dollars.
- notice that $X$ can increase or decrease the variance of the market maker's position, depending on the value of $A-D$.

- $\sigma$ is the estimated one-day volatility of the market asset
- $t$ is the expected time in days the market maker will hold the position before receiving an offsetting trade.
- volatility scales by the square root of time.

Substituting $\mathbf{E}[W]$ and $\mathbf{Var}[W]$ into the utility function $U(W) = \mathbf{E}[W] - \frac{\lambda}{2} \mathbf{Var}[W]$ yields:

$$\mathbf{U}(W) = sX - \gamma P (X + Y)(A-D+X) - \frac{\lambda}{2} (\sigma \sqrt{t} P(A-D+X))^2$$To find the optimal number of shares the market maker would be willing to buy or sell at a price earning a spread of $s$, simply calculate the first derivative of $\mathbf{U}(W)$, set the result equal to zero, and solve for $X$.

The optimal number of shares for the market maker to be willing to buy on the bid or sell at the offer becomes:

$$X_{bid} = \max\Biggl[0, \frac{s - \gamma P (Y + A - D) - \lambda \sigma^2 t P^2 (A - D)}{2 \gamma P + \lambda \sigma^2 t P^2}\Biggr]\\ X_{ask} = \max\Biggl[0, \frac{s - \gamma P (Y - A + D) + \lambda \sigma^2 t P^2 (A - D)}{2 \gamma P + \lambda \sigma^2 t P^2}\Biggr]$$Interactive Model to help visualize the model available here

In [16]:

```
activity_plot(["Total Profit", "MM Profit", "Arb Profit"], ["k", "r", "b"])
```

In [17]:

```
activity_plot(["MM Trades", "Arb Attempts"], ["k", "r"])
```

- The spread profit is the profit the market making algorithm earns from buying at prices less than the mid price and selling at prices higher than the mid price. Spread profits accumulate with every market making trade.
- The positioning profit is the profit the algorithm earns from favorable price movements of its asset holdings. Positioning profits accumulate inbetween market making trades.

Which will be greater: spread profits or positioning profits?

In [18]:

```
activity_plot(["MM Profit", "Spread Profit", "Positioning Profit"], ["r", "k--", "b--"])
```

- How does the structure of the Iowa Electronic Markets create trading opportunities?
- Compare/contrast with other markets
- How did I benefit this market and its goal of aggregating information?
- Did human traders benefit from my presence in this market? Was there any harm?
- Implementation details
- What about 2004, 2012, and 2014?